rubico 2.10.0 → 2.12.1

package/every.js

@@ -51,18 +51,22 @@ const _every = function (collection, predicate) {
  * ```
  *
  * @description
- * Test a predicate concurrently across all elements of a foldable, returning true if all executions return true.
+ * Tests a predicate concurrently across all items of a foldable. Returns true if every item tests true by the predicate.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
  *
- * console.log(
- *   every([1, 2, 3, 4, 5], isOdd),
- * ) // false
+ * {
+ *   const array = [1, 2, 3, 4, 5]
+ *   const isEveryNumberOdd = every(array, isOdd)
+ *   console.log(isEveryNumberOdd)
+ * }
  *
- * console.log(
- *   every([1, 3, 5], isOdd),
- * ) // true
+ * {
+ *   const array = [1, 3, 5]
+ *   const isEveryNumberOdd = every(array, isOdd)
+ *   console.log(isEveryNumberOdd)
+ * }
  * ```
  *
  * The following data types are considered to be foldables:
@@ -74,29 +78,19 @@ const _every = function (collection, predicate) {
  *  * `object with .reduce method`
  *  * `object`
  *
- * `every` works for async generators.
- *
- * ```javascript [playground]
- * const asyncNumbers = async function* () {
- *   yield 1; yield 2; yield 3; yield 4; yield 5
- * }
- *
- * every(asyncNumbers(), async number => number < 6).then(console.log) // true
- * ```
- *
  * `every` supports a lazy interface for composability.
  *
  * ```javascript [playground]
  * pipe([1, 2, 3], [
  *   every(number => number < 5),
- *   console.log, // true
+ *   console.log,
  * ])
  * ```
  *
- * Any promises passed in data argument position are resolved for their values before further execution.
+ * If the foldable is a promise, it is resolved for its value before further execution for the eager interface only.
  *
  * ```javascript [playground]
- * every(Promise.resolve([1, 2, 3, 4, 5]), n => n < 6).then(console.log) // true
+ * every(Promise.resolve([1, 2, 3, 4, 5]), n => n < 6).then(console.log)
  * ```
  *
  * See also:

package/filter.js

@@ -96,14 +96,24 @@ const _filter = function (value, predicate) {
  *   value any,
  *   indexOrKey number|string|any,
  *   filterable Filterable,
- * )=>(condition Promise|boolean)
+ * )=>(booleanResult Promise|boolean|any)
  *
- * filter(filterable Promise|Filterable, predicate SyncOrAsyncPredicate) -> result Promise|Filterable
- * filter(predicate SyncOrAsyncPredicate)(filterable Filterable) -> result Promise|Filterable
+ * filter(filterable Promise|Filterable, predicate SyncOrAsyncPredicate) -> filteredFilterable Promise|Filterable
+ * filter(predicate SyncOrAsyncPredicate)(filterable Filterable) -> filteredFilterable Promise|Filterable
  * ```
  *
  * @description
- * Filters out elements from a filterable. Returns a filterable of the same type. The order of the elements in the filterable is preserved.
+ * Filters out items from a filterable, returning a filtered filterable of the same type. The order of the items of the filterable is preserved.
+ *
+ * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
+ *
+ * const array = [1, 2, 3, 4, 5]
+ *
+ * const filteredArray = filter(array, isOdd)
+ *
+ * console.log(filteredArray)
+ * ```
  *
  * The following data types are considered to be filterables:
  *  * `array`
@@ -114,12 +124,12 @@ const _filter = function (value, predicate) {
  *  * `object with .filter method`
  *  * `object`
  *
- * The filtering operation is defined by a given predicate function. The predicate function dictates whether a given element from the filterable should be included in the returned filterable.
+ * The filtering operation is defined by the predicate function, which determines whether a given item from the filterable should be included in the filtered filterable.
  *
  * ```javascript
- * const predicate = function (element) {
- *   // condition is the boolean result of the predicate test on element
- *   return condition
+ * const predicate = function (item) {
+ *   // booleanResult is the boolean result of the predicate
+ *   return booleanResult
  * }
  * ```
  *
@@ -127,142 +137,94 @@ const _filter = function (value, predicate) {
  *
  * If the filterable is an array:
  * ```coffeescript [specscript]
- * predicate(element any, index number, filt Array) -> condition Promise|boolean|any
+ * predicate(item any, index number, filterable Array) -> booleanResult Promise|boolean|any
  * ```
  *
  * If the filterable is a set:
  * ```coffeescript [specscript]
- * predicate(element any, element any, filt Set) -> condition Promise|boolean|any
+ * predicate(item any, item any, filterable Set) -> booleanResult Promise|boolean|any
  * ```
  *
  * If the filterable is a map:
  * ```coffeescript [specscript]
- * predicate(element any, key any, filt Map) -> condition Promise|boolean|any
+ * predicate(item any, key any, filterable Map) -> booleanResult Promise|boolean|any
  * ```
  *
  * If the filterable is a generator:
  * ```coffeescript [specscript]
- * predicate(element any) -> condition Promise|boolean|any
+ * predicate(item any) -> booleanResult Promise|boolean|any
  * ```
  *
  * If the filterable is an async generator:
  * ```coffeescript [specscript]
- * predicate(element any) -> condition Promise|boolean|any
+ * predicate(item any) -> booleanResult Promise|boolean|any
  * ```
  *
- * If the filterable is an object with a `.filter` method, the predicate function signature is defined externally.
- *
  * If the filterable is a plain object:
  * ```coffeescript [specscript]
- * predicate(element any, key string, filt Object) -> condition Promise|boolean|any
+ * predicate(item any, key string, filterable Object) -> booleanResult Promise|boolean|any
  * ```
  *
- * `filter` works for arrays.
- *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * const array = [1, 2, 3, 4, 5]
+ * If the filterable is an object with a `.filter` method, the predicate function signature is defined externally.
  *
- * const result = filter(array, isOdd)
- * console.log(result) // [1, 3, 5]
- * ```
+ * If the filterable is a generator, the predicate function must be synchronous.
  *
- * If the predicate is asynchronous, the returned promise is concurrently resolved for its boolean condition before continuing with the filtering operation.
+ * If the predicate function is asynchronous, it is executed concurrently.
  *
  * ```javascript [playground]
  * const asyncIsOdd = async number => number % 2 == 1
  *
  * const array = [1, 2, 3, 4, 5]
  *
- * const promise = filter(array, asyncIsOdd)
- * promise.then(console.log) // [1, 3, 5]
- * ```
- *
- * `filter` applies the predicate function to just the values of an object.
+ * const result = await filter(array, asyncIsOdd)
  *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * const obj = { a: 1, b: 2, c: 3, d: 4, e: 5 }
- *
- * const result = filter(obj, isOdd)
- * console.log(result) // { a: 1, c: 3, e: 5 }
+ * console.log(result)
  * ```
  *
- * `filter` applies the predicate to the values of the entries of a map.
+ * `filter` applies the predicate function to just the values of objects and maps.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
  *
- * const myMap = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])
- *
- * const result = filter(myMap, isOdd)
- * console.log(result) // Map(3) { 'a' => 1, 'c' => 3, 'e' => 5 }
- * ```
+ * const object = { a: 1, b: 2, c: 3, d: 4, e: 5 }
+ * const map = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])
  *
- * For generators, `filter` returns a lazily filtered generator. All values that are normally yielded by the generator that test false by the predicate are excluded from the returned generator.
+ * const filteredObject = filter(object, isOdd)
+ * const filteredMap = filter(map, isOdd)
  *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * const numbersGeneratorFunction = function* () {
- *   yield 1; yield 2; yield 3; yield 4; yield 5
- * }
- *
- * const numbersGenerator = numbersGeneratorFunction()
- * const oddNumbersGenerator = filter(numbersGeneratorFunction(), isOdd)
- *
- * for (const number of numbersGenerator) {
- *   console.log(number) // 1
- *                       // 2
- *                       // 3
- *                       // 4
- *                       // 5
- * }
- *
- * for (const number of oddNumbersGenerator) {
- *   console.log(number) // 1
- *                       // 3
- *                       // 5
- * }
+ * console.log(filteredObject)
+ * console.log(filteredMap)
  * ```
  *
- * For async generators, `filter` returns a lazily filtered async generator. All values that are normally yielded by the async generator that test falsy by the predicate are excluded from the returned async generator.
+ * For generators, `filter` returns a filtered generator.
  *
  * ```javascript [playground]
- * const asyncIsOdd = async number => number % 2 == 1
+ * const isOdd = number => number % 2 == 1
  *
- * const asyncNumbersGeneratorFunction = async function* () {
+ * const generateNumbers = function* () {
  *   yield 1; yield 2; yield 3; yield 4; yield 5
  * }
  *
- * const asyncNumbersGenerator = asyncNumbersGeneratorFunction()
- *
- * const asyncOddNumbersGenerator = filter(asyncNumbersGeneratorFunction(), asyncIsOdd)
+ * const numbers = generateNumbers()
+ * const oddNumbers = filter(generateNumbers(), isOdd)
  *
- * for await (const number of asyncNumbersGenerator) {
- *   console.log(number) // 1
- *                       // 2
- *                       // 3
- *                       // 4
- *                       // 5
+ * console.log('numbers')
+ * for (const number of numbers) {
+ *   console.log(number)
  * }
  *
- * for await (const number of asyncOddNumbersGenerator) {
- *   console.log(number) // 1
- *                       // 3
- *                       // 5
+ * console.log('odd numbers')
+ * for (const number of oddNumbers) {
+ *   console.log(number)
  * }
  * ```
  *
- * Any promises passed in data argument position are resolved for their values before further execution.
+ * If the filterable is a promise, it is resolved for its value before further execution for the eager interface only. 
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
  *
  * filter(Promise.resolve([1, 2, 3, 4, 5]), isOdd).then(console.log)
- * // [1, 3, 5]
  * ```
  *
  * See also:

package/flatMap.js

@@ -79,9 +79,17 @@ const _flatMap = function (value, flatMapper) {
  * @description
  * Applies a flat-mapper function to each item of a monad, returning a flat-mapped monad of the same type.
  *
- * A flat-mapping operation iterates through each item of a monad and applies the flat-mapper function to each item, flattening the result of the execution into the returned monad.
+ * ```javascript [playground]
+ * const duplicate = value => [value, value]
+ *
+ * const duplicated = flatMap([1, 2, 3, 4, 5], duplicate)
+ *
+ * console.log(duplicated)
+ * ```
+ *
+ * `flatMap` iterates through each item of a monad and applies the flat-mapper function to each item, concatenating the execution result (flat-mapped item) into the flat-mapped monad. If the execution result is a promise, it is resolved for its value before being concatenated into the flat-mapped monad. If the execution result is asynchronously iterable, it is muxed into the flat-mapped monad.
  *
- * If the flat-mapper is asynchronous, it is executed concurrently. The execution result may be asynchronously iterable, in which case it is muxed into the returned monad.
+ * If the flat-mapper function is asynchronous, it is executed concurrently.
  *
  * The following data types are considered to be monads:
  *  * `array`
@@ -125,15 +133,7 @@ const _flatMap = function (value, flatMapper) {
  * flatMapper(item any, key string, monad Object) -> flatMappedItem Promise|Monad|any
  * ```
  *
- * ```javascript [playground]
- * const duplicate = value => [value, value]
- *
- * const duplicated = flatMap([1, 2, 3, 4, 5], duplicate)
- *
- * console.log(duplicated)
- * ```
- *
- * If the iterable is an object with a `.flatMap` or `.chain` method, the flat-mapper function signature is defined externally.
+ * If the iterable is an object with a `flatMap` or `chain` method, the flat-mapper function signature is defined externally.
  *
  * Values from async generators are muxed. Muxing, or asynchronously "mixing", is the process of combining multiple asynchronous sources into one source, with order determined by the asynchronous resolution of the individual promise elements.
  *
@@ -153,7 +153,7 @@ const _flatMap = function (value, flatMapper) {
  * // values from async generators are muxed
  * const muxed = await flatMap(['foo', 'bar', 'baz'], asyncRepeat3)
  *
- * console.log(muxed)
+ * console.log('muxed:', muxed)
  *
  * const repeat3 = function* (message) {
  *   yield message; yield message; yield message
@@ -162,7 +162,7 @@ const _flatMap = function (value, flatMapper) {
  * // values from generators and other monads are concatenated
  * const repeated = flatMap(['foo', 'bar', 'baz'], repeat3)
  *
- * console.log(repeated)
+ * console.log('repeated:', repeated)
  * ```
  *
  * If the monad is a promise, it is resolved for its value before further execution for the eager interface only.

package/forEach.js

@@ -60,6 +60,14 @@ const _forEach = function (collection, callback) {
  * @description
  * Executes a callback function for each item of an iterable, returning the original iterable unmodified.
  *
+ * ```javascript [playground]
+ * console.log('array')
+ * forEach([1, 2, 3, 4, 5], num => console.log(num))
+ *
+ * console.log('object')
+ * forEach({ a: 1, b: 2, c: 3 }, num => console.log(num))
+ * ```
+ *
  * The following data types are considered to be iterable:
  *  * `array`
  *  * `set`
@@ -101,14 +109,6 @@ const _forEach = function (collection, callback) {
  * callback(item any, key string, iterable Object) -> Promise|undefined
  * ```
  *
- * ```javascript [playground]
- * console.log('array')
- * forEach([1, 2, 3, 4, 5], num => console.log(num))
- *
- * console.log('object')
- * forEach({ a: 1, b: 2, c: 3 }, num => console.log(num))
- * ```
- *
  * If the iterable is an object with a `.forEach` method, the callback function signature is defined externally.
  *
  * If the callback function is asynchronous, it is executed concurrently.

package/get.js

@@ -74,9 +74,9 @@ const _get = function (object, path, defaultValue) {
  * ```javascript [playground]
  * const asyncDefaultResolver = async object => object.a
  *
- * const promise = get({ a: 1 }, 'notfound', asyncDefaultResolver)
+ * const result = await get({ a: 1 }, 'notfound', asyncDefaultResolver)
  *
- * promise.then(console.log)
+ * console.log(result)
  * ```
  *
  * `get` supports three types of path patterns for nested property access.
@@ -96,7 +96,7 @@ const _get = function (object, path, defaultValue) {
  * const get00000BracketNotation = get('[0][0][0][0][0]')
  * const get00000ArrayNotation = get([0, 0, 0, 0, 0])
  *
- * const nested = [[[[['foo']]]]]
+ * const nested = [[[[[1]]]]]
  *
  * console.log(get00000DotNotation(nested))
  * console.log(get00000BracketNotation(nested))

package/gt.js

@@ -6,44 +6,37 @@ const greaterThan = require('./_internal/greaterThan')
  *
  * @synopsis
  * ```coffeescript [specscript]
- * args Array<any>
- * argsOrPromises Array<Promise|any>
- *
- * type SyncOrAsyncResolver = (...args)=>Promise|any
- *
- * leftValue Promise|any
- * rightValue Promise|any
- * leftResolver SyncOrAsyncResolver
- * rightResolver SyncOrAsyncResolver
- *
- * gt(leftValue, rightValue) -> Promise|boolean
- * gt(...argsOrPromises, leftResolver, rightValue) -> Promise|boolean
- * gt(...argsOrPromises, leftValue, rightResolver) -> Promise|boolean
- * gt(...argsOrPromises, leftResolver, rightResolver) -> Promise|boolean
- * gt(leftResolver, rightValue)(...args) -> Promise|boolean
- * gt(leftValue, rightResolver)(...args) -> Promise|boolean
- * gt(leftResolver, rightResolver)(...args) -> Promise|boolean
+ * type SyncOrAsyncResolver = (...arguments)=>Promise|any
+ *
+ * gt(leftValue Promise|any, rightValue Promise|any) -> Promise|boolean
+ * gt(...arguments, leftResolver SyncOrAsyncResolver, rightValue Promise|any) -> Promise|boolean
+ * gt(...arguments, leftValue Promise|any, rightResolver SyncOrAsyncResolver) -> Promise|boolean
+ * gt(...arguments, leftResolver SyncOrAsyncResolver, rightResolver SyncOrAsyncResolver) -> Promise|boolean
+ *
+ * gt(leftResolver SyncOrAsyncResolver, rightValue Promise|any)(...arguments) -> Promise|boolean
+ * gt(leftValue Promise|any, rightResolver SyncOrAsyncResolver)(...arguments) -> Promise|boolean
+ * gt(leftResolver SyncOrAsyncResolver, rightResolver SyncOrAsyncResolver)(...arguments) -> Promise|boolean
  * ```
  *
  * @description
- * Functional equivalent of the [Greater than (>)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Greater_than) operator. Tests if a value is greater than (`>`) another value.
+ * Comparison operator. Tests if a value is greater than (`>`) another value.
  *
  * ```javascript [playground]
  * const age = 40
  *
  * const isAgeGreaterThan21 = gt(age, 21)
  *
- * console.log(isAgeGreaterThan21) // true
+ * console.log(isAgeGreaterThan21)
  * ```
  *
- * If either of the two values are resolver functions, `gt` returns a function that resolves the value(s) to compare.
+ * If either of the two values are resolver functions, `gt` returns a function that resolves the values to compare.
  *
  * ```javascript [playground]
  * const isOfLegalAge = gt(get('age'), 21)
  *
  * const juvenile = { age: 16 }
  *
- * console.log(isOfLegalAge(juvenile)) // false
+ * console.log(isOfLegalAge(juvenile))
  * ```
  *
  * If either of the resolver functions is asynchronous, `gt` returns an asynchronous function.
@@ -53,7 +46,7 @@ const greaterThan = require('./_internal/greaterThan')
  *
  * const juvenile = { age: 16 }
  *
- * asyncIsOfLegalAge(juvenile).then(console.log) // false
+ * asyncIsOfLegalAge(juvenile).then(console.log)
  * ```
  *
  * `gt` supports a lazy interface for composability.
@@ -61,14 +54,14 @@ const greaterThan = require('./_internal/greaterThan')
  * ```javascript [playground]
  * pipe({ value: 1 }, [
  *   gt(5, get('value')),
- *   console.log, // true
+ *   console.log,
  * ])
  * ```
  *
- * Any promises passed in data argument position are resolved for their values before further execution.
+ * Any promises in `arguments` are resolved for their values before further execution for the eager interface only.
  *
  * ```javascript [playground]
- * gt(Promise.resolve({ a: 2, b: 1 }), get('a'), get('b')).then(console.log) // true
+ * gt(Promise.resolve({ a: 2, b: 1 }), get('a'), get('b')).then(console.log)
  * ```
  *
  * See also:

package/gte.js

@@ -6,46 +6,39 @@ const greaterThanOrEqual = require('./_internal/greaterThanOrEqual')
  *
  * @synopsis
  * ```coffeescript [specscript]
- * args Array<any>
- * argsOrPromises Array<Promise|any>
- *
- * type SyncOrAsyncResolver = (...args)=>Promise|any
- *
- * leftValue Promise|any
- * rightValue Promise|any
- * leftResolver SyncOrAsyncResolver
- * rightResolver SyncOrAsyncResolver
- *
- * gte(leftValue, rightValue) -> Promise|boolean
- * gte(...argsOrPromises, leftResolver, rightValue) -> Promise|boolean
- * gte(...argsOrPromises, leftValue, rightResolver) -> Promise|boolean
- * gte(...argsOrPromises, leftResolver, rightResolver) -> Promise|boolean
- * gte(leftResolver, rightValue)(...args) -> Promise|boolean
- * gte(leftValue, rightResolver)(...args) -> Promise|boolean
- * gte(leftResolver, rightResolver)(...args) -> Promise|boolean
+ * type SyncOrAsyncResolver = (...arguments)=>Promise|any
+ *
+ * gte(leftValue Promise|any, rightValue Promise|any) -> Promise|boolean
+ * gte(...arguments, leftResolver SyncOrAsyncResolver, rightValue Promise|any) -> Promise|boolean
+ * gte(...arguments, leftValue Promise|any, rightResolver SyncOrAsyncResolver) -> Promise|boolean
+ * gte(...arguments, leftResolver SyncOrAsyncResolver, rightResolver SyncOrAsyncResolver) -> Promise|boolean
+ *
+ * gte(leftResolver SyncOrAsyncResolver, rightValue Promise|any)(...arguments) -> Promise|boolean
+ * gte(leftValue Promise|any, rightResolver SyncOrAsyncResolver)(...arguments) -> Promise|boolean
+ * gte(leftResolver SyncOrAsyncResolver, rightResolver SyncOrAsyncResolver)(...arguments) -> Promise|boolean
  * ```
  *
  * @description
- * Functional equivalent of the [Greater than or equal (>=)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Greater_than_or_equal) operator. Tests if a value is greater than or equal (`>=`) to another value.
+ * Comparison operator. Tests if a value is greater than or equal (`>=`) to another value.
  *
  * ```javascript [playground]
  * const age = 20
  *
  * const isAdultAge = gte(age, 18)
  *
- * console.log(isAdultAge) // true
+ * console.log(isAdultAge)
  * ```
  *
- * If either of the two values are resolver functions, `gte` returns a function that resolves the value(s) to compare.
+ * If either of the two values are resolver functions, `gte` returns a function that resolves the values to compare.
  *
  * ```javascript [playground]
  * const identity = value => value
  *
  * const isAtLeast100 = gte(identity, 100)
  *
- * console.log(isAtLeast100(99)) // false
- * console.log(isAtLeast100(100)) // true
- * console.log(isAtLeast100(101)) // true
+ * console.log(isAtLeast100(99))
+ * console.log(isAtLeast100(100))
+ * console.log(isAtLeast100(101))
  * ```
  *
  * If either of the two resolver functions is asynchronous, `gte` returns an asynchronous function.
@@ -55,9 +48,9 @@ const greaterThanOrEqual = require('./_internal/greaterThanOrEqual')
  *
  * const asyncIsAtLeast100 = gte(asyncIdentity, 100)
  *
- * asyncIsAtLeast100(99).then(console.log) // false
- * asyncIsAtLeast100(100).then(console.log) // true
- * asyncIsAtLeast100(101).then(console.log) // true
+ * asyncIsAtLeast100(99).then(console.log)
+ * asyncIsAtLeast100(100).then(console.log)
+ * asyncIsAtLeast100(101).then(console.log)
  * ```
  *
  * `gte` supports a lazy interface for composability.
@@ -65,14 +58,14 @@ const greaterThanOrEqual = require('./_internal/greaterThanOrEqual')
  * ```javascript [playground]
  * pipe({ value: 1 }, [
  *   gte(1, get('value')),
- *   console.log, // true
+ *   console.log,
  * ])
  * ```
  *
- * Any promises passed in data argument position are resolved for their values before further execution.
+ * Any promises in `arguments` are resolved for their values before further execution for the eager interface only.
  *
  * ```javascript [playground]
- * gte(Promise.resolve({ a: 1, b: 1 }), get('a'), get('b')).then(console.log) // true
+ * gte(Promise.resolve({ a: 1, b: 1 }), get('a'), get('b')).then(console.log)
  * ```
  *
  * See also:

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Rubico v2.10.0
+ * Rubico v2.12.1
  * https://rubico.land/
  *
  * © Richard Yufei Tong, King of Software
@@ -1480,26 +1480,64 @@ const FilteringIterator = (iterator, predicate) => ({
   },
 })
 
-const FilteringAsyncIterator = (asyncIterator, predicate) => ({
-  isAsyncIteratorDone: false,
-  [symbolAsyncIterator]() {
-    return this
-  },
-  async next() {
-    while (!this.isAsyncIteratorDone) {
-      const { value, done } = await asyncIterator.next()
-      if (done) {
-        this.isAsyncIteratorDone = true
-      } else {
-        const predication = predicate(value)
-        if (isPromise(predication) ? await predication : predication) {
-          return { value, done: false }
+const FilteringAsyncIterator = (asyncIterator, predicate) => {
+  const buffer = new LinkedList()
+
+  let index = -1
+  let consumingAsyncIterator = false
+  let isAsyncIteratorDone = false
+
+  return {
+    [symbolAsyncIterator]() {
+      return this
+    },
+
+    // _consumeAsyncIterator() -> Promise<>
+    async _consumeAsyncIterator() {
+      for await (const item of asyncIterator) {
+        index += 1
+        const booleanResult = predicate(item)
+        buffer.append([booleanResult, item])
+      }
+      isAsyncIteratorDone = true
+    },
+
+    
+    async next() {
+      if (!consumingAsyncIterator) {
+        this._consumeAsyncIterator()
+        consumingAsyncIterator = true
+      }
+
+      while (!isAsyncIteratorDone) {
+        if (buffer.length > 0) {
+          let [booleanResult, item] = buffer.popFirst()
+          if (isPromise(booleanResult)) {
+            booleanResult = await booleanResult
+          }
+          if (booleanResult) {
+            return { value: item, done: false }
+          }
+          continue
         }
+        await sleep(10)
       }
-    }
-    return { value: undefined, done: true }
-  },
-})
+
+      while (buffer.length > 0) {
+        let [booleanResult, item] = buffer.popFirst()
+        if (isPromise(booleanResult)) {
+          booleanResult = await booleanResult
+        }
+        if (booleanResult) {
+          return { value: item, done: false }
+        }
+      }
+
+      return { value: undefined, done: true }
+    },
+
+  }
+}
 
 const arrayExtendMap = function (
   array, values, valuesMapper, valuesIndex,