@cspell/cspell-pipe 6.26.3 → 6.27.0

package/dist/cjs/operators/{reduce.cjs → reduce.js}

@@ -1,18 +1,7 @@
-'use strict';
-
-function* iteratorToIterable(iterator) {
-    let n;
-    while (!(n = iterator.next()).done) {
-        yield n.value;
-    }
-}
-async function* asyncIteratorToAsyncIterable(iterator) {
-    let n;
-    while (!(n = await iterator.next()).done) {
-        yield n.value;
-    }
-}
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opReduceSync = exports.opReduceAsync = void 0;
+const index_js_1 = require("../helpers/index.js");
 function opReduceAsync(reduceFn, initialValue) {
     async function* reduce(head, tail) {
         for await (const v of tail) {
@@ -28,6 +17,7 @@ function opReduceAsync(reduceFn, initialValue) {
     }
     return fn;
 }
+exports.opReduceAsync = opReduceAsync;
 function opReduceSync(reduceFn, initialValue) {
     function* reduce(head, tail) {
         for (const v of tail) {
@@ -43,23 +33,22 @@ function opReduceSync(reduceFn, initialValue) {
     }
     return fn;
 }
+exports.opReduceSync = opReduceSync;
 function headTail(iter) {
     const iterator = iter[Symbol.iterator]();
     const first = iterator.next();
     if (first.done)
         return undefined;
-    return { head: first.value, tail: iteratorToIterable(iterator) };
+    return { head: first.value, tail: (0, index_js_1.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) };
+    return { head: first.value, tail: (0, index_js_1.asyncIteratorToAsyncIterable)(iterator) };
 }
 function isIterable(i) {
     return typeof i[Symbol.iterator] === 'function';
 }
-
-exports.opReduceAsync = opReduceAsync;
-exports.opReduceSync = opReduceSync;
+//# sourceMappingURL=reduce.js.map

package/dist/cjs/operators/{skip.cjs → skip.js}

@@ -1,15 +1,7 @@
-'use strict';
-
-function toPipeFn(syncFn, asyncFn) {
-    function _(i) {
-        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
-    }
-    return _;
-}
-function isAsyncIterable(i) {
-    return typeof i[Symbol.asyncIterator] === 'function';
-}
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opSkip = exports.opSkipSync = exports.opSkipAsync = void 0;
+const util_js_1 = require("../helpers/util.js");
 function opSkipAsync(count) {
     async function* fn(iter) {
         for await (const v of iter) {
@@ -22,6 +14,7 @@ function opSkipAsync(count) {
     }
     return fn;
 }
+exports.opSkipAsync = opSkipAsync;
 function opSkipSync(count) {
     function* fn(iter) {
         for (const v of iter) {
@@ -34,8 +27,7 @@ function opSkipSync(count) {
     }
     return fn;
 }
-const opSkip = (count) => toPipeFn(opSkipSync(count), opSkipAsync(count));
-
-exports.opSkip = opSkip;
-exports.opSkipAsync = opSkipAsync;
 exports.opSkipSync = opSkipSync;
+const opSkip = (count) => (0, util_js_1.toPipeFn)(opSkipSync(count), opSkipAsync(count));
+exports.opSkip = opSkip;
+//# sourceMappingURL=skip.js.map

package/dist/cjs/operators/{take.cjs → take.js}

@@ -1,15 +1,7 @@
-'use strict';
-
-function toPipeFn(syncFn, asyncFn) {
-    function _(i) {
-        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
-    }
-    return _;
-}
-function isAsyncIterable(i) {
-    return typeof i[Symbol.asyncIterator] === 'function';
-}
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opTake = exports.opTakeSync = exports.opTakeAsync = void 0;
+const util_js_1 = require("../helpers/util.js");
 function opTakeAsync(count) {
     async function* fn(iter) {
         if (count <= 0)
@@ -22,6 +14,7 @@ function opTakeAsync(count) {
     }
     return fn;
 }
+exports.opTakeAsync = opTakeAsync;
 function opTakeSync(count) {
     function* fn(iter) {
         if (count <= 0)
@@ -34,12 +27,11 @@ function opTakeSync(count) {
     }
     return fn;
 }
+exports.opTakeSync = opTakeSync;
 /**
  * Consume only the first `count` number from the iterable.
  * @param count - number to take
  */
-const opTake = (count) => toPipeFn(opTakeSync(count), opTakeAsync(count));
-
+const opTake = (count) => (0, util_js_1.toPipeFn)(opTakeSync(count), opTakeAsync(count));
 exports.opTake = opTake;
-exports.opTakeAsync = opTakeAsync;
-exports.opTakeSync = opTakeSync;
+//# sourceMappingURL=take.js.map

package/dist/cjs/operators/{tap.cjs → tap.js}

@@ -1,15 +1,7 @@
-'use strict';
-
-function toPipeFn(syncFn, asyncFn) {
-    function _(i) {
-        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
-    }
-    return _;
-}
-function isAsyncIterable(i) {
-    return typeof i[Symbol.asyncIterator] === 'function';
-}
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opTap = exports.opTapSync = exports.opTapAsync = void 0;
+const util_js_1 = require("../helpers/util.js");
 /**
  * Tap allows you to listen on values, without modifying them.
  *
@@ -24,6 +16,7 @@ function opTapAsync(tapFn) {
     }
     return fn;
 }
+exports.opTapAsync = opTapAsync;
 /**
  * Tap allows you to listen on values, without modifying them.
  *
@@ -38,13 +31,12 @@ function opTapSync(tapFn) {
     }
     return fn;
 }
+exports.opTapSync = opTapSync;
 /**
  * Tap allows you to listen on values, without modifying them.
  *
  * @param fn - function to call for each value.
  */
-const opTap = (fn) => toPipeFn(opTapSync(fn), opTapAsync(fn));
-
+const opTap = (fn) => (0, util_js_1.toPipeFn)(opTapSync(fn), opTapAsync(fn));
 exports.opTap = opTap;
-exports.opTapAsync = opTapAsync;
-exports.opTapSync = opTapSync;
+//# sourceMappingURL=tap.js.map

package/dist/cjs/operators/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/cjs/operators/{unique.cjs → unique.js}

@@ -1,15 +1,7 @@
-'use strict';
-
-function toPipeFn(syncFn, asyncFn) {
-    function _(i) {
-        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
-    }
-    return _;
-}
-function isAsyncIterable(i) {
-    return typeof i[Symbol.asyncIterator] === 'function';
-}
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opUnique = exports.opUniqueSync = exports.opUniqueAsync = void 0;
+const util_js_1 = require("../helpers/util.js");
 function opUniqueAsync(k) {
     function fnK(k) {
         async function* fn(iter) {
@@ -35,6 +27,7 @@ function opUniqueAsync(k) {
     }
     return k ? fnK(k) : fn;
 }
+exports.opUniqueAsync = opUniqueAsync;
 function opUniqueSync(k) {
     function fnK(key) {
         function* fn(iter) {
@@ -60,8 +53,7 @@ function opUniqueSync(k) {
     }
     return k ? fnK(k) : fn;
 }
-const opUnique = (getKey) => toPipeFn(opUniqueSync(getKey), opUniqueAsync(getKey));
-
-exports.opUnique = opUnique;
-exports.opUniqueAsync = opUniqueAsync;
 exports.opUniqueSync = opUniqueSync;
+const opUnique = (getKey) => (0, util_js_1.toPipeFn)(opUniqueSync(getKey), opUniqueAsync(getKey));
+exports.opUnique = opUnique;
+//# sourceMappingURL=unique.js.map

package/dist/cjs/pipe.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipeSync = exports.pipeAsync = void 0;
+const index_js_1 = require("./helpers/index.js");
+const index_js_2 = require("./operators/index.js");
+function pipeAsync(i, ...fns) {
+    const iter = (0, index_js_1.toAsyncIterable)(i);
+    return (0, index_js_2.opCombineAsync)(...fns)(iter);
+}
+exports.pipeAsync = pipeAsync;
+function pipeSync(i, ...fns) {
+    return (0, index_js_2.opCombineSync)(...fns)(i);
+}
+exports.pipeSync = pipeSync;
+//# sourceMappingURL=pipe.js.map

package/dist/cjs/reduce.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduce = exports.reduceAsync = exports.reduceSync = void 0;
+const index_js_1 = require("./helpers/index.js");
+const toArray_js_1 = require("./helpers/toArray.js");
+const index_js_2 = require("./operators/index.js");
+const pipe_js_1 = require("./pipe.js");
+function reduceSync(iter, reduceFn, initialValue) {
+    const i = initialValue === undefined
+        ? (0, pipe_js_1.pipeSync)(iter, (0, index_js_2.opReduceSync)(reduceFn))
+        : (0, pipe_js_1.pipeSync)(iter, (0, index_js_2.opReduceSync)(reduceFn, initialValue));
+    return [...i][0];
+}
+exports.reduceSync = reduceSync;
+async function reduceAsync(iter, reduceFn, initialValue) {
+    const i = initialValue === undefined
+        ? (0, pipe_js_1.pipeAsync)(iter, (0, index_js_2.opReduceAsync)(reduceFn))
+        : (0, pipe_js_1.pipeAsync)(iter, (0, index_js_2.opReduceAsync)(reduceFn, initialValue));
+    const arr = await (0, toArray_js_1.toArrayAsync)(i);
+    return arr[0];
+}
+exports.reduceAsync = reduceAsync;
+function reduce(iter, reduceFn, initialValue) {
+    return (0, index_js_1.isAsyncIterable)(iter) ? reduceAsync(iter, reduceFn, initialValue) : reduceSync(iter, reduceFn, initialValue);
+}
+exports.reduce = reduce;
+//# sourceMappingURL=reduce.js.map

package/dist/cjs/sync/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduce = exports.pipeSync = exports.pipe = exports.opUnique = exports.opTap = exports.opTake = exports.opSkip = exports.opReduce = exports.opMap = exports.opLast = exports.opJoinStrings = exports.opFlatten = exports.opFirst = exports.opFilter = exports.opConcatMap = exports.opCombine = exports.opAppend = exports.toArray = void 0;
+var toArray_js_1 = require("../helpers/toArray.js");
+Object.defineProperty(exports, "toArray", { enumerable: true, get: function () { return toArray_js_1.toArraySync; } });
+var index_js_1 = require("../operators/index.js");
+Object.defineProperty(exports, "opAppend", { enumerable: true, get: function () { return index_js_1.opAppendSync; } });
+Object.defineProperty(exports, "opCombine", { enumerable: true, get: function () { return index_js_1.opCombineSync; } });
+Object.defineProperty(exports, "opConcatMap", { enumerable: true, get: function () { return index_js_1.opConcatMapSync; } });
+Object.defineProperty(exports, "opFilter", { enumerable: true, get: function () { return index_js_1.opFilterSync; } });
+Object.defineProperty(exports, "opFirst", { enumerable: true, get: function () { return index_js_1.opFirstSync; } });
+Object.defineProperty(exports, "opFlatten", { enumerable: true, get: function () { return index_js_1.opFlattenSync; } });
+Object.defineProperty(exports, "opJoinStrings", { enumerable: true, get: function () { return index_js_1.opJoinStringsSync; } });
+Object.defineProperty(exports, "opLast", { enumerable: true, get: function () { return index_js_1.opLastSync; } });
+Object.defineProperty(exports, "opMap", { enumerable: true, get: function () { return index_js_1.opMapSync; } });
+Object.defineProperty(exports, "opReduce", { enumerable: true, get: function () { return index_js_1.opReduceSync; } });
+Object.defineProperty(exports, "opSkip", { enumerable: true, get: function () { return index_js_1.opSkipSync; } });
+Object.defineProperty(exports, "opTake", { enumerable: true, get: function () { return index_js_1.opTakeSync; } });
+Object.defineProperty(exports, "opTap", { enumerable: true, get: function () { return index_js_1.opTapSync; } });
+Object.defineProperty(exports, "opUnique", { enumerable: true, get: function () { return index_js_1.opUniqueSync; } });
+var pipe_js_1 = require("../pipe.js");
+Object.defineProperty(exports, "pipe", { enumerable: true, get: function () { return pipe_js_1.pipeSync; } });
+Object.defineProperty(exports, "pipeSync", { enumerable: true, get: function () { return pipe_js_1.pipeSync; } });
+var reduce_js_1 = require("../reduce.js");
+Object.defineProperty(exports, "reduce", { enumerable: true, get: function () { return reduce_js_1.reduceSync; } });
+//# sourceMappingURL=index.js.map

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

@@ -10,4 +10,4 @@ export declare function toDistributableIterableSync<T>(iterable: Iterable<T>): I
  * @param iterable - the iterable to share
  */
 export declare const toDistributableIterable: typeof toDistributableIterableSync;
-//# sourceMappingURL=distribute.d.ts.map
+//# sourceMappingURL=distribute.d.mts.map

package/dist/esm/helpers/distribute.mjs

@@ -0,0 +1,33 @@
+/**
+ * Allows an iterable to be shared by multiple consumers.
+ * Each consumer takes from the iterable.
+ * @param iterable - the iterable to share
+ */
+export function toDistributableIterableSync(iterable) {
+    let lastValue;
+    let iter;
+    function getNext() {
+        if (lastValue && lastValue.done) {
+            return { ...lastValue };
+        }
+        iter = iter || iterable[Symbol.iterator]();
+        lastValue = iter.next();
+        return lastValue;
+    }
+    function* iterableFn() {
+        let next;
+        while (!(next = getNext()).done) {
+            yield next.value;
+        }
+    }
+    return {
+        [Symbol.iterator]: iterableFn,
+    };
+}
+/**
+ * Allows an iterable to be shared by multiple consumers.
+ * Each consumer takes from the iterable.
+ * @param iterable - the iterable to share
+ */
+export const toDistributableIterable = toDistributableIterableSync;
+//# sourceMappingURL=distribute.mjs.map

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

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

package/dist/esm/helpers/index.mjs

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

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

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

package/dist/esm/helpers/interleave.mjs

@@ -0,0 +1,18 @@
+export function* interleave(a, b) {
+    const ai = a[Symbol.iterator]();
+    const bi = b[Symbol.iterator]();
+    for (let aNext = ai.next(); !aNext.done; aNext = ai.next()) {
+        yield aNext.value;
+        const bNext = bi.next();
+        if (bNext.done)
+            break;
+        yield bNext.value;
+    }
+    for (let aNext = ai.next(); !aNext.done; aNext = ai.next()) {
+        yield aNext.value;
+    }
+    for (let bNext = bi.next(); !bNext.done; bNext = bi.next()) {
+        yield bNext.value;
+    }
+}
+//# sourceMappingURL=interleave.mjs.map

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

@@ -1,3 +1,3 @@
 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
+//# sourceMappingURL=iteratorToIterable.d.mts.map

package/dist/esm/helpers/iteratorToIterable.mjs

@@ -0,0 +1,13 @@
+export function* iteratorToIterable(iterator) {
+    let n;
+    while (!(n = iterator.next()).done) {
+        yield n.value;
+    }
+}
+export async function* asyncIteratorToAsyncIterable(iterator) {
+    let n;
+    while (!(n = await iterator.next()).done) {
+        yield n.value;
+    }
+}
+//# sourceMappingURL=iteratorToIterable.mjs.map

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

@@ -3,4 +3,4 @@ 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
+//# sourceMappingURL=toArray.d.mts.map

package/dist/esm/helpers/toArray.mjs

@@ -0,0 +1,15 @@
+import { isAsyncIterable } from './util.mjs';
+export function toArray(i) {
+    return isAsyncIterable(i) ? toArrayAsync(i) : toArraySync(i);
+}
+export function toArraySync(iter) {
+    return [...iter];
+}
+export async function toArrayAsync(iter) {
+    const collection = [];
+    for await (const i of iter) {
+        collection.push(i);
+    }
+    return collection;
+}
+//# sourceMappingURL=toArray.mjs.map

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

@@ -1,4 +1,4 @@
-import type { AnyIterable } from '../internalTypes.js';
+import type { AnyIterable } from '../internalTypes.mjs';
 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>;
@@ -8,4 +8,4 @@ export declare function mergeAsyncIterables<T>(iter: AnyIterable<T>, ...rest: An
  * Convert one or more iterables to an AsyncIterable
  */
 export declare const toAsyncIterable: typeof mergeAsyncIterables;
-//# sourceMappingURL=toAsyncIterable.d.ts.map
+//# sourceMappingURL=toAsyncIterable.d.mts.map

package/dist/esm/helpers/toAsyncIterable.mjs

@@ -0,0 +1,15 @@
+/**
+ * Merge multiple iterables into an AsyncIterable
+ * @param iter - initial iterable.
+ * @param rest - iterables to merge.
+ */
+export async function* mergeAsyncIterables(iter, ...rest) {
+    for await (const i of [iter, ...rest]) {
+        yield* i;
+    }
+}
+/**
+ * Convert one or more iterables to an AsyncIterable
+ */
+export const toAsyncIterable = mergeAsyncIterables;
+//# sourceMappingURL=toAsyncIterable.mjs.map

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

@@ -1,4 +1,4 @@
-import type { AnyIterable, PipeFn, PipeFnAsync, PipeFnSync } from '../internalTypes.js';
+import type { AnyIterable, PipeFn, PipeFnAsync, PipeFnSync } from '../internalTypes.mjs';
 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
+//# sourceMappingURL=util.d.mts.map

package/dist/esm/helpers/util.mjs

@@ -0,0 +1,10 @@
+export function toPipeFn(syncFn, asyncFn) {
+    function _(i) {
+        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
+    }
+    return _;
+}
+export function isAsyncIterable(i) {
+    return typeof i[Symbol.asyncIterator] === 'function';
+}
+//# sourceMappingURL=util.mjs.map

package/dist/esm/index.d.mts

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

package/dist/esm/index.mjs

@@ -0,0 +1,11 @@
+import * as _helpers from './helpers/index.mjs';
+import * as _operators from './operators/index.mjs';
+export { interleave, isAsyncIterable, toArray, toAsyncIterable, toDistributableIterable } from './helpers/index.mjs';
+export { opAppend, opAwaitAsync, opConcatMap, opFilter, opFirst, opFlatten, opJoinStrings, opLast, opMap, opSkip, opTake, opTap, opUnique, } from './operators/index.mjs';
+export { pipeAsync, pipeSync } from './pipe.mjs';
+export { reduce, reduceAsync, reduceSync } from './reduce.mjs';
+// eslint-disable-next-line unicorn/prefer-export-from
+export const operators = _operators;
+// eslint-disable-next-line unicorn/prefer-export-from
+export const helpers = _helpers;
+//# sourceMappingURL=index.mjs.map

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

@@ -14,4 +14,4 @@ export type AnyIterable<T> = Iterable<T> | AsyncIterable<T> | Promise<Iterable<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
+//# sourceMappingURL=internalTypes.d.mts.map

package/dist/esm/internalTypes.mjs

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

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

@@ -1,4 +1,4 @@
-import type { PipeFn } from '../internalTypes.js';
+import type { PipeFn } from '../internalTypes.mjs';
 /**
  * Append values onto the end of an iterable.
  * @param iterablesToAppend - the iterables in the order to be appended.
@@ -12,4 +12,4 @@ export declare function opAppendAsync<T>(...iterablesToAppend: (AsyncIterable<T>
  */
 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
+//# sourceMappingURL=append.d.mts.map

package/dist/esm/operators/append.mjs

@@ -0,0 +1,36 @@
+import { isAsyncIterable } from '../helpers/index.mjs';
+/**
+ * Append values onto the end of an iterable.
+ * @param iterablesToAppend - the iterables in the order to be appended.
+ * @returns
+ */
+export function opAppendAsync(...iterablesToAppend) {
+    async function* fn(iter) {
+        yield* iter;
+        for (const i of iterablesToAppend) {
+            yield* i;
+        }
+    }
+    return fn;
+}
+/**
+ * Append values onto the end of an iterable.
+ * @param iterablesToAppend - the iterables in the order to be appended.
+ * @returns
+ */
+export function opAppendSync(...iterablesToAppend) {
+    function* fn(iter) {
+        yield* iter;
+        for (const i of iterablesToAppend) {
+            yield* i;
+        }
+    }
+    return fn;
+}
+export function opAppend(...iterablesToAppend) {
+    function _(i) {
+        return isAsyncIterable(i) ? opAppendAsync(...iterablesToAppend)(i) : opAppendSync(...iterablesToAppend)(i);
+    }
+    return _;
+}
+//# sourceMappingURL=append.mjs.map

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

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

package/dist/{cjs/operators/await.cjs → esm/operators/await.mjs}

@@ -1,12 +1,9 @@
-'use strict';
-
 async function* _asyncAwait(iter) {
     for await (const v of iter) {
         yield v;
     }
 }
-function opAwaitAsync() {
+export function opAwaitAsync() {
     return _asyncAwait;
 }
-
-exports.opAwaitAsync = opAwaitAsync;
+//# sourceMappingURL=await.mjs.map

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

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

package/dist/esm/operators/combine.mjs

@@ -0,0 +1,19 @@
+export function opCombineAsync(...fns) {
+    function combine(iter) {
+        for (const fn of fns) {
+            iter = fn(iter);
+        }
+        return iter;
+    }
+    return combine;
+}
+export function opCombineSync(...fns) {
+    function combine(iter) {
+        for (const fn of fns) {
+            iter = fn(iter);
+        }
+        return iter;
+    }
+    return combine;
+}
+//# sourceMappingURL=combine.mjs.map

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

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