@cspell/cspell-pipe 5.17.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Jason Dent
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+# `@cspell/cspell-pipe`
+
+A library to assist with working with Iterables and AsyncIterables
+
+## Install
+
+```sh
+npm install -S @cspell/cspell-pipe
+```
+
+## Usage
+
+```ts
+import { GitIgnore, findRepoRoot } from 'cspell-gitignore';
+
+// ...
+
+const cwd = process.cwd();
+const root = (await findRepoRoot(cwd)) || cwd;
+const gitIgnore = new GitIgnore([root]);
+
+const allFiles = glob('**');
+
+const files = await gitIgnore.filterOutIgnored(allFiles);
+```
+
+## Logic
+
+- For each file, search for the `.gitignore` files in the directory hierarchy.
+- Ignore any files that match the globs found in the `.gitignore` files.
+
+The `.gitignore` globs are evaluated from highest to lowest, matching the `git` behavior.
+
+To prevent searching higher in the directory hierarchy, specify roots:
+
+```ts
+const gitIgnore = new GitIgnore([process.cwd()]);
+```
+
+# `cspell-gitignore` CLI
+
+`cspell-gitignore` provides a simple cli for debugging .gitignore issues.
+
+In most cases it should provide the same output as `git check-ignore`.
+
+## Usage
+
+```text
+Usage cspell-gitignore [options] <files>
+
+Check files against .gitignore
+Compare against git check-ignore -v -n <files>
+
+Options:
+  -r, --root   Add a root to prevent searching for .gitignore files above the root if the file is under the root.
+               This option can be used multiple times to add multiple roots. The default root is the current
+               repository root determined by the `.git` directory.
+
+Example:
+  cspell-gitignore README.md
+  cspell-gitignore -r . node_modules
+
+```
+
+## Example:
+
+```sh
+$ cspell-gitignore -r . node_modules
+.gitignore:58:node_modules/       node_modules
+```

package/dist/helpers/index.d.ts

@@ -0,0 +1,4 @@
+export { toAsyncIterable } from './toAsyncIterable';
+export { isAsyncIterable } from './util';
+export { toArray } from './toArray';
+//# sourceMappingURL=index.d.ts.map

package/dist/helpers/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toArray = exports.isAsyncIterable = exports.toAsyncIterable = void 0;
+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; } });
+var toArray_1 = require("./toArray");
+Object.defineProperty(exports, "toArray", { enumerable: true, get: function () { return toArray_1.toArray; } });
+//# sourceMappingURL=index.js.map

package/dist/helpers/toArray.d.ts

@@ -0,0 +1,4 @@
+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>[]>;
+//# sourceMappingURL=toArray.d.ts.map

package/dist/helpers/toArray.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toArray = void 0;
+const _1 = require(".");
+function toArray(i) {
+    return (0, _1.isAsyncIterable)(i) ? toArrayAsync(i) : toArraySync(i);
+}
+exports.toArray = toArray;
+function toArraySync(iter) {
+    return [...iter];
+}
+async function toArrayAsync(iter) {
+    const collection = [];
+    for await (const i of iter) {
+        collection.push(i);
+    }
+    return collection;
+}
+//# sourceMappingURL=toArray.js.map

package/dist/helpers/toAsyncIterable.d.ts

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAsyncIterable = exports.mergeAsyncIterables = void 0;
+/**
+ * Merge multiple iterables into an AsyncIterable
+ * @param iter - initial iterable.
+ * @param rest - iterables to merge.
+ */
+async function* mergeAsyncIterables(iter, ...rest) {
+    for await (const i of [iter, ...rest]) {
+        yield* i;
+    }
+}
+exports.mergeAsyncIterables = mergeAsyncIterables;
+/**
+ * Convert one or more iterables to an AsyncIterable
+ */
+exports.toAsyncIterable = mergeAsyncIterables;
+//# sourceMappingURL=toAsyncIterable.js.map

package/dist/helpers/util.d.ts

@@ -0,0 +1,4 @@
+import { AnyIterable, PipeFn, PipeFnAsync, PipeFnSync } from '../internalTypes';
+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/helpers/util.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAsyncIterable = exports.toPipeFn = void 0;
+function toPipeFn(syncFn, asyncFn) {
+    function _(i) {
+        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
+    }
+    return _;
+}
+exports.toPipeFn = toPipeFn;
+function isAsyncIterable(i) {
+    return typeof i[Symbol.asyncIterator] === 'function';
+}
+exports.isAsyncIterable = isAsyncIterable;
+//# sourceMappingURL=util.js.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import * as _helpers from './helpers';
+import * as _operators from './operators';
+export { pipeAsync, pipeSync } from './pipe';
+export declare const operators: typeof _operators;
+export declare const helpers: typeof _helpers;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.helpers = exports.operators = exports.pipeSync = exports.pipeAsync = void 0;
+const _helpers = __importStar(require("./helpers"));
+const _operators = __importStar(require("./operators"));
+var pipe_1 = require("./pipe");
+Object.defineProperty(exports, "pipeAsync", { enumerable: true, get: function () { return pipe_1.pipeAsync; } });
+Object.defineProperty(exports, "pipeSync", { enumerable: true, get: function () { return pipe_1.pipeSync; } });
+exports.operators = _operators;
+exports.helpers = _helpers;
+//# sourceMappingURL=index.js.map

package/dist/internalTypes.d.ts

@@ -0,0 +1,17 @@
+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 declare type PipeFn<T, U> = PipeFnSync<T, U> & PipeFnAsync<T, U>;
+export declare type PsFn<T, U> = PipeFnSync<T, U> | ((i: Iterable<T>) => Iterable<U>);
+export declare type AnyIterable<T> = Iterable<T> | AsyncIterable<T> | Promise<Iterable<T>> | Iterable<Promise<T>>;
+export declare type PaFn<T, U> = PipeFnAsync<T, U> | ((i: AsyncIterable<T>) => AsyncIterable<U>);
+export declare 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 declare 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/internalTypes.js

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

package/dist/operators/await.d.ts

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

package/dist/operators/await.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opAwaitAsync = void 0;
+async function* _asyncAwait(iter) {
+    for await (const v of iter) {
+        yield v;
+    }
+}
+function opAwaitAsync() {
+    return _asyncAwait;
+}
+exports.opAwaitAsync = opAwaitAsync;
+//# sourceMappingURL=await.js.map

package/dist/operators/filter.d.ts

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opFilter = exports.opFilterSync = exports.opFilterAsync = void 0;
+const util_1 = require("../helpers/util");
+function opFilterAsync(filterFn) {
+    async function* fn(iter) {
+        for await (const v of iter) {
+            if (filterFn(v))
+                yield v;
+        }
+    }
+    return fn;
+}
+exports.opFilterAsync = opFilterAsync;
+function opFilterSync(filterFn) {
+    function* fn(iter) {
+        for (const v of iter) {
+            if (filterFn(v))
+                yield v;
+        }
+    }
+    return fn;
+}
+exports.opFilterSync = opFilterSync;
+function opFilter(fn) {
+    const asyncFn = opFilterAsync(fn);
+    const syncFn = opFilterSync(fn);
+    function _(i) {
+        return (0, util_1.isAsyncIterable)(i) ? asyncFn(i) : syncFn(i);
+    }
+    return _;
+}
+exports.opFilter = opFilter;
+//# sourceMappingURL=filter.js.map

package/dist/operators/flatten.d.ts

@@ -0,0 +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>;
+//# sourceMappingURL=flatten.d.ts.map

package/dist/operators/flatten.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opFlatten = exports.opFlattenSync = exports.opFlattenAsync = void 0;
+const util_1 = require("../helpers/util");
+function opFlattenAsync() {
+    async function* fn(iter) {
+        for await (const v of iter) {
+            yield* v;
+        }
+    }
+    return fn;
+}
+exports.opFlattenAsync = opFlattenAsync;
+function opFlattenSync() {
+    function* fn(iter) {
+        for (const v of iter) {
+            yield* v;
+        }
+    }
+    return fn;
+}
+exports.opFlattenSync = opFlattenSync;
+const opFlatten = () => (0, util_1.toPipeFn)(opFlattenSync(), opFlattenAsync());
+exports.opFlatten = opFlatten;
+//# sourceMappingURL=flatten.js.map

package/dist/operators/index.d.ts

@@ -0,0 +1,7 @@
+export { opAwaitAsync } from './await';
+export { opFilter, opFilterAsync, opFilterSync } from './filter';
+export { opFlatten, opFlattenAsync, opFlattenSync } from './flatten';
+export { opJoinStrings, opJoinStringsAsync, opJoinStringsSync } from './joinStrings';
+export { opMap, opMapAsync, opMapSync } from './map';
+export { opUnique, opUniqueAsync, opUniqueSync } from './unique';
+//# sourceMappingURL=index.d.ts.map

package/dist/operators/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opUniqueSync = exports.opUniqueAsync = exports.opUnique = exports.opMapSync = exports.opMapAsync = exports.opMap = exports.opJoinStringsSync = exports.opJoinStringsAsync = exports.opJoinStrings = exports.opFlattenSync = exports.opFlattenAsync = exports.opFlatten = exports.opFilterSync = exports.opFilterAsync = exports.opFilter = exports.opAwaitAsync = void 0;
+var await_1 = require("./await");
+Object.defineProperty(exports, "opAwaitAsync", { enumerable: true, get: function () { return await_1.opAwaitAsync; } });
+var filter_1 = require("./filter");
+Object.defineProperty(exports, "opFilter", { enumerable: true, get: function () { return filter_1.opFilter; } });
+Object.defineProperty(exports, "opFilterAsync", { enumerable: true, get: function () { return filter_1.opFilterAsync; } });
+Object.defineProperty(exports, "opFilterSync", { enumerable: true, get: function () { return filter_1.opFilterSync; } });
+var flatten_1 = require("./flatten");
+Object.defineProperty(exports, "opFlatten", { enumerable: true, get: function () { return flatten_1.opFlatten; } });
+Object.defineProperty(exports, "opFlattenAsync", { enumerable: true, get: function () { return flatten_1.opFlattenAsync; } });
+Object.defineProperty(exports, "opFlattenSync", { enumerable: true, get: function () { return flatten_1.opFlattenSync; } });
+var joinStrings_1 = require("./joinStrings");
+Object.defineProperty(exports, "opJoinStrings", { enumerable: true, get: function () { return joinStrings_1.opJoinStrings; } });
+Object.defineProperty(exports, "opJoinStringsAsync", { enumerable: true, get: function () { return joinStrings_1.opJoinStringsAsync; } });
+Object.defineProperty(exports, "opJoinStringsSync", { enumerable: true, get: function () { return joinStrings_1.opJoinStringsSync; } });
+var map_1 = require("./map");
+Object.defineProperty(exports, "opMap", { enumerable: true, get: function () { return map_1.opMap; } });
+Object.defineProperty(exports, "opMapAsync", { enumerable: true, get: function () { return map_1.opMapAsync; } });
+Object.defineProperty(exports, "opMapSync", { enumerable: true, get: function () { return map_1.opMapSync; } });
+var unique_1 = require("./unique");
+Object.defineProperty(exports, "opUnique", { enumerable: true, get: function () { return unique_1.opUnique; } });
+Object.defineProperty(exports, "opUniqueAsync", { enumerable: true, get: function () { return unique_1.opUniqueAsync; } });
+Object.defineProperty(exports, "opUniqueSync", { enumerable: true, get: function () { return unique_1.opUniqueSync; } });
+//# sourceMappingURL=index.js.map

package/dist/operators/joinStrings.d.ts

@@ -0,0 +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>;
+//# sourceMappingURL=joinStrings.d.ts.map

package/dist/operators/joinStrings.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opJoinStrings = exports.opJoinStringsSync = exports.opJoinStringsAsync = void 0;
+const helpers_1 = require("../helpers");
+const util_1 = require("../helpers/util");
+function opJoinStringsAsync(joinCharacter = ',') {
+    async function* fn(iter) {
+        for await (const v of iter) {
+            const a = await (0, helpers_1.toArray)(v);
+            yield a.join(joinCharacter);
+        }
+    }
+    return fn;
+}
+exports.opJoinStringsAsync = opJoinStringsAsync;
+function opJoinStringsSync(joinCharacter = ',') {
+    function* fn(iter) {
+        for (const v of iter) {
+            const a = (0, helpers_1.toArray)(v);
+            yield a.join(joinCharacter);
+        }
+    }
+    return fn;
+}
+exports.opJoinStringsSync = opJoinStringsSync;
+const opJoinStrings = (joinCharacter = ',') => (0, util_1.toPipeFn)(opJoinStringsSync(joinCharacter), opJoinStringsAsync(joinCharacter));
+exports.opJoinStrings = opJoinStrings;
+//# sourceMappingURL=joinStrings.js.map

package/dist/operators/map.d.ts

@@ -0,0 +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>;
+//# sourceMappingURL=map.d.ts.map

package/dist/operators/map.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opMap = exports.opMapSync = exports.opMapAsync = void 0;
+const util_1 = require("../helpers/util");
+function opMapAsync(mapFn) {
+    async function* fn(iter) {
+        for await (const v of iter) {
+            yield mapFn(v);
+        }
+    }
+    return fn;
+}
+exports.opMapAsync = opMapAsync;
+function opMapSync(mapFn) {
+    function* fn(iter) {
+        for (const v of iter) {
+            yield mapFn(v);
+        }
+    }
+    return fn;
+}
+exports.opMapSync = opMapSync;
+const opMap = (fn) => (0, util_1.toPipeFn)(opMapSync(fn), opMapAsync(fn));
+exports.opMap = opMap;
+//# sourceMappingURL=map.js.map

package/dist/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").PipeFn<T, T>;
+//# sourceMappingURL=unique.d.ts.map

package/dist/operators/unique.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opUnique = exports.opUniqueSync = exports.opUniqueAsync = void 0;
+const util_1 = require("../helpers/util");
+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;
+}
+exports.opUniqueAsync = opUniqueAsync;
+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;
+}
+exports.opUniqueSync = opUniqueSync;
+const opUnique = (getKey) => (0, util_1.toPipeFn)(opUniqueSync(getKey), opUniqueAsync(getKey));
+exports.opUnique = opUnique;
+//# sourceMappingURL=unique.js.map

package/dist/pipe.d.ts

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipeSync = exports.pipeAsync = void 0;
+const helpers_1 = require("./helpers");
+function pipeAsync(i, ...fns) {
+    let iter = (0, helpers_1.toAsyncIterable)(i);
+    for (const fn of fns) {
+        iter = fn(iter);
+    }
+    return iter;
+}
+exports.pipeAsync = pipeAsync;
+function pipeSync(i, ...fns) {
+    let iter = i;
+    for (const fn of fns) {
+        iter = fn(iter);
+    }
+    return iter;
+}
+exports.pipeSync = pipeSync;
+//# sourceMappingURL=pipe.js.map

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@cspell/cspell-pipe",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "5.17.0",
+  "description": "Library to make working with Iterators/AsyncIterators easier.",
+  "keywords": [
+    "cspell",
+    "pipe",
+    "Iterator",
+    "Iterable",
+    "AsyncIterator",
+    "AsyncIterable"
+  ],
+  "author": "Jason Dent <jason@streetsidesoftware.nl>",
+  "homepage": "https://github.com/streetsidesoftware/cspell/tree/master/packages/cspell-pipe#readme",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "directories": {
+    "dist": "dist"
+  },
+  "exports": {
+    ".": "./cspell-ext.json",
+    "./cspell": "./cspell-ext.json",
+    "./cspell-ext.json": "./cspell-ext.json"
+  },
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "!**/__mocks__",
+    "!**/*.test.*",
+    "!**/*.spec.*",
+    "!**/*.map"
+  ],
+  "scripts": {
+    "build": "tsc -p .",
+    "build-dev": "tsc -p tsconfig.dev.json",
+    "watch": "tsc -p . -w",
+    "clean": "rimraf dist coverage .tsbuildinfo",
+    "clean-build": "npm run clean && npm run build",
+    "coverage": "jest --coverage",
+    "test-watch": "jest --watch",
+    "test": "jest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/streetsidesoftware/cspell.git"
+  },
+  "bugs": {
+    "url": "https://github.com/streetsidesoftware/cspell/labels/cspell-gitignore"
+  },
+  "engines": {
+    "node": ">=12.13.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^17.0.12",
+    "jest": "^27.4.7",
+    "rimraf": "^3.0.2"
+  }
+}