@cspell/cspell-pipe 6.26.3 → 6.28.0

package/dist/{cjs/operators/operators/combine.d.ts → esm/operators/combine.d.mts}

@@ -1,5 +1,5 @@
-import type { PaFn, PipeAsyncTx, PipeSyncTx, PsFn } from '../internalTypes.js';
-import type { OperatorAsync, OperatorSync } from './types.js';
+import type { PaFn, PipeAsyncTx, PipeSyncTx, PsFn } from '../internalTypes.mjs';
+import type { OperatorAsync, OperatorSync } from './types.mjs';
 export declare function opCombineAsync<T>(): OperatorAsync<T>;
 export declare function opCombineAsync<T, T0>(...f: PipeAsyncTx<[T, T0]>): OperatorAsync<T0>;
 export declare function opCombineAsync<T, T0, T1>(...f: PipeAsyncTx<[T, T0, T1]>): OperatorAsync<T1>;
@@ -20,4 +20,4 @@ export declare function opCombineSync<T, T0, T1, T2, T3, T4, T5>(...f: PipeSyncT
 export declare function opCombineSync<T, T0, T1, T2, T3, T4, T5, T6>(...f: PipeSyncTx<[T, T0, T1, T2, T3, T4, T5, T6]>): OperatorSync<T6>;
 export declare function opCombineSync<T, T0, T1, T2, T3, T4, T5, T6, T7>(...f: PipeSyncTx<[T, T0, T1, T2, T3, T4, T5, T6, T7]>): OperatorSync<T7>;
 export declare function opCombineSync<T>(...fns: PsFn<T, T>[]): OperatorSync<T>;
-//# sourceMappingURL=combine.d.ts.map
+//# sourceMappingURL=combine.d.mts.map

package/dist/esm/operators/combine.js

@@ -16,4 +16,3 @@ export function opCombineSync(...fns) {
     }
     return combine;
 }
-//# sourceMappingURL=combine.js.map

package/dist/esm/operators/combine.mjs

@@ -0,0 +1,18 @@
+export function opCombineAsync(...fns) {
+    function combine(iter) {
+        for (const fn of fns) {
+            iter = fn(iter);
+        }
+        return iter;
+    }
+    return combine;
+}
+export function opCombineSync(...fns) {
+    function combine(iter) {
+        for (const fn of fns) {
+            iter = fn(iter);
+        }
+        return iter;
+    }
+    return combine;
+}

package/dist/{cjs/operators/operators/concatMap.d.ts → esm/operators/concatMap.d.mts}

@@ -1,4 +1,4 @@
 export declare function opConcatMapAsync<T, U = T>(mapFn: (v: T) => AsyncIterable<U> | Iterable<U>): (iter: AsyncIterable<T>) => AsyncIterable<U>;
 export declare function opConcatMapSync<T, U = T>(mapFn: (v: T) => Iterable<U>): (iter: Iterable<T>) => Iterable<U>;
 export declare const opConcatMap: <T, U>(fn: (v: T) => Iterable<U>) => import("../internalTypes.js").PipeFn<T, U>;
-//# sourceMappingURL=concatMap.d.ts.map
+//# sourceMappingURL=concatMap.d.mts.map

package/dist/esm/operators/concatMap.js

@@ -16,4 +16,3 @@ export function opConcatMapSync(mapFn) {
     return fn;
 }
 export const opConcatMap = (fn) => toPipeFn(opConcatMapSync(fn), opConcatMapAsync(fn));
-//# sourceMappingURL=concatMap.js.map

package/dist/esm/operators/concatMap.mjs

@@ -0,0 +1,18 @@
+import { toPipeFn } from '../helpers/util.mjs';
+export function opConcatMapAsync(mapFn) {
+    async function* fn(iter) {
+        for await (const v of iter) {
+            yield* mapFn(v);
+        }
+    }
+    return fn;
+}
+export function opConcatMapSync(mapFn) {
+    function* fn(iter) {
+        for (const v of iter) {
+            yield* mapFn(v);
+        }
+    }
+    return fn;
+}
+export const opConcatMap = (fn) => toPipeFn(opConcatMapSync(fn), opConcatMapAsync(fn));

package/dist/{cjs/operators/operators/filter.d.ts → esm/operators/filter.d.mts}

@@ -1,4 +1,4 @@
-import type { PipeFn } from '../internalTypes.js';
+import type { PipeFn } from '../internalTypes.mjs';
 export declare function opFilterAsync<T, S extends T>(filterFn: (v: T) => v is S): (iter: AsyncIterable<T>) => AsyncIterable<S>;
 export declare function opFilterAsync<T, S extends Awaited<T>>(filterFn: (v: Awaited<T>) => v is S): (iter: AsyncIterable<T>) => AsyncIterable<S>;
 export declare function opFilterAsync<T>(filterFn: (v: Awaited<T>) => boolean): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
@@ -7,4 +7,4 @@ export declare function opFilterSync<T, S extends T>(filterFn: (v: T) => v is S)
 export declare function opFilterSync<T>(filterFn: (v: T) => boolean): (iter: Iterable<T>) => Iterable<T>;
 export declare function opFilter<T, S extends T>(fn: (v: T) => v is S): PipeFn<T, S>;
 export declare function opFilter<T>(fn: (v: T) => boolean): PipeFn<T, T>;
-//# sourceMappingURL=filter.d.ts.map
+//# sourceMappingURL=filter.d.mts.map

package/dist/esm/operators/filter.js

@@ -27,4 +27,3 @@ export function opFilter(fn) {
     }
     return _;
 }
-//# sourceMappingURL=filter.js.map

package/dist/esm/operators/filter.mjs

@@ -0,0 +1,29 @@
+import { isAsyncIterable } from '../helpers/util.mjs';
+// prettier-ignore
+export function opFilterAsync(filterFn) {
+    async function* fn(iter) {
+        for await (const v of iter) {
+            const pass = await filterFn(v);
+            if (pass)
+                yield v;
+        }
+    }
+    return fn;
+}
+export function opFilterSync(filterFn) {
+    function* fn(iter) {
+        for (const v of iter) {
+            if (filterFn(v))
+                yield v;
+        }
+    }
+    return fn;
+}
+export function opFilter(fn) {
+    const asyncFn = opFilterAsync(fn);
+    const syncFn = opFilterSync(fn);
+    function _(i) {
+        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
+    }
+    return _;
+}

package/dist/{cjs/operators/operators/first.d.ts → esm/operators/first.d.mts}

@@ -1,4 +1,4 @@
-import type { PipeFn } from '../internalTypes.js';
+import type { PipeFn } from '../internalTypes.mjs';
 export declare function opFirstAsync<T, S extends T>(firstFn: (v: T) => v is S): (iter: AsyncIterable<T>) => AsyncIterable<S>;
 export declare function opFirstAsync<T, S extends Awaited<T>>(firstFn: (v: Awaited<T>) => v is S): (iter: AsyncIterable<T>) => AsyncIterable<S>;
 export declare function opFirstAsync<T>(firstFn: (v: Awaited<T>) => boolean): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
@@ -7,4 +7,4 @@ export declare function opFirstSync<T, S extends T>(firstFn: (v: T) => v is S):
 export declare function opFirstSync<T>(firstFn: (v: T) => boolean): (iter: Iterable<T>) => Iterable<T>;
 export declare function opFirst<T, S extends T>(fn: (v: T) => v is S): PipeFn<T, S>;
 export declare function opFirst<T>(fn: (v: T) => boolean): PipeFn<T, T>;
-//# sourceMappingURL=first.d.ts.map
+//# sourceMappingURL=first.d.mts.map

package/dist/esm/operators/first.js

@@ -31,4 +31,3 @@ export function opFirst(fn) {
     }
     return _;
 }
-//# sourceMappingURL=first.js.map

package/dist/esm/operators/first.mjs

@@ -0,0 +1,33 @@
+import { isAsyncIterable } from '../helpers/util.mjs';
+// prettier-ignore
+export function opFirstAsync(firstFn) {
+    async function* fn(iter) {
+        for await (const v of iter) {
+            const pass = await firstFn(v);
+            if (pass) {
+                yield v;
+                break;
+            }
+        }
+    }
+    return fn;
+}
+export function opFirstSync(firstFn) {
+    function* fn(iter) {
+        for (const v of iter) {
+            if (firstFn(v)) {
+                yield v;
+                break;
+            }
+        }
+    }
+    return fn;
+}
+export function opFirst(fn) {
+    const asyncFn = opFirstAsync(fn);
+    const syncFn = opFirstSync(fn);
+    function _(i) {
+        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
+    }
+    return _;
+}

package/dist/{cjs/operators/operators/flatten.d.ts → esm/operators/flatten.d.mts}

@@ -1,4 +1,4 @@
 export declare function opFlattenAsync<T>(): (iter: AsyncIterable<AsyncIterable<T> | Iterable<T>>) => AsyncIterable<T>;
 export declare function opFlattenSync<T>(): (iter: Iterable<Iterable<T>>) => Iterable<T>;
 export declare const opFlatten: <T>() => import("../internalTypes.js").PipeFn<Iterable<T>, T>;
-//# sourceMappingURL=flatten.d.ts.map
+//# sourceMappingURL=flatten.d.mts.map

package/dist/esm/operators/flatten.js

@@ -16,4 +16,3 @@ export function opFlattenSync() {
     return fn;
 }
 export const opFlatten = () => toPipeFn(opFlattenSync(), opFlattenAsync());
-//# sourceMappingURL=flatten.js.map

package/dist/esm/operators/flatten.mjs

@@ -0,0 +1,18 @@
+import { toPipeFn } from '../helpers/util.mjs';
+export function opFlattenAsync() {
+    async function* fn(iter) {
+        for await (const v of iter) {
+            yield* v;
+        }
+    }
+    return fn;
+}
+export function opFlattenSync() {
+    function* fn(iter) {
+        for (const v of iter) {
+            yield* v;
+        }
+    }
+    return fn;
+}
+export const opFlatten = () => toPipeFn(opFlattenSync(), opFlattenAsync());

package/dist/esm/operators/index.d.mts

@@ -0,0 +1,17 @@
+export { opAppend, opAppendAsync, opAppendSync } from './append.mjs';
+export { opAwaitAsync } from './await.mjs';
+export { opCombineAsync, opCombineSync } from './combine.mjs';
+export { opConcatMap, opConcatMapAsync, opConcatMapSync } from './concatMap.mjs';
+export { opFilter, opFilterAsync, opFilterSync } from './filter.mjs';
+export { opFirst, opFirstAsync, opFirstSync } from './first.mjs';
+export { opFlatten, opFlattenAsync, opFlattenSync } from './flatten.mjs';
+export { opJoinStrings, opJoinStringsAsync, opJoinStringsSync } from './joinStrings.mjs';
+export { opLast, opLastAsync, opLastSync } from './last.mjs';
+export { opMap, opMapAsync, opMapSync } from './map.mjs';
+export { opReduceAsync, opReduceSync } from './reduce.mjs';
+export { opSkip, opSkipAsync, opSkipSync } from './skip.mjs';
+export { opTake, opTakeAsync, opTakeSync } from './take.mjs';
+export { opTap, opTapAsync, opTapSync } from './tap.mjs';
+export type { OperatorAsync, OperatorSync, OperatorSyncToAsync } from './types.mjs';
+export { opUnique, opUniqueAsync, opUniqueSync } from './unique.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/esm/operators/index.js

@@ -13,4 +13,3 @@ export { opSkip, opSkipAsync, opSkipSync } from './skip.js';
 export { opTake, opTakeAsync, opTakeSync } from './take.js';
 export { opTap, opTapAsync, opTapSync } from './tap.js';
 export { opUnique, opUniqueAsync, opUniqueSync } from './unique.js';
-//# sourceMappingURL=index.js.map

package/dist/esm/operators/index.mjs

@@ -0,0 +1,15 @@
+export { opAppend, opAppendAsync, opAppendSync } from './append.mjs';
+export { opAwaitAsync } from './await.mjs';
+export { opCombineAsync, opCombineSync } from './combine.mjs';
+export { opConcatMap, opConcatMapAsync, opConcatMapSync } from './concatMap.mjs';
+export { opFilter, opFilterAsync, opFilterSync } from './filter.mjs';
+export { opFirst, opFirstAsync, opFirstSync } from './first.mjs';
+export { opFlatten, opFlattenAsync, opFlattenSync } from './flatten.mjs';
+export { opJoinStrings, opJoinStringsAsync, opJoinStringsSync } from './joinStrings.mjs';
+export { opLast, opLastAsync, opLastSync } from './last.mjs';
+export { opMap, opMapAsync, opMapSync } from './map.mjs';
+export { opReduceAsync, opReduceSync } from './reduce.mjs';
+export { opSkip, opSkipAsync, opSkipSync } from './skip.mjs';
+export { opTake, opTakeAsync, opTakeSync } from './take.mjs';
+export { opTap, opTapAsync, opTapSync } from './tap.mjs';
+export { opUnique, opUniqueAsync, opUniqueSync } from './unique.mjs';

package/dist/{cjs/operators/operators/joinStrings.d.ts → esm/operators/joinStrings.d.mts}

@@ -1,4 +1,4 @@
 export declare function opJoinStringsAsync(joinCharacter?: string): (iter: AsyncIterable<AsyncIterable<string> | Iterable<string>>) => AsyncIterable<string>;
 export declare function opJoinStringsSync(joinCharacter?: string): (iter: Iterable<Iterable<string>>) => Iterable<string>;
 export declare const opJoinStrings: (joinCharacter?: string) => import("../internalTypes.js").PipeFn<Iterable<string>, string>;
-//# sourceMappingURL=joinStrings.d.ts.map
+//# sourceMappingURL=joinStrings.d.mts.map

package/dist/esm/operators/joinStrings.js

@@ -19,4 +19,3 @@ export function opJoinStringsSync(joinCharacter = ',') {
     return fn;
 }
 export const opJoinStrings = (joinCharacter) => toPipeFn(opJoinStringsSync(joinCharacter), opJoinStringsAsync(joinCharacter));
-//# sourceMappingURL=joinStrings.js.map

package/dist/esm/operators/joinStrings.mjs

@@ -0,0 +1,21 @@
+import { toArray } from '../helpers/toArray.mjs';
+import { toPipeFn } from '../helpers/util.mjs';
+export function opJoinStringsAsync(joinCharacter = ',') {
+    async function* fn(iter) {
+        for await (const v of iter) {
+            const a = await toArray(v);
+            yield a.join(joinCharacter);
+        }
+    }
+    return fn;
+}
+export function opJoinStringsSync(joinCharacter = ',') {
+    function* fn(iter) {
+        for (const v of iter) {
+            const a = toArray(v);
+            yield a.join(joinCharacter);
+        }
+    }
+    return fn;
+}
+export const opJoinStrings = (joinCharacter) => toPipeFn(opJoinStringsSync(joinCharacter), opJoinStringsAsync(joinCharacter));

package/dist/{cjs/operators/operators/last.d.ts → esm/operators/last.d.mts}

@@ -1,4 +1,4 @@
-import type { PipeFn } from '../internalTypes.js';
+import type { PipeFn } from '../internalTypes.mjs';
 export declare function opLastAsync<T, S extends T>(lastFn: (v: T) => v is S): (iter: AsyncIterable<T>) => AsyncIterable<S>;
 export declare function opLastAsync<T, S extends Awaited<T>>(lastFn: (v: Awaited<T>) => v is S): (iter: AsyncIterable<T>) => AsyncIterable<S>;
 export declare function opLastAsync<T>(lastFn: (v: Awaited<T>) => boolean): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
@@ -7,4 +7,4 @@ export declare function opLastSync<T, S extends T>(lastFn: (v: T) => v is S): (i
 export declare function opLastSync<T>(lastFn: (v: T) => boolean): (iter: Iterable<T>) => Iterable<T>;
 export declare function opLast<T, S extends T>(fn: (v: T) => v is S): PipeFn<T, S>;
 export declare function opLast<T>(fn: (v: T) => boolean): PipeFn<T, T>;
-//# sourceMappingURL=last.d.ts.map
+//# sourceMappingURL=last.d.mts.map

package/dist/esm/operators/last.js

@@ -36,4 +36,3 @@ export function opLast(fn) {
     }
     return _;
 }
-//# sourceMappingURL=last.js.map

package/dist/esm/operators/last.mjs

@@ -0,0 +1,38 @@
+import { isAsyncIterable } from '../helpers/util.mjs';
+const symNotFound = Symbol('LastNotFound');
+// prettier-ignore
+export function opLastAsync(lastFn) {
+    async function* fn(iter) {
+        let last = symNotFound;
+        for await (const v of iter) {
+            const pass = await lastFn(v);
+            if (pass) {
+                last = v;
+            }
+        }
+        if (last !== symNotFound)
+            yield last;
+    }
+    return fn;
+}
+export function opLastSync(lastFn) {
+    function* fn(iter) {
+        let last = symNotFound;
+        for (const v of iter) {
+            if (lastFn(v)) {
+                last = v;
+            }
+        }
+        if (last !== symNotFound)
+            yield last;
+    }
+    return fn;
+}
+export function opLast(fn) {
+    const asyncFn = opLastAsync(fn);
+    const syncFn = opLastSync(fn);
+    function _(i) {
+        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
+    }
+    return _;
+}

package/dist/{cjs/operators/operators/map.d.ts → esm/operators/map.d.mts}

@@ -1,4 +1,4 @@
 export declare function opMapAsync<T, U = T>(mapFn: (v: T) => U): (iter: AsyncIterable<T>) => AsyncIterable<U>;
 export declare function opMapSync<T, U = T>(mapFn: (v: T) => U): (iter: Iterable<T>) => Iterable<U>;
 export declare const opMap: <T, U>(fn: (v: T) => U) => import("../internalTypes.js").PipeFn<T, U>;
-//# sourceMappingURL=map.d.ts.map
+//# sourceMappingURL=map.d.mts.map

package/dist/esm/operators/map.js

@@ -16,4 +16,3 @@ export function opMapSync(mapFn) {
     return fn;
 }
 export const opMap = (fn) => toPipeFn(opMapSync(fn), opMapAsync(fn));
-//# sourceMappingURL=map.js.map

package/dist/esm/operators/map.mjs

@@ -0,0 +1,18 @@
+import { toPipeFn } from '../helpers/util.mjs';
+export function opMapAsync(mapFn) {
+    async function* fn(iter) {
+        for await (const v of iter) {
+            yield mapFn(v);
+        }
+    }
+    return fn;
+}
+export function opMapSync(mapFn) {
+    function* fn(iter) {
+        for (const v of iter) {
+            yield mapFn(v);
+        }
+    }
+    return fn;
+}
+export const opMap = (fn) => toPipeFn(opMapSync(fn), opMapAsync(fn));

package/dist/{cjs/operators/operators/reduce.d.ts → esm/operators/reduce.d.mts}

@@ -4,4 +4,4 @@ export declare function opReduceAsync<T, U>(reduceFn: (previousValue: U, current
 export declare function opReduceSync<T>(reduceFn: (previousValue: T, currentValue: T) => T): (iter: Iterable<T>) => Iterable<T>;
 export declare function opReduceSync<T>(reduceFn: (previousValue: T, currentValue: T) => T, initialValue: T): (iter: Iterable<T>) => Iterable<T>;
 export declare function opReduceSync<T, U>(reduceFn: (previousValue: U, currentValue: T) => U, initialValue: U): (iter: Iterable<T>) => Iterable<U>;
-//# sourceMappingURL=reduce.d.ts.map
+//# sourceMappingURL=reduce.d.mts.map

package/dist/esm/operators/reduce.js

@@ -46,4 +46,3 @@ async function headTailAsync(iter) {
 function isIterable(i) {
     return typeof i[Symbol.iterator] === 'function';
 }
-//# sourceMappingURL=reduce.js.map

package/dist/esm/operators/reduce.mjs

@@ -0,0 +1,48 @@
+import { asyncIteratorToAsyncIterable, iteratorToIterable } from '../helpers/index.mjs';
+export function opReduceAsync(reduceFn, initialValue) {
+    async function* reduce(head, tail) {
+        for await (const v of tail) {
+            head = reduceFn(head, v);
+        }
+        yield head;
+    }
+    async function* fn(iter) {
+        const ht = initialValue === undefined ? await headTailAsync(iter) : { head: await initialValue, tail: iter };
+        if (!ht)
+            return;
+        yield* reduce(ht.head, ht.tail);
+    }
+    return fn;
+}
+export function opReduceSync(reduceFn, initialValue) {
+    function* reduce(head, tail) {
+        for (const v of tail) {
+            head = reduceFn(head, v);
+        }
+        yield head;
+    }
+    function* fn(iter) {
+        const ht = initialValue === undefined ? headTail(iter) : { head: initialValue, tail: iter };
+        if (!ht)
+            return;
+        yield* reduce(ht.head, ht.tail);
+    }
+    return fn;
+}
+function headTail(iter) {
+    const iterator = iter[Symbol.iterator]();
+    const first = iterator.next();
+    if (first.done)
+        return undefined;
+    return { head: first.value, tail: iteratorToIterable(iterator) };
+}
+async function headTailAsync(iter) {
+    const iterator = isIterable(iter) ? iter[Symbol.iterator]() : iter[Symbol.asyncIterator]();
+    const first = await iterator.next();
+    if (first.done)
+        return undefined;
+    return { head: first.value, tail: asyncIteratorToAsyncIterable(iterator) };
+}
+function isIterable(i) {
+    return typeof i[Symbol.iterator] === 'function';
+}

package/dist/{cjs/operators/operators/skip.d.ts → esm/operators/skip.d.mts}

@@ -1,4 +1,4 @@
 export declare function opSkipAsync<T>(count: number): (iter: AsyncIterable<T> | Iterable<T>) => AsyncIterable<T>;
 export declare function opSkipSync<T>(count: number): (iter: Iterable<T>) => Iterable<T>;
 export declare const opSkip: <T>(count: number) => import("../internalTypes.js").PipeFn<T, T>;
-//# sourceMappingURL=skip.d.ts.map
+//# sourceMappingURL=skip.d.mts.map

package/dist/esm/operators/skip.js

@@ -24,4 +24,3 @@ export function opSkipSync(count) {
     return fn;
 }
 export const opSkip = (count) => toPipeFn(opSkipSync(count), opSkipAsync(count));
-//# sourceMappingURL=skip.js.map

package/dist/esm/operators/skip.mjs

@@ -0,0 +1,26 @@
+import { toPipeFn } from '../helpers/util.mjs';
+export function opSkipAsync(count) {
+    async function* fn(iter) {
+        for await (const v of iter) {
+            if (count > 0) {
+                --count;
+                continue;
+            }
+            yield v;
+        }
+    }
+    return fn;
+}
+export function opSkipSync(count) {
+    function* fn(iter) {
+        for (const v of iter) {
+            if (count > 0) {
+                --count;
+                continue;
+            }
+            yield v;
+        }
+    }
+    return fn;
+}
+export const opSkip = (count) => toPipeFn(opSkipSync(count), opSkipAsync(count));

package/dist/{operators/take.d.ts → esm/operators/take.d.mts}

@@ -5,4 +5,4 @@ export declare function opTakeSync<T>(count: number): (iter: Iterable<T>) => Ite
  * @param count - number to take
  */
 export declare const opTake: <T>(count: number) => import("../internalTypes.js").PipeFn<T, T>;
-//# sourceMappingURL=take.d.ts.map
+//# sourceMappingURL=take.d.mts.map

package/dist/esm/operators/take.js

@@ -28,4 +28,3 @@ export function opTakeSync(count) {
  * @param count - number to take
  */
 export const opTake = (count) => toPipeFn(opTakeSync(count), opTakeAsync(count));
-//# sourceMappingURL=take.js.map

package/dist/esm/operators/take.mjs

@@ -0,0 +1,30 @@
+import { toPipeFn } from '../helpers/util.mjs';
+export function opTakeAsync(count) {
+    async function* fn(iter) {
+        if (count <= 0)
+            return;
+        for await (const v of iter) {
+            yield v;
+            if (--count <= 0)
+                return;
+        }
+    }
+    return fn;
+}
+export function opTakeSync(count) {
+    function* fn(iter) {
+        if (count <= 0)
+            return;
+        for (const v of iter) {
+            yield v;
+            if (--count <= 0)
+                return;
+        }
+    }
+    return fn;
+}
+/**
+ * Consume only the first `count` number from the iterable.
+ * @param count - number to take
+ */
+export const opTake = (count) => toPipeFn(opTakeSync(count), opTakeAsync(count));

package/dist/{cjs/sync/operators/tap.d.ts → esm/operators/tap.d.mts}

@@ -16,4 +16,4 @@ export declare function opTapSync<T>(tapFn: (v: T) => void): (iter: Iterable<T>)
  * @param fn - function to call for each value.
  */
 export declare const opTap: <T>(fn: (v: T) => void) => import("../internalTypes.js").PipeFn<T, T>;
-//# sourceMappingURL=tap.d.ts.map
+//# sourceMappingURL=tap.d.mts.map

package/dist/esm/operators/tap.js

@@ -33,4 +33,3 @@ export function opTapSync(tapFn) {
  * @param fn - function to call for each value.
  */
 export const opTap = (fn) => toPipeFn(opTapSync(fn), opTapAsync(fn));
-//# sourceMappingURL=tap.js.map

package/dist/esm/operators/tap.mjs

@@ -0,0 +1,35 @@
+import { toPipeFn } from '../helpers/util.mjs';
+/**
+ * Tap allows you to listen on values, without modifying them.
+ *
+ * @param fn - function to call for each value.
+ */
+export function opTapAsync(tapFn) {
+    async function* fn(iter) {
+        for await (const v of iter) {
+            tapFn(v);
+            yield v;
+        }
+    }
+    return fn;
+}
+/**
+ * Tap allows you to listen on values, without modifying them.
+ *
+ * @param fn - function to call for each value.
+ */
+export function opTapSync(tapFn) {
+    function* fn(iter) {
+        for (const v of iter) {
+            tapFn(v);
+            yield v;
+        }
+    }
+    return fn;
+}
+/**
+ * Tap allows you to listen on values, without modifying them.
+ *
+ * @param fn - function to call for each value.
+ */
+export const opTap = (fn) => toPipeFn(opTapSync(fn), opTapAsync(fn));

package/dist/{cjs/operators/operators/types.d.ts → esm/operators/types.d.mts}

@@ -1,4 +1,4 @@
 export type OperatorSync<T, U = T> = (i: Iterable<T>) => Iterable<U>;
 export type OperatorAsync<T, U = T> = (i: AsyncIterable<T>) => AsyncIterable<U>;
 export type OperatorSyncToAsync<T, U = T> = (i: Iterable<T>) => AsyncIterable<U>;
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=types.d.mts.map

package/dist/esm/operators/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/esm/operators/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/{operators/unique.d.ts → esm/operators/unique.d.mts}

@@ -1,4 +1,4 @@
 export declare function opUniqueAsync<T, U>(k?: (v: T) => U): (iter: AsyncIterable<T>) => AsyncIterable<T>;
 export declare function opUniqueSync<T, U>(k?: (v: T) => U): (iter: Iterable<T>) => Iterable<T>;
 export declare const opUnique: <T, U = T>(getKey?: ((v: T) => U) | undefined) => import("../internalTypes.js").PipeFn<T, T>;
-//# sourceMappingURL=unique.d.ts.map
+//# sourceMappingURL=unique.d.mts.map

package/dist/esm/operators/unique.js

@@ -50,4 +50,3 @@ export function opUniqueSync(k) {
     return k ? fnK(k) : fn;
 }
 export const opUnique = (getKey) => toPipeFn(opUniqueSync(getKey), opUniqueAsync(getKey));
-//# sourceMappingURL=unique.js.map