@cspell/cspell-pipe 6.26.2 → 6.27.0

package/dist/esm/operators/concatMap.mjs

@@ -0,0 +1,19 @@
+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));
+//# sourceMappingURL=concatMap.mjs.map

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.mjs

@@ -0,0 +1,30 @@
+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 _;
+}
+//# sourceMappingURL=filter.mjs.map

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.mjs

@@ -0,0 +1,34 @@
+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 _;
+}
+//# sourceMappingURL=first.mjs.map

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.mjs

@@ -0,0 +1,19 @@
+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());
+//# sourceMappingURL=flatten.mjs.map

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.mjs

@@ -0,0 +1,16 @@
+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';
+//# sourceMappingURL=index.mjs.map

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.mjs

@@ -0,0 +1,22 @@
+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));
+//# sourceMappingURL=joinStrings.mjs.map

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.mjs

@@ -0,0 +1,39 @@
+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 _;
+}
+//# sourceMappingURL=last.mjs.map

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.mjs

@@ -0,0 +1,19 @@
+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));
+//# sourceMappingURL=map.mjs.map

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.mjs

@@ -0,0 +1,49 @@
+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';
+}
+//# sourceMappingURL=reduce.mjs.map

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.mjs

@@ -0,0 +1,27 @@
+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));
+//# sourceMappingURL=skip.mjs.map

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.mjs

@@ -0,0 +1,31 @@
+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));
+//# sourceMappingURL=take.mjs.map

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.mjs

@@ -0,0 +1,36 @@
+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));
+//# sourceMappingURL=tap.mjs.map

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.mjs

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

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.mjs

@@ -0,0 +1,53 @@
+import { toPipeFn } from '../helpers/util.mjs';
+export function opUniqueAsync(k) {
+    function fnK(k) {
+        async function* fn(iter) {
+            const s = new Set();
+            for await (const v of iter) {
+                const kk = k(v);
+                if (s.has(kk))
+                    continue;
+                s.add(kk);
+                yield v;
+            }
+        }
+        return fn;
+    }
+    async function* fn(iter) {
+        const s = new Set();
+        for await (const v of iter) {
+            if (s.has(v))
+                continue;
+            s.add(v);
+            yield v;
+        }
+    }
+    return k ? fnK(k) : fn;
+}
+export function opUniqueSync(k) {
+    function fnK(key) {
+        function* fn(iter) {
+            const s = new Set();
+            for (const v of iter) {
+                const kk = key(v);
+                if (s.has(kk))
+                    continue;
+                s.add(kk);
+                yield v;
+            }
+        }
+        return fn;
+    }
+    function* fn(iter) {
+        const s = new Set();
+        for (const v of iter) {
+            if (s.has(v))
+                continue;
+            s.add(v);
+            yield v;
+        }
+    }
+    return k ? fnK(k) : fn;
+}
+export const opUnique = (getKey) => toPipeFn(opUniqueSync(getKey), opUniqueAsync(getKey));
+//# sourceMappingURL=unique.mjs.map

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

@@ -1,4 +1,4 @@
-import type { AnyIterable, PipeAsyncTx, PipeSyncTx } from './internalTypes.js';
+import type { AnyIterable, PipeAsyncTx, PipeSyncTx } from './internalTypes.mjs';
 export declare function pipeAsync<T>(i: AnyIterable<T>): AsyncIterable<T>;
 export declare function pipeAsync<T, T0>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0]>): AsyncIterable<T0>;
 export declare function pipeAsync<T, T0, T1>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1]>): AsyncIterable<T1>;
@@ -17,4 +17,4 @@ export declare function pipeSync<T, T0, T1, T2, T3, T4>(i: Iterable<T>, ...f: Pi
 export declare function pipeSync<T, T0, T1, T2, T3, T4, T5>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1, T2, T3, T4, T5]>): Iterable<T5>;
 export declare function pipeSync<T, T0, T1, T2, T3, T4, T5, T6>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1, T2, T3, T4, T5, T6]>): Iterable<T6>;
 export declare function pipeSync<T, T0, T1, T2, T3, T4, T5, T6, T7>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1, T2, T3, T4, T5, T6, T7]>): Iterable<T7>;
-//# sourceMappingURL=pipe.d.ts.map
+//# sourceMappingURL=pipe.d.mts.map

package/dist/esm/pipe.mjs

@@ -0,0 +1,10 @@
+import { toAsyncIterable } from './helpers/index.mjs';
+import { opCombineAsync, opCombineSync } from './operators/index.mjs';
+export function pipeAsync(i, ...fns) {
+    const iter = toAsyncIterable(i);
+    return opCombineAsync(...fns)(iter);
+}
+export function pipeSync(i, ...fns) {
+    return opCombineSync(...fns)(i);
+}
+//# sourceMappingURL=pipe.mjs.map

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

@@ -1,4 +1,4 @@
-import type { AnyIterable } from './internalTypes.js';
+import type { AnyIterable } from './internalTypes.mjs';
 export declare function reduceSync<T>(iter: Iterable<T>, reduceFn: (prev: T, curr: T) => T): T | undefined;
 export declare function reduceSync<T>(iter: Iterable<T>, reduceFn: (prev: T, curr: T) => T, initialValue: T): T;
 export declare function reduceSync<T>(iter: Iterable<T>, reduceFn: (prev: T, curr: T) => T, initialValue?: T): T | undefined;
@@ -13,4 +13,4 @@ export declare function reduce<T, U>(iter: Iterable<T>, reduceFn: (prev: U, curr
 export declare function reduce<T>(iter: AsyncIterable<T>, reduceFn: (prev: T, curr: T) => T): Promise<T | undefined>;
 export declare function reduce<T>(iter: AsyncIterable<T>, reduceFn: (prev: T, curr: T) => T, initialValue: T): Promise<T>;
 export declare function reduce<T, U>(iter: AsyncIterable<T>, reduceFn: (prev: U, curr: T) => U, initialValue: U): Promise<U>;
-//# sourceMappingURL=reduce.d.ts.map
+//# sourceMappingURL=reduce.d.mts.map

package/dist/esm/reduce.mjs

@@ -0,0 +1,21 @@
+import { isAsyncIterable } from './helpers/index.mjs';
+import { toArrayAsync } from './helpers/toArray.mjs';
+import { opReduceAsync, opReduceSync } from './operators/index.mjs';
+import { pipeAsync, pipeSync } from './pipe.mjs';
+export function reduceSync(iter, reduceFn, initialValue) {
+    const i = initialValue === undefined
+        ? pipeSync(iter, opReduceSync(reduceFn))
+        : pipeSync(iter, opReduceSync(reduceFn, initialValue));
+    return [...i][0];
+}
+export async function reduceAsync(iter, reduceFn, initialValue) {
+    const i = initialValue === undefined
+        ? pipeAsync(iter, opReduceAsync(reduceFn))
+        : pipeAsync(iter, opReduceAsync(reduceFn, initialValue));
+    const arr = await toArrayAsync(i);
+    return arr[0];
+}
+export function reduce(iter, reduceFn, initialValue) {
+    return isAsyncIterable(iter) ? reduceAsync(iter, reduceFn, initialValue) : reduceSync(iter, reduceFn, initialValue);
+}
+//# sourceMappingURL=reduce.mjs.map

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

@@ -1,6 +1,6 @@
-export { toArraySync as toArray } from '../helpers/toArray.js';
-export type { OperatorSync as Operator } from '../operators/index.js';
-export { opAppendSync as opAppend, opCombineSync as opCombine, opConcatMapSync as opConcatMap, opFilterSync as opFilter, opFirstSync as opFirst, opFlattenSync as opFlatten, opJoinStringsSync as opJoinStrings, opLastSync as opLast, opMapSync as opMap, opReduceSync as opReduce, opSkipSync as opSkip, opTakeSync as opTake, opTapSync as opTap, opUniqueSync as opUnique, } from '../operators/index.js';
-export { pipeSync as pipe, pipeSync } from '../pipe.js';
-export { reduceSync as reduce } from '../reduce.js';
-//# sourceMappingURL=index.d.ts.map
+export { toArraySync as toArray } from '../helpers/toArray.mjs';
+export type { OperatorSync as Operator } from '../operators/index.mjs';
+export { opAppendSync as opAppend, opCombineSync as opCombine, opConcatMapSync as opConcatMap, opFilterSync as opFilter, opFirstSync as opFirst, opFlattenSync as opFlatten, opJoinStringsSync as opJoinStrings, opLastSync as opLast, opMapSync as opMap, opReduceSync as opReduce, opSkipSync as opSkip, opTakeSync as opTake, opTapSync as opTap, opUniqueSync as opUnique, } from '../operators/index.mjs';
+export { pipeSync as pipe, pipeSync } from '../pipe.mjs';
+export { reduceSync as reduce } from '../reduce.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/{cjs/sync/sync/index.d.ts → esm/sync/index.mjs}

@@ -1,6 +1,5 @@
-export { toArraySync as toArray } from '../helpers/toArray.js';
-export type { OperatorSync as Operator } from '../operators/index.js';
-export { opAppendSync as opAppend, opCombineSync as opCombine, opConcatMapSync as opConcatMap, opFilterSync as opFilter, opFirstSync as opFirst, opFlattenSync as opFlatten, opJoinStringsSync as opJoinStrings, opLastSync as opLast, opMapSync as opMap, opReduceSync as opReduce, opSkipSync as opSkip, opTakeSync as opTake, opTapSync as opTap, opUniqueSync as opUnique, } from '../operators/index.js';
-export { pipeSync as pipe, pipeSync } from '../pipe.js';
-export { reduceSync as reduce } from '../reduce.js';
-//# sourceMappingURL=index.d.ts.map
+export { toArraySync as toArray } from '../helpers/toArray.mjs';
+export { opAppendSync as opAppend, opCombineSync as opCombine, opConcatMapSync as opConcatMap, opFilterSync as opFilter, opFirstSync as opFirst, opFlattenSync as opFlatten, opJoinStringsSync as opJoinStrings, opLastSync as opLast, opMapSync as opMap, opReduceSync as opReduce, opSkipSync as opSkip, opTakeSync as opTake, opTapSync as opTap, opUniqueSync as opUnique, } from '../operators/index.mjs';
+export { pipeSync as pipe, pipeSync } from '../pipe.mjs';
+export { reduceSync as reduce } from '../reduce.mjs';
+//# sourceMappingURL=index.mjs.map