@cspell/cspell-pipe 7.0.0-alpha.2 → 7.0.0

package/dist/esm/operators/reduce.mjs

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

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

@@ -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.mts.map

package/dist/esm/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/esm/operators/skip.mjs

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

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

@@ -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.mts.map

package/dist/esm/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/esm/operators/take.mjs

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

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

@@ -1,19 +0,0 @@
-/**
- * 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.mts.map

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

@@ -1,19 +0,0 @@
-/**
- * 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.mjs

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

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

@@ -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.mts.map

package/dist/esm/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/esm/operators/types.mjs

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

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

@@ -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.mts.map

package/dist/esm/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/esm/operators/unique.mjs

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

package/dist/esm/pipe.d.mts

@@ -1,20 +0,0 @@
-import type { AnyIterable, PipeAsyncTx, PipeSyncTx } from './internalTypes.mjs';
-export declare function pipeAsync<T>(i: AnyIterable<T>): AsyncIterable<T>;
-export declare function pipeAsync<T, T0>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0]>): AsyncIterable<T0>;
-export declare function pipeAsync<T, T0, T1>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1]>): AsyncIterable<T1>;
-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.mts.map

package/dist/esm/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/esm/pipe.mjs

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

package/dist/esm/reduce.d.mts

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

package/dist/esm/reduce.d.ts

@@ -1,16 +0,0 @@
-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.mjs

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

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

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

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

@@ -1,6 +0,0 @@
-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.mjs

@@ -1,4 +0,0 @@
-export { toArraySync as toArray } from '../helpers/toArray.mjs';
-export { opAppendSync as opAppend, opCombineSync as opCombine, opConcatMapSync as opConcatMap, opFilterSync as opFilter, opFirstSync as opFirst, opFlattenSync as opFlatten, opJoinStringsSync as opJoinStrings, opLastSync as opLast, opMapSync as opMap, opReduceSync as opReduce, opSkipSync as opSkip, opTakeSync as opTake, opTapSync as opTap, opUniqueSync as opUnique, } from '../operators/index.mjs';
-export { pipeSync as pipe, pipeSync } from '../pipe.mjs';
-export { reduceSync as reduce } from '../reduce.mjs';