@cspell/cspell-pipe 6.18.0 → 6.19.0

package/dist/esm/operators/tap.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Tap allows you to listen on values, without modifying them.
+ *
+ * @param fn - function to call for each value.
+ */
+export declare function opTapAsync<T>(tapFn: (v: T) => void): (iter: AsyncIterable<T>) => AsyncIterable<T>;
+/**
+ * Tap allows you to listen on values, without modifying them.
+ *
+ * @param fn - function to call for each value.
+ */
+export declare function opTapSync<T>(tapFn: (v: T) => void): (iter: Iterable<T>) => Iterable<T>;
+/**
+ * Tap allows you to listen on values, without modifying them.
+ *
+ * @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

package/dist/esm/operators/tap.js

@@ -0,0 +1,36 @@
+import { toPipeFn } from '../helpers/util.js';
+/**
+ * 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.js.map

package/dist/esm/operators/types.d.ts

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

package/dist/esm/operators/types.js

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

package/dist/esm/operators/unique.d.ts

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

package/dist/esm/operators/unique.js

@@ -0,0 +1,53 @@
+import { toPipeFn } from '../helpers/util.js';
+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.js.map

package/dist/esm/pipe.d.ts

@@ -0,0 +1,20 @@
+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/esm/pipe.js

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

package/dist/esm/reduce.d.ts

@@ -0,0 +1,16 @@
+import type { AnyIterable } from './internalTypes.js';
+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;
+export declare function reduceSync<T, U>(iter: Iterable<T>, reduceFn: (prev: U, curr: T) => U, initialValue: U): U;
+export declare function reduceAsync<T>(iter: AnyIterable<T>, reduceFn: (prev: T, curr: T) => T): Promise<T | undefined>;
+export declare function reduceAsync<T>(iter: AnyIterable<T>, reduceFn: (prev: T, curr: T) => T, initialValue: T): Promise<T>;
+export declare function reduceAsync<T>(iter: AnyIterable<T>, reduceFn: (prev: T, curr: T) => T, initialValue?: T): Promise<T | undefined>;
+export declare function reduceAsync<T, U>(iter: AnyIterable<T>, reduceFn: (prev: U, curr: T) => U, initialValue: U): Promise<U>;
+export declare function reduce<T>(iter: Iterable<T>, reduceFn: (prev: T, curr: T) => T): T | undefined;
+export declare function reduce<T>(iter: Iterable<T>, reduceFn: (prev: T, curr: T) => T, initialValue: T): T;
+export declare function reduce<T, U>(iter: Iterable<T>, reduceFn: (prev: U, curr: T) => U, initialValue: U): U;
+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

package/dist/esm/reduce.js

@@ -0,0 +1,21 @@
+import { isAsyncIterable } from './helpers/index.js';
+import { toArrayAsync } from './helpers/toArray.js';
+import { opReduceAsync, opReduceSync } from './operators/index.js';
+import { pipeAsync, pipeSync } from './pipe.js';
+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.js.map

package/dist/esm/sync/index.d.ts

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

package/dist/esm/sync/index.js

@@ -0,0 +1,5 @@
+export { toArraySync as toArray } from '../helpers/toArray.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.js.map

package/dist/helpers/index.d.ts

@@ -1,7 +1,7 @@
-export { toDistributableIterable } from './distribute';
-export { interleave } from './interleave';
-export { asyncIteratorToAsyncIterable, iteratorToIterable } from './iteratorToIterable';
-export { toArray } from './toArray';
-export { toAsyncIterable } from './toAsyncIterable';
-export { isAsyncIterable } from './util';
+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/toAsyncIterable.d.ts

@@ -1,4 +1,4 @@
-import { AnyIterable } from '../internalTypes';
+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>;

package/dist/helpers/util.d.ts

@@ -1,4 +1,4 @@
-import { AnyIterable, PipeFn, PipeFnAsync, PipeFnSync } from '../internalTypes';
+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 +1,9 @@
-import * as _helpers from './helpers';
-import * as _operators from './operators';
-export { interleave, isAsyncIterable, toArray, toAsyncIterable, toDistributableIterable } from './helpers';
-export { opAppend, opAwaitAsync, opConcatMap, opFilter, opFirst, opFlatten, opJoinStrings, opLast, opMap, opSkip, opTake, opTap, opUnique, } from './operators';
-export { pipeAsync, pipeSync } from './pipe';
-export { reduce, reduceAsync, reduceSync } from './reduce';
+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/operators/append.d.ts

@@ -1,4 +1,4 @@
-import { PipeFn } from '../internalTypes';
+import type { PipeFn } from '../internalTypes.js';
 /**
  * Append values onto the end of an iterable.
  * @param iterablesToAppend - the iterables in the order to be appended.

package/dist/operators/combine.d.ts

@@ -1,5 +1,5 @@
-import { PaFn, PipeAsyncTx, PipeSyncTx, PsFn } from '../internalTypes';
-import { OperatorAsync, OperatorSync } from './types';
+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>;

package/dist/operators/concatMap.d.ts

@@ -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").PipeFn<T, 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,4 +1,4 @@
-import { PipeFn } from '../internalTypes';
+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>>;

package/dist/operators/first.d.ts

@@ -1,4 +1,4 @@
-import { PipeFn } from '../internalTypes';
+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>>;

package/dist/operators/flatten.d.ts

@@ -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").PipeFn<Iterable<T>, 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 +1,17 @@
-export { opAppend, opAppendAsync, opAppendSync } from './append';
-export { opAwaitAsync } from './await';
-export { opCombineAsync, opCombineSync } from './combine';
-export { opConcatMap, opConcatMapAsync, opConcatMapSync } from './concatMap';
-export { opFilter, opFilterAsync, opFilterSync } from './filter';
-export { opFirst, opFirstAsync, opFirstSync } from './first';
-export { opFlatten, opFlattenAsync, opFlattenSync } from './flatten';
-export { opJoinStrings, opJoinStringsAsync, opJoinStringsSync } from './joinStrings';
-export { opLast, opLastAsync, opLastSync } from './last';
-export { opMap, opMapAsync, opMapSync } from './map';
-export { opReduceAsync, opReduceSync } from './reduce';
-export { opSkip, opSkipAsync, opSkipSync } from './skip';
-export { opTake, opTakeAsync, opTakeSync } from './take';
-export { opTap, opTapAsync, opTapSync } from './tap';
-export type { OperatorAsync, OperatorSync, OperatorSyncToAsync } from './types';
-export { opUnique, opUniqueAsync, opUniqueSync } from './unique';
+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 +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").PipeFn<Iterable<string>, string>;
+export declare const opJoinStrings: (joinCharacter?: string) => import("../internalTypes.js").PipeFn<Iterable<string>, string>;
 //# sourceMappingURL=joinStrings.d.ts.map

package/dist/operators/last.d.ts

@@ -1,4 +1,4 @@
-import { PipeFn } from '../internalTypes';
+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>>;

package/dist/operators/map.d.ts

@@ -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").PipeFn<T, U>;
+export declare const opMap: <T, U>(fn: (v: T) => U) => import("../internalTypes.js").PipeFn<T, U>;
 //# sourceMappingURL=map.d.ts.map

package/dist/operators/skip.d.ts

@@ -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").PipeFn<T, T>;
+export declare const opSkip: <T>(count: number) => import("../internalTypes.js").PipeFn<T, T>;
 //# sourceMappingURL=skip.d.ts.map

package/dist/operators/take.d.ts

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

package/dist/operators/tap.d.ts

@@ -15,5 +15,5 @@ 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").PipeFn<T, T>;
+export declare const opTap: <T>(fn: (v: T) => void) => import("../internalTypes.js").PipeFn<T, T>;
 //# sourceMappingURL=tap.d.ts.map

package/dist/operators/unique.d.ts

@@ -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").PipeFn<T, 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/pipe.d.ts

@@ -1,4 +1,4 @@
-import { AnyIterable, PipeAsyncTx, PipeSyncTx } from './internalTypes';
+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>;

package/dist/reduce.d.ts

@@ -1,4 +1,4 @@
-import { AnyIterable } from './internalTypes';
+import type { AnyIterable } from './internalTypes.js';
 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;

package/dist/sync/index.d.ts

@@ -1,6 +1,6 @@
-export { toArraySync as toArray } from '../helpers/toArray';
-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';
-export type { OperatorSync as Operator } from '../operators';
-export { pipeSync as pipe, pipeSync } from '../pipe';
-export { reduceSync as reduce } from '../reduce';
+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

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "6.18.0",
+  "version": "6.19.0",
   "description": "Library to make working with Iterators/AsyncIterators easier.",
   "keywords": [
     "cspell",
@@ -16,42 +16,59 @@
   "author": "Jason Dent <jason@streetsidesoftware.nl>",
   "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-pipe#readme",
   "license": "MIT",
-  "main": "dist/index.js",
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
   "directories": {
     "dist": "dist"
   },
   "exports": {
     ".": {
-      "require": "./dist/index.js"
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.cjs"
+    },
+    "./index": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.cjs"
+    },
+    "./index.js": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.cjs"
+    },
+    "./index.d.ts": {
+      "import": "./dist/esm/index.d.ts",
+      "require": "./dist/cjs/index.d.ts"
     },
-    "./index": "./dist/index.js",
-    "./index.js": "./dist/index.js",
-    "./index.d.ts": "./dist/index.d.ts",
     "./operators": {
-      "require": "./dist/operators/index.js"
+      "import": "./dist/esm/operators/index.js",
+      "require": "./dist/cjs/operators/index.cjs"
     },
     "./operators/index.js": {
-      "require": "./dist/operators/index.js"
+      "import": "./dist/esm/operators/index.js",
+      "require": "./dist/cjs/operators/index.cjs"
     },
     "./operators/index.d.ts": {
-      "require": "./dist/operators/index.js"
+      "import": "./dist/esm/operators/index.d.ts",
+      "require": "./dist/cjs/operators/index.d.ts"
     },
     "./sync": {
-      "require": "./dist/sync/index.js",
-      "types": "./dist/sync/index.d.ts",
-      "default": "./dist/sync/index.js"
+      "import": "./dist/esm/sync/index.js",
+      "require": "./dist/cjs/sync/index.cjs"
     },
     "./sync/index": {
-      "require": "./dist/sync/index.js"
+      "import": "./dist/esm/sync/index.js",
+      "require": "./dist/cjs/sync/index.cjs"
     },
     "./sync/index.js": {
-      "require": "./dist/sync/index.js"
+      "import": "./dist/esm/sync/index.js",
+      "require": "./dist/cjs/sync/index.cjs"
     },
     "./sync/index.d.ts": {
-      "require": "./dist/sync/index.d.ts"
+      "import": "./dist/esm/sync/index.d.ts",
+      "require": "./dist/cjs/sync/index.d.ts"
     }
   },
-  "typings": "dist/index.d.ts",
+  "types": "dist/index.d.ts",
   "typesVersions": {
     "*": {
       "index.d.ts": [
@@ -75,8 +92,11 @@
       "sync/index.d.ts": [
         "dist/sync/index.d.ts"
       ],
+      "dist/cjs/index.d.ts": [
+        "dist/index.d.ts"
+      ],
       "*": [
-        "dist/*",
+        "dist/*.d.ts",
         "dist/*/index.d.ts"
       ]
     }
@@ -90,14 +110,19 @@
     "!**/*.map"
   ],
   "scripts": {
-    "build": "tsc -p .",
+    "build": "pnpm build:types && pnpm build:esm && pnpm build:cjs",
+    "build:cjs": "rollup -c rollup.config.mjs",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:types": "tsc --emitDeclarationOnly --declaration --declarationDir dist",
     "build-dev": "tsc -p tsconfig.dev.json",
     "watch": "tsc -p . -w",
-    "clean": "rimraf dist coverage .tsbuildinfo",
+    "clean": "shx rm -rf dist coverage .tsbuildinfo",
     "clean-build": "pnpm run clean && pnpm run build",
-    "coverage": "jest --coverage",
-    "test-watch": "jest --watch",
-    "test": "jest"
+    "coverage": "pnpm coverage:vitest && pnpm coverage:fix",
+    "coverage:vitest": "vitest run --coverage",
+    "coverage:fix": "nyc report --temp-dir \"$(pwd)/coverage\" --reporter lcov --report-dir \"$(pwd)/coverage\" --cwd ../..",
+    "test-watch": "vitest",
+    "test": "vitest run"
   },
   "repository": {
     "type": "git",
@@ -110,9 +135,18 @@
     "node": ">=14"
   },
   "devDependencies": {
-    "@types/node": "^18.11.17",
+    "@rollup/plugin-commonjs": "^24.0.0",
+    "@rollup/plugin-json": "^6.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "@rollup/plugin-typescript": "^11.0.0",
+    "@types/node": "^18.11.18",
+    "globby": "^13.1.3",
     "jest": "^29.3.1",
-    "rimraf": "^3.0.2"
+    "rollup": "^3.10.0",
+    "tslib": "^2.4.1"
+  },
+  "dependencies": {
+    "vitest": "^0.26.3"
   },
-  "gitHead": "6785657a445643ec1c9a17152e3c3733eb0e2a74"
+  "gitHead": "f643f0cd6384905618dbca950bd65a39a77dc028"
 }

package/dist/helpers/index.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAsyncIterable = exports.toAsyncIterable = exports.toArray = exports.iteratorToIterable = exports.asyncIteratorToAsyncIterable = exports.interleave = exports.toDistributableIterable = void 0;
-var distribute_1 = require("./distribute");
-Object.defineProperty(exports, "toDistributableIterable", { enumerable: true, get: function () { return distribute_1.toDistributableIterable; } });
-var interleave_1 = require("./interleave");
-Object.defineProperty(exports, "interleave", { enumerable: true, get: function () { return interleave_1.interleave; } });
-var iteratorToIterable_1 = require("./iteratorToIterable");
-Object.defineProperty(exports, "asyncIteratorToAsyncIterable", { enumerable: true, get: function () { return iteratorToIterable_1.asyncIteratorToAsyncIterable; } });
-Object.defineProperty(exports, "iteratorToIterable", { enumerable: true, get: function () { return iteratorToIterable_1.iteratorToIterable; } });
-var toArray_1 = require("./toArray");
-Object.defineProperty(exports, "toArray", { enumerable: true, get: function () { return toArray_1.toArray; } });
-var toAsyncIterable_1 = require("./toAsyncIterable");
-Object.defineProperty(exports, "toAsyncIterable", { enumerable: true, get: function () { return toAsyncIterable_1.toAsyncIterable; } });
-var util_1 = require("./util");
-Object.defineProperty(exports, "isAsyncIterable", { enumerable: true, get: function () { return util_1.isAsyncIterable; } });
-//# sourceMappingURL=index.js.map

package/dist/helpers/iteratorToIterable.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asyncIteratorToAsyncIterable = exports.iteratorToIterable = void 0;
-function* iteratorToIterable(iterator) {
-    let n;
-    while (!(n = iterator.next()).done) {
-        yield n.value;
-    }
-}
-exports.iteratorToIterable = iteratorToIterable;
-async function* asyncIteratorToAsyncIterable(iterator) {
-    let n;
-    while (!(n = await iterator.next()).done) {
-        yield n.value;
-    }
-}
-exports.asyncIteratorToAsyncIterable = asyncIteratorToAsyncIterable;
-//# sourceMappingURL=iteratorToIterable.js.map