@cspell/cspell-pipe 6.26.2 → 6.27.0

package/dist/cjs/sync/index.cjs

@@ -1,245 +0,0 @@
-'use strict';
-
-function isAsyncIterable(i) {
-    return typeof i[Symbol.asyncIterator] === 'function';
-}
-
-function toArray(i) {
-    return isAsyncIterable(i) ? toArrayAsync(i) : toArraySync(i);
-}
-function toArraySync(iter) {
-    return [...iter];
-}
-async function toArrayAsync(iter) {
-    const collection = [];
-    for await (const i of iter) {
-        collection.push(i);
-    }
-    return collection;
-}
-
-function* iteratorToIterable(iterator) {
-    let n;
-    while (!(n = iterator.next()).done) {
-        yield n.value;
-    }
-}
-
-/**
- * Append values onto the end of an iterable.
- * @param iterablesToAppend - the iterables in the order to be appended.
- * @returns
- */
-function opAppendSync(...iterablesToAppend) {
-    function* fn(iter) {
-        yield* iter;
-        for (const i of iterablesToAppend) {
-            yield* i;
-        }
-    }
-    return fn;
-}
-
-function opCombineSync(...fns) {
-    function combine(iter) {
-        for (const fn of fns) {
-            iter = fn(iter);
-        }
-        return iter;
-    }
-    return combine;
-}
-
-function opConcatMapSync(mapFn) {
-    function* fn(iter) {
-        for (const v of iter) {
-            yield* mapFn(v);
-        }
-    }
-    return fn;
-}
-
-function opFilterSync(filterFn) {
-    function* fn(iter) {
-        for (const v of iter) {
-            if (filterFn(v))
-                yield v;
-        }
-    }
-    return fn;
-}
-
-function opFirstSync(firstFn) {
-    function* fn(iter) {
-        for (const v of iter) {
-            if (firstFn(v)) {
-                yield v;
-                break;
-            }
-        }
-    }
-    return fn;
-}
-
-function opFlattenSync() {
-    function* fn(iter) {
-        for (const v of iter) {
-            yield* v;
-        }
-    }
-    return fn;
-}
-
-function opJoinStringsSync(joinCharacter = ',') {
-    function* fn(iter) {
-        for (const v of iter) {
-            const a = toArray(v);
-            yield a.join(joinCharacter);
-        }
-    }
-    return fn;
-}
-
-const symNotFound = Symbol('LastNotFound');
-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;
-}
-
-function opMapSync(mapFn) {
-    function* fn(iter) {
-        for (const v of iter) {
-            yield mapFn(v);
-        }
-    }
-    return fn;
-}
-
-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) };
-}
-
-function opSkipSync(count) {
-    function* fn(iter) {
-        for (const v of iter) {
-            if (count > 0) {
-                --count;
-                continue;
-            }
-            yield v;
-        }
-    }
-    return fn;
-}
-
-function opTakeSync(count) {
-    function* fn(iter) {
-        if (count <= 0)
-            return;
-        for (const v of iter) {
-            yield v;
-            if (--count <= 0)
-                return;
-        }
-    }
-    return fn;
-}
-
-/**
- * Tap allows you to listen on values, without modifying them.
- *
- * @param fn - function to call for each value.
- */
-function opTapSync(tapFn) {
-    function* fn(iter) {
-        for (const v of iter) {
-            tapFn(v);
-            yield v;
-        }
-    }
-    return fn;
-}
-
-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;
-}
-
-function pipeSync(i, ...fns) {
-    return opCombineSync(...fns)(i);
-}
-
-function reduceSync(iter, reduceFn, initialValue) {
-    const i = initialValue === undefined
-        ? pipeSync(iter, opReduceSync(reduceFn))
-        : pipeSync(iter, opReduceSync(reduceFn, initialValue));
-    return [...i][0];
-}
-
-exports.opAppend = opAppendSync;
-exports.opCombine = opCombineSync;
-exports.opConcatMap = opConcatMapSync;
-exports.opFilter = opFilterSync;
-exports.opFirst = opFirstSync;
-exports.opFlatten = opFlattenSync;
-exports.opJoinStrings = opJoinStringsSync;
-exports.opLast = opLastSync;
-exports.opMap = opMapSync;
-exports.opReduce = opReduceSync;
-exports.opSkip = opSkipSync;
-exports.opTake = opTakeSync;
-exports.opTap = opTapSync;
-exports.opUnique = opUniqueSync;
-exports.pipe = pipeSync;
-exports.pipeSync = pipeSync;
-exports.reduce = reduceSync;
-exports.toArray = toArraySync;

package/dist/cjs/sync/internalTypes.d.ts

@@ -1,17 +0,0 @@
-export interface PipeFnSync<T, U> {
-    (iter: Iterable<T>): Iterable<U>;
-    /** This is just to help TypeScript figure out the type. */
-    __PipeFnSync__?: [T, U];
-}
-export interface PipeFnAsync<T, U> {
-    (iter: AsyncIterable<T>): AsyncIterable<U>;
-    /** This is just to help TypeScript figure out the type. */
-    __PipeFnAsync__?: [T, U];
-}
-export type PipeFn<T, U> = PipeFnSync<T, U> & PipeFnAsync<T, U>;
-export type PsFn<T, U> = PipeFnSync<T, U> | ((i: Iterable<T>) => Iterable<U>);
-export type AnyIterable<T> = Iterable<T> | AsyncIterable<T> | Promise<Iterable<T>> | Iterable<Promise<T>>;
-export type PaFn<T, U> = PipeFnAsync<T, U> | ((i: AsyncIterable<T>) => AsyncIterable<U>);
-export type PipeAsyncTx<T extends [...any]> = T extends [infer Left, infer Right, ...infer Rest] ? Rest extends [any, ...any] ? [PaFn<Left, Right>, ...PipeAsyncTx<[Right, ...Rest]>] : [PaFn<Left, Right>] : never;
-export type PipeSyncTx<T extends [...any]> = T extends [infer Left, infer Right, ...infer Rest] ? Rest extends [any, ...any] ? [PsFn<Left, Right>, ...PipeSyncTx<[Right, ...Rest]>] : [PsFn<Left, Right>] : never;
-//# sourceMappingURL=internalTypes.d.ts.map

package/dist/cjs/sync/operators/await.d.ts

@@ -1,2 +0,0 @@
-export declare function opAwaitAsync<T>(): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
-//# sourceMappingURL=await.d.ts.map

package/dist/cjs/sync/operators/combine.d.ts

@@ -1,23 +0,0 @@
-import type { PaFn, PipeAsyncTx, PipeSyncTx, PsFn } from '../internalTypes.js';
-import type { OperatorAsync, OperatorSync } from './types.js';
-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>;
-export declare function opCombineAsync<T, T0, T1, T2>(...f: PipeAsyncTx<[T, T0, T1, T2]>): OperatorAsync<T2>;
-export declare function opCombineAsync<T, T0, T1, T2, T3>(...f: PipeAsyncTx<[T, T0, T1, T2, T3]>): OperatorAsync<T3>;
-export declare function opCombineAsync<T, T0, T1, T2, T3, T4>(...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4]>): OperatorAsync<T4>;
-export declare function opCombineAsync<T, T0, T1, T2, T3, T4, T5>(...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4, T5]>): OperatorAsync<T5>;
-export declare function opCombineAsync<T, T0, T1, T2, T3, T4, T5, T6>(...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4, T5, T6]>): OperatorAsync<T6>;
-export declare function opCombineAsync<T, T0, T1, T2, T3, T4, T5, T6, T7>(...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4, T5, T6, T7]>): OperatorAsync<T7>;
-export declare function opCombineAsync<T>(...fns: PaFn<T, T>[]): OperatorAsync<T>;
-export declare function opCombineSync<T>(): OperatorSync<T>;
-export declare function opCombineSync<T, T0 = T>(...f: PipeSyncTx<[T, T0]>): OperatorSync<T0>;
-export declare function opCombineSync<T, T0, T1>(...f: PipeSyncTx<[T, T0, T1]>): OperatorSync<T1>;
-export declare function opCombineSync<T, T0, T1, T2>(...f: PipeSyncTx<[T, T0, T1, T2]>): OperatorSync<T2>;
-export declare function opCombineSync<T, T0, T1, T2, T3>(...f: PipeSyncTx<[T, T0, T1, T2, T3]>): OperatorSync<T3>;
-export declare function opCombineSync<T, T0, T1, T2, T3, T4>(...f: PipeSyncTx<[T, T0, T1, T2, T3, T4]>): OperatorSync<T4>;
-export declare function opCombineSync<T, T0, T1, T2, T3, T4, T5>(...f: PipeSyncTx<[T, T0, T1, T2, T3, T4, T5]>): OperatorSync<T5>;
-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

package/dist/cjs/sync/operators/concatMap.d.ts

@@ -1,4 +0,0 @@
-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

package/dist/cjs/sync/operators/filter.d.ts

@@ -1,10 +0,0 @@
-import type { PipeFn } from '../internalTypes.js';
-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>>;
-export declare function opFilterAsync<T>(filterFn: (v: Awaited<T>) => Promise<boolean>): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
-export declare function opFilterSync<T, S extends T>(filterFn: (v: T) => v is S): (iter: Iterable<T>) => Iterable<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

package/dist/cjs/sync/operators/first.d.ts

@@ -1,10 +0,0 @@
-import type { PipeFn } from '../internalTypes.js';
-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>>;
-export declare function opFirstAsync<T>(firstFn: (v: Awaited<T>) => Promise<boolean>): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
-export declare function opFirstSync<T, S extends T>(firstFn: (v: T) => v is S): (iter: Iterable<T>) => Iterable<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

package/dist/cjs/sync/operators/flatten.d.ts

@@ -1,4 +0,0 @@
-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

package/dist/cjs/sync/operators/index.d.ts

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

package/dist/cjs/sync/operators/joinStrings.d.ts

@@ -1,4 +0,0 @@
-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

package/dist/cjs/sync/operators/last.d.ts

@@ -1,10 +0,0 @@
-import type { PipeFn } from '../internalTypes.js';
-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>>;
-export declare function opLastAsync<T>(lastFn: (v: Awaited<T>) => Promise<boolean>): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
-export declare function opLastSync<T, S extends T>(lastFn: (v: T) => v is S): (iter: Iterable<T>) => Iterable<S>;
-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

package/dist/cjs/sync/operators/map.d.ts

@@ -1,4 +0,0 @@
-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

package/dist/cjs/sync/operators/reduce.d.ts

@@ -1,7 +0,0 @@
-export declare function opReduceAsync<T>(reduceFn: (previousValue: T, currentValue: T) => T): (iter: AsyncIterable<T> | Iterable<T>) => AsyncIterable<T>;
-export declare function opReduceAsync<T>(reduceFn: (previousValue: T, currentValue: T) => T, initialValue: T | Promise<T>): (iter: AsyncIterable<T> | Iterable<T>) => AsyncIterable<T>;
-export declare function opReduceAsync<T, U>(reduceFn: (previousValue: U, currentValue: T) => U, initialValue: U | Promise<U>): (iter: AsyncIterable<T> | Iterable<T>) => AsyncIterable<U>;
-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

package/dist/cjs/sync/operators/skip.d.ts

@@ -1,4 +0,0 @@
-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

package/dist/cjs/sync/operators/take.d.ts

@@ -1,8 +0,0 @@
-export declare function opTakeAsync<T>(count: number): (iter: AsyncIterable<T> | Iterable<T>) => AsyncIterable<T>;
-export declare function opTakeSync<T>(count: number): (iter: Iterable<T>) => Iterable<T>;
-/**
- * Consume only the first `count` number from the iterable.
- * @param count - number to take
- */
-export declare const opTake: <T>(count: number) => import("../internalTypes.js").PipeFn<T, T>;
-//# sourceMappingURL=take.d.ts.map

package/dist/cjs/sync/operators/types.d.ts

@@ -1,4 +0,0 @@
-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

package/dist/cjs/sync/operators/unique.d.ts

@@ -1,4 +0,0 @@
-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

package/dist/cjs/sync/pipe.d.ts

@@ -1,20 +0,0 @@
-import type { AnyIterable, PipeAsyncTx, PipeSyncTx } from './internalTypes.js';
-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>;
-export declare function pipeAsync<T, T0, T1, T2>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1, T2]>): AsyncIterable<T2>;
-export declare function pipeAsync<T, T0, T1, T2, T3>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1, T2, T3]>): AsyncIterable<T3>;
-export declare function pipeAsync<T, T0, T1, T2, T3, T4>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4]>): AsyncIterable<T4>;
-export declare function pipeAsync<T, T0, T1, T2, T3, T4, T5>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4, T5]>): AsyncIterable<T5>;
-export declare function pipeAsync<T, T0, T1, T2, T3, T4, T5, T6>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4, T5, T6]>): AsyncIterable<T6>;
-export declare function pipeAsync<T, T0, T1, T2, T3, T4, T5, T6, T7>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4, T5, T6, T7]>): AsyncIterable<T7>;
-export declare function pipeSync<T>(i: Iterable<T>): Iterable<T>;
-export declare function pipeSync<T, T0 = T>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0]>): Iterable<T0>;
-export declare function pipeSync<T, T0, T1>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1]>): Iterable<T1>;
-export declare function pipeSync<T, T0, T1, T2>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1, T2]>): Iterable<T2>;
-export declare function pipeSync<T, T0, T1, T2, T3>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1, T2, T3]>): Iterable<T3>;
-export declare function pipeSync<T, T0, T1, T2, T3, T4>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1, T2, T3, T4]>): Iterable<T4>;
-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

package/dist/helpers/distribute.d.ts

@@ -1,13 +0,0 @@
-/**
- * Allows an iterable to be shared by multiple consumers.
- * Each consumer takes from the iterable.
- * @param iterable - the iterable to share
- */
-export declare function toDistributableIterableSync<T>(iterable: Iterable<T>): Iterable<T>;
-/**
- * Allows an iterable to be shared by multiple consumers.
- * Each consumer takes from the iterable.
- * @param iterable - the iterable to share
- */
-export declare const toDistributableIterable: typeof toDistributableIterableSync;
-//# sourceMappingURL=distribute.d.ts.map

package/dist/helpers/index.d.ts

@@ -1,7 +0,0 @@
-export { toDistributableIterable } from './distribute.js';
-export { interleave } from './interleave.js';
-export { asyncIteratorToAsyncIterable, iteratorToIterable } from './iteratorToIterable.js';
-export { toArray } from './toArray.js';
-export { toAsyncIterable } from './toAsyncIterable.js';
-export { isAsyncIterable } from './util.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/helpers/interleave.d.ts

@@ -1,2 +0,0 @@
-export declare function interleave<T>(a: Iterable<T>, b: Iterable<T>): Iterable<T>;
-//# sourceMappingURL=interleave.d.ts.map

package/dist/helpers/iteratorToIterable.d.ts

@@ -1,3 +0,0 @@
-export declare function iteratorToIterable<T>(iterator: Iterator<T>): Iterable<T>;
-export declare function asyncIteratorToAsyncIterable<T>(iterator: AsyncIterator<T> | Iterator<T>): AsyncIterable<T>;
-//# sourceMappingURL=iteratorToIterable.d.ts.map

package/dist/helpers/toArray.d.ts

@@ -1,6 +0,0 @@
-export declare function toArray<T>(i: AsyncIterable<T>): Promise<Awaited<T>[]>;
-export declare function toArray<T>(i: Iterable<T>): T[];
-export declare function toArray<T>(i: Iterable<T> | AsyncIterable<T>): T[] | Promise<Awaited<T>[]>;
-export declare function toArraySync<T>(iter: Iterable<T>): T[];
-export declare function toArrayAsync<T>(iter: AsyncIterable<T>): Promise<Awaited<T>[]>;
-//# sourceMappingURL=toArray.d.ts.map

package/dist/helpers/toAsyncIterable.d.ts

@@ -1,11 +0,0 @@
-import type { AnyIterable } from '../internalTypes.js';
-export declare function mergeAsyncIterables<T>(iter: Iterable<T>): AsyncIterable<T>;
-export declare function mergeAsyncIterables<T>(iter: AsyncIterable<T>): AsyncIterable<T>;
-export declare function mergeAsyncIterables<T>(iter: Promise<Iterable<T>>): AsyncIterable<T>;
-export declare function mergeAsyncIterables<T>(iter: AnyIterable<T>): AsyncIterable<T>;
-export declare function mergeAsyncIterables<T>(iter: AnyIterable<T>, ...rest: AnyIterable<T>[]): AsyncIterable<T>;
-/**
- * Convert one or more iterables to an AsyncIterable
- */
-export declare const toAsyncIterable: typeof mergeAsyncIterables;
-//# sourceMappingURL=toAsyncIterable.d.ts.map

package/dist/helpers/util.d.ts

@@ -1,4 +0,0 @@
-import type { AnyIterable, PipeFn, PipeFnAsync, PipeFnSync } from '../internalTypes.js';
-export declare function toPipeFn<T, U = T>(syncFn: PipeFnSync<T, U>, asyncFn: PipeFnAsync<T, U>): PipeFn<T, U>;
-export declare function isAsyncIterable<T>(i: AnyIterable<T>): i is AsyncIterable<T>;
-//# sourceMappingURL=util.d.ts.map

package/dist/index.d.ts

@@ -1,9 +0,0 @@
-import * as _helpers from './helpers/index.js';
-import * as _operators from './operators/index.js';
-export { interleave, isAsyncIterable, toArray, toAsyncIterable, toDistributableIterable } from './helpers/index.js';
-export { opAppend, opAwaitAsync, opConcatMap, opFilter, opFirst, opFlatten, opJoinStrings, opLast, opMap, opSkip, opTake, opTap, opUnique, } from './operators/index.js';
-export { pipeAsync, pipeSync } from './pipe.js';
-export { reduce, reduceAsync, reduceSync } from './reduce.js';
-export declare const operators: typeof _operators;
-export declare const helpers: typeof _helpers;
-//# sourceMappingURL=index.d.ts.map

package/dist/internalTypes.d.ts

@@ -1,17 +0,0 @@
-export interface PipeFnSync<T, U> {
-    (iter: Iterable<T>): Iterable<U>;
-    /** This is just to help TypeScript figure out the type. */
-    __PipeFnSync__?: [T, U];
-}
-export interface PipeFnAsync<T, U> {
-    (iter: AsyncIterable<T>): AsyncIterable<U>;
-    /** This is just to help TypeScript figure out the type. */
-    __PipeFnAsync__?: [T, U];
-}
-export type PipeFn<T, U> = PipeFnSync<T, U> & PipeFnAsync<T, U>;
-export type PsFn<T, U> = PipeFnSync<T, U> | ((i: Iterable<T>) => Iterable<U>);
-export type AnyIterable<T> = Iterable<T> | AsyncIterable<T> | Promise<Iterable<T>> | Iterable<Promise<T>>;
-export type PaFn<T, U> = PipeFnAsync<T, U> | ((i: AsyncIterable<T>) => AsyncIterable<U>);
-export type PipeAsyncTx<T extends [...any]> = T extends [infer Left, infer Right, ...infer Rest] ? Rest extends [any, ...any] ? [PaFn<Left, Right>, ...PipeAsyncTx<[Right, ...Rest]>] : [PaFn<Left, Right>] : never;
-export type PipeSyncTx<T extends [...any]> = T extends [infer Left, infer Right, ...infer Rest] ? Rest extends [any, ...any] ? [PsFn<Left, Right>, ...PipeSyncTx<[Right, ...Rest]>] : [PsFn<Left, Right>] : never;
-//# sourceMappingURL=internalTypes.d.ts.map

package/dist/operators/append.d.ts

@@ -1,15 +0,0 @@
-import type { PipeFn } from '../internalTypes.js';
-/**
- * Append values onto the end of an iterable.
- * @param iterablesToAppend - the iterables in the order to be appended.
- * @returns
- */
-export declare function opAppendAsync<T>(...iterablesToAppend: (AsyncIterable<T> | Iterable<T>)[]): (iter: AsyncIterable<T> | Iterable<T>) => AsyncIterable<T>;
-/**
- * Append values onto the end of an iterable.
- * @param iterablesToAppend - the iterables in the order to be appended.
- * @returns
- */
-export declare function opAppendSync<T>(...iterablesToAppend: Iterable<T>[]): (iter: Iterable<T>) => Iterable<T>;
-export declare function opAppend<T>(...iterablesToAppend: Iterable<T>[]): PipeFn<T, T>;
-//# sourceMappingURL=append.d.ts.map

package/dist/operators/await.d.ts

@@ -1,2 +0,0 @@
-export declare function opAwaitAsync<T>(): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
-//# sourceMappingURL=await.d.ts.map

package/dist/operators/combine.d.ts

@@ -1,23 +0,0 @@
-import type { PaFn, PipeAsyncTx, PipeSyncTx, PsFn } from '../internalTypes.js';
-import type { OperatorAsync, OperatorSync } from './types.js';
-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>;
-export declare function opCombineAsync<T, T0, T1, T2>(...f: PipeAsyncTx<[T, T0, T1, T2]>): OperatorAsync<T2>;
-export declare function opCombineAsync<T, T0, T1, T2, T3>(...f: PipeAsyncTx<[T, T0, T1, T2, T3]>): OperatorAsync<T3>;
-export declare function opCombineAsync<T, T0, T1, T2, T3, T4>(...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4]>): OperatorAsync<T4>;
-export declare function opCombineAsync<T, T0, T1, T2, T3, T4, T5>(...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4, T5]>): OperatorAsync<T5>;
-export declare function opCombineAsync<T, T0, T1, T2, T3, T4, T5, T6>(...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4, T5, T6]>): OperatorAsync<T6>;
-export declare function opCombineAsync<T, T0, T1, T2, T3, T4, T5, T6, T7>(...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4, T5, T6, T7]>): OperatorAsync<T7>;
-export declare function opCombineAsync<T>(...fns: PaFn<T, T>[]): OperatorAsync<T>;
-export declare function opCombineSync<T>(): OperatorSync<T>;
-export declare function opCombineSync<T, T0 = T>(...f: PipeSyncTx<[T, T0]>): OperatorSync<T0>;
-export declare function opCombineSync<T, T0, T1>(...f: PipeSyncTx<[T, T0, T1]>): OperatorSync<T1>;
-export declare function opCombineSync<T, T0, T1, T2>(...f: PipeSyncTx<[T, T0, T1, T2]>): OperatorSync<T2>;
-export declare function opCombineSync<T, T0, T1, T2, T3>(...f: PipeSyncTx<[T, T0, T1, T2, T3]>): OperatorSync<T3>;
-export declare function opCombineSync<T, T0, T1, T2, T3, T4>(...f: PipeSyncTx<[T, T0, T1, T2, T3, T4]>): OperatorSync<T4>;
-export declare function opCombineSync<T, T0, T1, T2, T3, T4, T5>(...f: PipeSyncTx<[T, T0, T1, T2, T3, T4, T5]>): OperatorSync<T5>;
-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

package/dist/operators/concatMap.d.ts

@@ -1,4 +0,0 @@
-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

package/dist/operators/filter.d.ts

@@ -1,10 +0,0 @@
-import type { PipeFn } from '../internalTypes.js';
-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>>;
-export declare function opFilterAsync<T>(filterFn: (v: Awaited<T>) => Promise<boolean>): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
-export declare function opFilterSync<T, S extends T>(filterFn: (v: T) => v is S): (iter: Iterable<T>) => Iterable<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

package/dist/operators/first.d.ts

@@ -1,10 +0,0 @@
-import type { PipeFn } from '../internalTypes.js';
-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>>;
-export declare function opFirstAsync<T>(firstFn: (v: Awaited<T>) => Promise<boolean>): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
-export declare function opFirstSync<T, S extends T>(firstFn: (v: T) => v is S): (iter: Iterable<T>) => Iterable<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

package/dist/operators/flatten.d.ts

@@ -1,4 +0,0 @@
-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

package/dist/operators/index.d.ts

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

package/dist/operators/joinStrings.d.ts

@@ -1,4 +0,0 @@
-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