spliterator 6.1.0 → 6.2.0

package/out/lib/iterators/chunks.js

@@ -0,0 +1,36 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ */
+/**
+ * Group an iterable's values into arrays of `size`, with a shorter final batch if the collection does not divide
+ * evenly.
+ *
+ * Distinct from `Iterator.prototype.take`, which yields the first `size` _values_. Named for the [iterator chunking
+ * proposal](https://github.com/tc39/proposal-iterator-chunking).
+ *
+ * @param collection The collection to batch.
+ * @param size The size of each batch.
+ *
+ * @yields Each batch of values.
+ * @see {@linkcode AsyncSequence.chunks} for the asynchronous form.
+ */
+export function* chunks(collection, size) {
+    const normalized = Math.trunc(size);
+    if (!Number.isFinite(normalized) || normalized < 1) {
+        throw new RangeError(`chunks(${size}): size must be a positive finite number`);
+    }
+    let batch = [];
+    for (const item of collection) {
+        batch.push(item);
+        if (batch.length === normalized) {
+            yield batch;
+            batch = [];
+        }
+    }
+    if (batch.length) {
+        yield batch;
+    }
+}
+//# sourceMappingURL=chunks.js.map

package/out/lib/iterators/chunks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunks.js","sourceRoot":"","sources":["../../../lib/iterators/chunks.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,SAAS,CAAC,CAAC,MAAM,CAAI,UAAuB,EAAE,IAAY;IAC/D,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IAEnC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,UAAU,GAAG,CAAC,EAAE,CAAC;QACpD,MAAM,IAAI,UAAU,CAAC,UAAU,IAAI,0CAA0C,CAAC,CAAA;IAC/E,CAAC;IAED,IAAI,KAAK,GAAQ,EAAE,CAAA;IAEnB,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QAC/B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAEhB,IAAI,KAAK,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YACjC,MAAM,KAAK,CAAA;YAEX,KAAK,GAAG,EAAE,CAAA;QACX,CAAC;IACF,CAAC;IAED,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QAClB,MAAM,KAAK,CAAA;IACZ,CAAC;AACF,CAAC"}

package/out/lib/iterators/pivot.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ */
+/**
+ * Given an iterable of values, maps each value to a record of the value and the result of the callback.
+ *
+ * This is a convenience function when an iterable needs mapping to an object-like structure.
+ *
+ * ```ts
+ * const iterable = ["a", "b", "c"]
+ * const result = pivot(iterable, (value) => value.toUpperCase())
+ *
+ * // { a: "A", b: "B", c: "C" }
+ * ```
+ *
+ * @category Collections
+ * @category Object
+ */
+export declare function pivot<T extends PropertyKey, C extends (value: T) => Promise<unknown> | unknown>(
+/**
+ * The iterable to pivot.
+ */
+iterable: Iterable<T>, 
+/**
+ * The callback to transform each value.
+ */
+callback: C): ReturnType<C> extends PromiseLike<infer U> ? Promise<Record<T, U>> : Record<T, ReturnType<C>>;
+//# sourceMappingURL=pivot.d.ts.map

package/out/lib/iterators/pivot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pivot.d.ts","sourceRoot":"","sources":["../../../lib/iterators/pivot.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO;AAC9F;;GAEG;AACH,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;AACrB;;GAEG;AACH,QAAQ,EAAE,CAAC,GACT,UAAU,CAAC,CAAC,CAAC,SAAS,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CA6B/F"}

package/out/lib/iterators/pivot.js

@@ -0,0 +1,47 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ */
+/**
+ * Given an iterable of values, maps each value to a record of the value and the result of the callback.
+ *
+ * This is a convenience function when an iterable needs mapping to an object-like structure.
+ *
+ * ```ts
+ * const iterable = ["a", "b", "c"]
+ * const result = pivot(iterable, (value) => value.toUpperCase())
+ *
+ * // { a: "A", b: "B", c: "C" }
+ * ```
+ *
+ * @category Collections
+ * @category Object
+ */
+export function pivot(
+/**
+ * The iterable to pivot.
+ */
+iterable, 
+/**
+ * The callback to transform each value.
+ */
+callback) {
+    const entries = [];
+    let foundThenable = false;
+    for (const value of iterable) {
+        const result = callback(value);
+        if (result && typeof result === "object" && "then" in result) {
+            foundThenable = true;
+        }
+        entries.push([value, result]);
+    }
+    if (foundThenable) {
+        return Promise.all(entries.map(([key, value]) => {
+            return Promise.resolve(value).then((resolvedValue) => [key, resolvedValue]);
+        })).then(Object.fromEntries);
+    }
+    const pivotedRecord = Object.fromEntries(entries);
+    return pivotedRecord;
+}
+//# sourceMappingURL=pivot.js.map

package/out/lib/iterators/pivot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pivot.js","sourceRoot":"","sources":["../../../lib/iterators/pivot.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,KAAK;AACpB;;GAEG;AACH,QAAqB;AACrB;;GAEG;AACH,QAAW;IAEX,MAAM,OAAO,GAA8B,EAAE,CAAA;IAC7C,IAAI,aAAa,GAAG,KAAK,CAAA;IAEzB,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QAC9B,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;QAE9B,IAAI,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,IAAI,MAAM,EAAE,CAAC;YAC9D,aAAa,GAAG,IAAI,CAAA;QACrB,CAAC;QAED,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,MAAuB,CAAC,CAAC,CAAA;IAC/C,CAAC;IAED,IAAI,aAAa,EAAE,CAAC;QACnB,OAAO,OAAO,CAAC,GAAG,CACjB,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;YAC5B,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,aAAa,CAAU,CAAC,CAAA;QACrF,CAAC,CAAC,CACF,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAEE,CAAA;IAC5B,CAAC;IAED,MAAM,aAAa,GAAG,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAA;IAEjD,OAAO,aAEoB,CAAA;AAC5B,CAAC"}

package/out/lib/iterators/zip.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ */
+export type Zipped<T, U> = [a: T | undefined, b: U | undefined, idx: number];
+export type ZippedEntries<Z> = Z extends Zipped<infer T, infer U> ? [T, U] : never;
+export declare function zippedEntries<T, U>(zipped: Zipped<T, U>): ZippedEntries<Zipped<T, U>>;
+/**
+ * Given two iterables, zip them together into a single iterable which yields pairs of elements.
+ *
+ * If one iterable is longer than the other, the shorter iterable will be padded with `undefined`.
+ *
+ * @param a The first iterable to zip.
+ * @param b The second iterable to zip.
+ *
+ * @yields Pairs of elements from the two iterables.
+ * @see {@linkcode zipAsync} for the asynchronous version.
+ */
+export declare function zipSync<T, U>(a: Iterable<T>, b: Iterable<U>): Generator<Zipped<T, U>>;
+/**
+ * Given two iterables, zip them together into a single iterable which yields pairs of elements.
+ *
+ * If one iterable is longer than the other, the shorter iterable will be padded with `undefined`.
+ *
+ * @param a The first iterable to zip.
+ * @param b The second iterable to zip.
+ *
+ * @yields Pairs of elements from the two iterables.
+ * @see {@linkcode zipSync} for the synchronous version.
+ */
+export declare function zipAsync<T, U>(a: AsyncIterable<T> | Iterable<T>, b: AsyncIterable<U> | Iterable<U>): AsyncGenerator<[a: T | undefined, b: U | undefined, idx: number]>;
+//# sourceMappingURL=zip.d.ts.map

package/out/lib/iterators/zip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip.d.ts","sourceRoot":"","sources":["../../../lib/iterators/zip.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,CAAC,CAAA;AAE5E,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAA;AAElF,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAErF;AAED;;;;;;;;;;GAUG;AACH,wBAAiB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAkBtF;AAED;;;;;;;;;;GAUG;AACH,wBAAuB,QAAQ,CAAC,CAAC,EAAE,CAAC,EACnC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,EACjC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAC/B,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,CAkBnE"}

package/out/lib/iterators/zip.js

@@ -0,0 +1,59 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ */
+export function zippedEntries(zipped) {
+    return zipped.slice(0, 2);
+}
+/**
+ * Given two iterables, zip them together into a single iterable which yields pairs of elements.
+ *
+ * If one iterable is longer than the other, the shorter iterable will be padded with `undefined`.
+ *
+ * @param a The first iterable to zip.
+ * @param b The second iterable to zip.
+ *
+ * @yields Pairs of elements from the two iterables.
+ * @see {@linkcode zipAsync} for the asynchronous version.
+ */
+export function* zipSync(a, b) {
+    const aIterator = a[Symbol.iterator]();
+    const bIterator = b[Symbol.iterator]();
+    let index = 0;
+    while (true) {
+        const { done: aDone, value: aValue } = aIterator.next();
+        const { done: bDone, value: bValue } = bIterator.next();
+        if (aDone && bDone) {
+            break;
+        }
+        yield [aValue, bValue, index];
+        index++;
+    }
+}
+/**
+ * Given two iterables, zip them together into a single iterable which yields pairs of elements.
+ *
+ * If one iterable is longer than the other, the shorter iterable will be padded with `undefined`.
+ *
+ * @param a The first iterable to zip.
+ * @param b The second iterable to zip.
+ *
+ * @yields Pairs of elements from the two iterables.
+ * @see {@linkcode zipSync} for the synchronous version.
+ */
+export async function* zipAsync(a, b) {
+    const aIterator = Symbol.asyncIterator in a ? a[Symbol.asyncIterator]() : a[Symbol.iterator]();
+    const bIterator = Symbol.asyncIterator in b ? b[Symbol.asyncIterator]() : b[Symbol.iterator]();
+    let index = 0;
+    while (true) {
+        const { done: aDone, value: aValue } = await aIterator.next();
+        const { done: bDone, value: bValue } = await bIterator.next();
+        if (aDone && bDone) {
+            break;
+        }
+        yield [aValue, bValue, index];
+        index++;
+    }
+}
+//# sourceMappingURL=zip.js.map

package/out/lib/iterators/zip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip.js","sourceRoot":"","sources":["../../../lib/iterators/zip.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,MAAM,UAAU,aAAa,CAAO,MAAoB;IACvD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAgC,CAAA;AACzD,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,SAAS,CAAC,CAAC,OAAO,CAAO,CAAc,EAAE,CAAc;IAC5D,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAA;IACtC,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAA;IAEtC,IAAI,KAAK,GAAG,CAAC,CAAA;IAEb,OAAO,IAAI,EAAE,CAAC;QACb,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC,IAAI,EAAE,CAAA;QACvD,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC,IAAI,EAAE,CAAA;QAEvD,IAAI,KAAK,IAAI,KAAK,EAAE,CAAC;YACpB,MAAK;QACN,CAAC;QAED,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAA;QAE7B,KAAK,EAAE,CAAA;IACR,CAAC;AACF,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,QAAQ,CAC9B,CAAiC,EACjC,CAAiC;IAEjC,MAAM,SAAS,GAAG,MAAM,CAAC,aAAa,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAA;IAC9F,MAAM,SAAS,GAAG,MAAM,CAAC,aAAa,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAA;IAE9F,IAAI,KAAK,GAAG,CAAC,CAAA;IAEb,OAAO,IAAI,EAAE,CAAC;QACb,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,SAAS,CAAC,IAAI,EAAE,CAAA;QAC7D,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,SAAS,CAAC,IAAI,EAAE,CAAA;QAE7D,IAAI,KAAK,IAAI,KAAK,EAAE,CAAC;YACpB,MAAK;QACN,CAAC;QAED,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAA;QAE7B,KAAK,EAAE,CAAA;IACR,CAAC;AACF,CAAC"}

package/out/lib/parallel/merge-async-iterators.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ */
+/**
+ * Merge several async iterables, pulling from **all of them concurrently** and yielding each value as soon as it
+ * arrives (completion order, not source order). An error from any source rejects; remaining sources are returned
+ * (cancelled) on completion, error, or early break.
+ */
+export declare function mergeAsyncIterators<R>(sources: Array<AsyncIterable<R>>): AsyncIterableIterator<R>;
+//# sourceMappingURL=merge-async-iterators.d.ts.map

package/out/lib/parallel/merge-async-iterators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-async-iterators.d.ts","sourceRoot":"","sources":["../../../lib/parallel/merge-async-iterators.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AACH,wBAAuB,mBAAmB,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GAAG,qBAAqB,CAAC,CAAC,CAAC,CA6BxG"}

package/out/lib/parallel/merge-async-iterators.js

@@ -0,0 +1,39 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ */
+/**
+ * Merge several async iterables, pulling from **all of them concurrently** and yielding each value as soon as it
+ * arrives (completion order, not source order). An error from any source rejects; remaining sources are returned
+ * (cancelled) on completion, error, or early break.
+ */
+export async function* mergeAsyncIterators(sources) {
+    const advance = (it) => it.next().then((result) => ({ it, result }));
+    const pending = new Map();
+    for (const source of sources) {
+        const it = source[Symbol.asyncIterator]();
+        pending.set(it, advance(it));
+    }
+    try {
+        while (pending.size) {
+            const { it, result } = await Promise.race(pending.values());
+            if (result.done) {
+                pending.delete(it);
+            }
+            else {
+                yield result.value;
+                pending.set(it, advance(it));
+            }
+        }
+    }
+    finally {
+        // Stop any iterators we didn't drain (early break / error). Swallow rejections from their
+        // in-flight `next()` so they don't surface as unhandled.
+        for (const promise of pending.values()) {
+            void promise.catch(() => { });
+        }
+        await Promise.allSettled(Array.from(pending.keys(), (it) => it.return?.()));
+    }
+}
+//# sourceMappingURL=merge-async-iterators.js.map

package/out/lib/parallel/merge-async-iterators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-async-iterators.js","sourceRoot":"","sources":["../../../lib/parallel/merge-async-iterators.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,mBAAmB,CAAI,OAAgC;IAC7E,MAAM,OAAO,GAAG,CAAC,EAAoB,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,CAAA;IACtF,MAAM,OAAO,GAAG,IAAI,GAAG,EAAkF,CAAA;IAEzG,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC9B,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAA;QACzC,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CAAA;IAC7B,CAAC;IAED,IAAI,CAAC;QACJ,OAAO,OAAO,CAAC,IAAI,EAAE,CAAC;YACrB,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;YAE3D,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;gBACjB,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;YACnB,CAAC;iBAAM,CAAC;gBACP,MAAM,MAAM,CAAC,KAAK,CAAA;gBAClB,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CAAA;YAC7B,CAAC;QACF,CAAC;IACF,CAAC;YAAS,CAAC;QACV,0FAA0F;QAC1F,yDAAyD;QACzD,KAAK,MAAM,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;YACxC,KAAK,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAA;QAC7B,CAAC;QAED,MAAM,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAA;IAC5E,CAAC;AACF,CAAC"}

package/out/lib/parallel/parallel-map-runtime.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ *
+ * Transport-agnostic core of `parallelMap` — a record-dispatch worker pool. `runPool` keeps every
+ * worker busy mapping batches pulled from one shared source, with no `worker_threads` dependency so it
+ * unit-tests against fake workers.
+ */
+/**
+ * One pool slot. `process` ships a batch to its worker and resolves with that batch's results.
+ */
+export interface PoolWorker<T, R> {
+    process(batch: T[]): Promise<R[]>;
+}
+/**
+ * Drive a pool of `workers` over `source`: each worker loops — pull a batch, map it, emit results — until the source is
+ * exhausted. Results stream out in completion order (a worker's whole batch yields before it pulls the next, which
+ * bounds in-flight work to the pool size). A worker error propagates and tears the pool down.
+ */
+export declare function runPool<T, R>(workers: Array<PoolWorker<T, R>>, source: AsyncIterable<T> | Iterable<T>, batchSize: number): AsyncIterableIterator<R>;
+//# sourceMappingURL=parallel-map-runtime.d.ts.map

package/out/lib/parallel/parallel-map-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel-map-runtime.d.ts","sourceRoot":"","sources":["../../../lib/parallel/parallel-map-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,EAAE,CAAC;IAC/B,OAAO,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAAA;CACjC;AA+CD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC3B,OAAO,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAChC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,EACtC,SAAS,EAAE,MAAM,GACf,qBAAqB,CAAC,CAAC,CAAC,CAgB1B"}

package/out/lib/parallel/parallel-map-runtime.js

@@ -0,0 +1,60 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ *
+ * Transport-agnostic core of `parallelMap` — a record-dispatch worker pool. `runPool` keeps every
+ * worker busy mapping batches pulled from one shared source, with no `worker_threads` dependency so it
+ * unit-tests against fake workers.
+ */
+import { mergeAsyncIterators } from "./merge-async-iterators.js";
+/**
+ * Serialize pulls from `source` into batches of up to `batchSize`. Returns a `next()` that is safe to call concurrently
+ * (each call awaits the prior pull) — concurrent worker loops share one source without racing the underlying iterator.
+ * Resolves `null` once the source is exhausted.
+ */
+function makeBatcher(source, batchSize) {
+    const iterator = Symbol.asyncIterator in source
+        ? source[Symbol.asyncIterator]()
+        : source[Symbol.iterator]();
+    let chain = Promise.resolve();
+    let exhausted = false;
+    return () => {
+        const pull = chain.then(async () => {
+            if (exhausted)
+                return null;
+            const batch = [];
+            while (batch.length < batchSize) {
+                const { value, done } = await iterator.next();
+                if (done) {
+                    exhausted = true;
+                    break;
+                }
+                batch.push(value);
+            }
+            return batch.length ? batch : null;
+        });
+        // Keep the chain alive regardless of this pull's outcome so the next call still serializes.
+        chain = pull.then(() => undefined, () => undefined);
+        return pull;
+    };
+}
+/**
+ * Drive a pool of `workers` over `source`: each worker loops — pull a batch, map it, emit results — until the source is
+ * exhausted. Results stream out in completion order (a worker's whole batch yields before it pulls the next, which
+ * bounds in-flight work to the pool size). A worker error propagates and tears the pool down.
+ */
+export function runPool(workers, source, batchSize) {
+    const nextBatch = makeBatcher(source, batchSize);
+    async function* workerLoop(worker) {
+        for (;;) {
+            const batch = await nextBatch();
+            if (batch === null)
+                return;
+            const results = await worker.process(batch);
+            yield* results;
+        }
+    }
+    return mergeAsyncIterators(workers.map((worker) => workerLoop(worker)));
+}
+//# sourceMappingURL=parallel-map-runtime.js.map

package/out/lib/parallel/parallel-map-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel-map-runtime.js","sourceRoot":"","sources":["../../../lib/parallel/parallel-map-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAShE;;;;GAIG;AACH,SAAS,WAAW,CAAI,MAAsC,EAAE,SAAiB;IAChF,MAAM,QAAQ,GACb,MAAM,CAAC,aAAa,IAAI,MAAM;QAC7B,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE;QAChC,CAAC,CAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAkC,CAAA;IAE9D,IAAI,KAAK,GAAqB,OAAO,CAAC,OAAO,EAAE,CAAA;IAC/C,IAAI,SAAS,GAAG,KAAK,CAAA;IAErB,OAAO,GAAG,EAAE;QACX,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;YAClC,IAAI,SAAS;gBAAE,OAAO,IAAI,CAAA;YAE1B,MAAM,KAAK,GAAQ,EAAE,CAAA;YAErB,OAAO,KAAK,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;gBACjC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAA;gBAE7C,IAAI,IAAI,EAAE,CAAC;oBACV,SAAS,GAAG,IAAI,CAAA;oBAEhB,MAAK;gBACN,CAAC;gBAED,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YAClB,CAAC;YAED,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAA;QACnC,CAAC,CAAC,CAAA;QAEF,4FAA4F;QAC5F,KAAK,GAAG,IAAI,CAAC,IAAI,CAChB,GAAG,EAAE,CAAC,SAAS,EACf,GAAG,EAAE,CAAC,SAAS,CACf,CAAA;QAED,OAAO,IAAI,CAAA;IACZ,CAAC,CAAA;AACF,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,OAAO,CACtB,OAAgC,EAChC,MAAsC,EACtC,SAAiB;IAEjB,MAAM,SAAS,GAAG,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IAEhD,KAAK,SAAS,CAAC,CAAC,UAAU,CAAC,MAAwB;QAClD,SAAS,CAAC;YACT,MAAM,KAAK,GAAG,MAAM,SAAS,EAAE,CAAA;YAE/B,IAAI,KAAK,KAAK,IAAI;gBAAE,OAAM;YAE1B,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;YAE3C,KAAK,CAAC,CAAC,OAAO,CAAA;QACf,CAAC;IACF,CAAC;IAED,OAAO,mBAAmB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;AACxE,CAAC"}

package/out/lib/parallel/parallel-map-worker-entry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ *
+ * Runs inside a worker thread (spawned by parallelMap). Imports the handler module once (top-level =
+ * per-worker init), then maps each dispatched batch and posts the results back. Processes one batch at
+ * a time — the pool never dispatches the next until this batch's result returns.
+ */
+export {};
+//# sourceMappingURL=parallel-map-worker-entry.d.ts.map

package/out/lib/parallel/parallel-map-worker-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel-map-worker-entry.d.ts","sourceRoot":"","sources":["../../../lib/parallel/parallel-map-worker-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/out/lib/parallel/parallel-map-worker-entry.js

@@ -0,0 +1,41 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ *
+ * Runs inside a worker thread (spawned by parallelMap). Imports the handler module once (top-level =
+ * per-worker init), then maps each dispatched batch and posts the results back. Processes one batch at
+ * a time — the pool never dispatches the next until this batch's result returns.
+ */
+import { parentPort, workerData } from "node:worker_threads";
+const data = workerData;
+const port = parentPort;
+let nextIndex = 0;
+const handlerReady = import(data.handlerUrl).then((mod) => mod.handleItem ?? mod.default);
+port.on("message", async (msg) => {
+    const message = msg;
+    if (message?.type !== "batch")
+        return;
+    try {
+        const handleItem = await handlerReady;
+        if (typeof handleItem !== "function") {
+            throw new TypeError(`Worker module ${data.handlerUrl} has no handleItem export.`);
+        }
+        const results = [];
+        const transfer = [];
+        for (const item of message.batch) {
+            const result = await handleItem(item, { index: nextIndex++ });
+            if (result === undefined)
+                continue;
+            results.push(result);
+            if (result instanceof Uint8Array) {
+                transfer.push(result.buffer);
+            }
+        }
+        port.postMessage({ type: "result", results }, transfer);
+    }
+    catch (error) {
+        port.postMessage({ type: "error", message: error instanceof Error ? error.message : String(error) });
+    }
+});
+//# sourceMappingURL=parallel-map-worker-entry.js.map

package/out/lib/parallel/parallel-map-worker-entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel-map-worker-entry.js","sourceRoot":"","sources":["../../../lib/parallel/parallel-map-worker-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAS5D,MAAM,IAAI,GAAG,UAAwB,CAAA;AACrC,MAAM,IAAI,GAAG,UAAW,CAAA;AAExB,IAAI,SAAS,GAAG,CAAC,CAAA;AAEjB,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,IAAI,CAChD,CAAC,GAAgE,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,IAAI,GAAG,CAAC,OAAO,CACnG,CAAA;AAED,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,GAAY,EAAE,EAAE;IACzC,MAAM,OAAO,GAAG,GAA0C,CAAA;IAE1D,IAAI,OAAO,EAAE,IAAI,KAAK,OAAO;QAAE,OAAM;IAErC,IAAI,CAAC;QACJ,MAAM,UAAU,GAAG,MAAM,YAAY,CAAA;QAErC,IAAI,OAAO,UAAU,KAAK,UAAU,EAAE,CAAC;YACtC,MAAM,IAAI,SAAS,CAAC,iBAAiB,IAAI,CAAC,UAAU,4BAA4B,CAAC,CAAA;QAClF,CAAC;QAED,MAAM,OAAO,GAAc,EAAE,CAAA;QAC7B,MAAM,QAAQ,GAAkB,EAAE,CAAA;QAElC,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;YAClC,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,CAAC,CAAA;YAE7D,IAAI,MAAM,KAAK,SAAS;gBAAE,SAAQ;YAElC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;YAEpB,IAAI,MAAM,YAAY,UAAU,EAAE,CAAC;gBAClC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,MAAqB,CAAC,CAAA;YAC5C,CAAC;QACF,CAAC;QAED,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,QAAQ,CAAC,CAAA;IACxD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;IACrG,CAAC;AACF,CAAC,CAAC,CAAA"}

package/out/lib/parallel/parallel-map-workers.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ */
+/**
+ * Per-item handler a parallelMapWorkers worker module exports. `index` is per-worker monotonic.
+ */
+export type ParallelHandler<T = unknown, R = unknown> = (item: T, ctx: {
+    index: number;
+}) => R | Uint8Array | undefined | Promise<R | Uint8Array | undefined>;
+export interface ParallelMapWorkersOptions {
+    /**
+     * Worker module path/URL exporting `handleItem(item, ctx)`. Top-level code = per-worker init.
+     */
+    worker: string | URL;
+    /**
+     * Number of worker threads in the pool. Keep it SMALL for I/O- or memory-bound handlers (per-row DB lookups, large
+     * shared datasets): throughput typically peaks at ~2–3 and _degrades_ past that as workers contend for the shared
+     * resource — only CPU-bound handlers scale toward the core count. Also bounded by RAM (each worker re-inits its
+     * deps). Sweep it for your workload rather than defaulting to `availableParallelism()`.
+     */
+    concurrency: number;
+    /**
+     * Items per dispatched batch. @default 64
+     */
+    batchSize?: number;
+    /**
+     * Forwarded to every worker via `workerData.userData` (must be structured-cloneable).
+     */
+    workerData?: unknown;
+}
+/**
+ * Map an async (or sync) iterable through a pool of worker threads. Main pulls items from `source`, batches them, and
+ * dispatches each batch to an idle worker running the `worker` handler module; results stream back as a single merged
+ * async iterator in **completion order** (not input order). A handler returning `undefined` drops that item; a
+ * `Uint8Array` is transferred zero-copy.
+ *
+ * **When it pays (measure — don't assume).** Threading only wins when per-item work is heavy relative to the ~µs
+ * cross-thread dispatch cost (structured-clone in + out). From real workloads: light per-row work — CSV/JSON parse,
+ * string normalize, `JSON.parse` — is _dispatch-bound_ and runs **0.3–0.9× of single-threaded (a net loss)**; ms-scale
+ * per-row work — model inference, geocoding, crypto/image ops — is where threads win. If the per-row cost isn't clearly
+ * milliseconds, benchmark against the single-threaded version before adopting.
+ *
+ * **Concurrency is not core count.** Heavy work that is I/O- or memory-bound (random reads into one large on-disk DB,
+ * anything sharing memory bandwidth) peaks _low_ — often ~2–3 workers — and then _degrades_, because the workers
+ * contend for the shared resource, not the CPU. Start small and sweep; don't reach for `availableParallelism()`. Only
+ * CPU-bound per-row work (pure compute) scales out toward the core count.
+ *
+ * All workers are terminated on completion, error, or early `return()`.
+ *
+ * @see `parallelMap` for the same shape on the caller's thread — it takes a closure, which is why it cannot cross a
+ *   thread boundary and this takes a module path instead.
+ * @see The "Choosing a primitive" table in the README, which keys the decision off per-row work.
+ */
+export declare function parallelMapWorkers<T, R = unknown>(source: AsyncIterable<T> | Iterable<T>, options: ParallelMapWorkersOptions): AsyncIterableIterator<R>;
+//# sourceMappingURL=parallel-map-workers.d.ts.map

package/out/lib/parallel/parallel-map-workers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel-map-workers.d.ts","sourceRoot":"","sources":["../../../lib/parallel/parallel-map-workers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH;;GAEG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,IAAI,CACvD,IAAI,EAAE,CAAC,EACP,GAAG,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,KAClB,CAAC,GAAG,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC,CAAC,GAAG,UAAU,GAAG,SAAS,CAAC,CAAA;AAErE,MAAM,WAAW,yBAAyB;IACzC;;OAEG;IACH,MAAM,EAAE,MAAM,GAAG,GAAG,CAAA;IACpB;;;;;OAKG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;OAEG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;CACpB;AAqCD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,EAChD,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,EACtC,OAAO,EAAE,yBAAyB,GAChC,qBAAqB,CAAC,CAAC,CAAC,CAyB1B"}

package/out/lib/parallel/parallel-map-workers.js

@@ -0,0 +1,82 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ */
+import { Worker } from "node:worker_threads";
+import { runPool } from "./parallel-map-runtime.js";
+/**
+ * Wrap a worker as a pool slot: dispatch one batch, await its result. One batch in flight at a time.
+ */
+function workerHandle(worker) {
+    let pending = null;
+    const settle = (fn) => {
+        if (!pending)
+            return;
+        const p = pending;
+        pending = null;
+        fn(p);
+    };
+    worker.on("message", (msg) => {
+        if (msg?.type === "result") {
+            settle((p) => p.resolve(msg.results));
+        }
+        else if (msg?.type === "error") {
+            settle((p) => p.reject(new Error(msg.message)));
+        }
+    });
+    worker.on("error", (error) => settle((p) => p.reject(error instanceof Error ? error : new Error(String(error)))));
+    return {
+        process(batch) {
+            return new Promise((resolve, reject) => {
+                pending = { resolve, reject };
+                worker.postMessage({ type: "batch", batch });
+            });
+        },
+    };
+}
+/**
+ * Map an async (or sync) iterable through a pool of worker threads. Main pulls items from `source`, batches them, and
+ * dispatches each batch to an idle worker running the `worker` handler module; results stream back as a single merged
+ * async iterator in **completion order** (not input order). A handler returning `undefined` drops that item; a
+ * `Uint8Array` is transferred zero-copy.
+ *
+ * **When it pays (measure — don't assume).** Threading only wins when per-item work is heavy relative to the ~µs
+ * cross-thread dispatch cost (structured-clone in + out). From real workloads: light per-row work — CSV/JSON parse,
+ * string normalize, `JSON.parse` — is _dispatch-bound_ and runs **0.3–0.9× of single-threaded (a net loss)**; ms-scale
+ * per-row work — model inference, geocoding, crypto/image ops — is where threads win. If the per-row cost isn't clearly
+ * milliseconds, benchmark against the single-threaded version before adopting.
+ *
+ * **Concurrency is not core count.** Heavy work that is I/O- or memory-bound (random reads into one large on-disk DB,
+ * anything sharing memory bandwidth) peaks _low_ — often ~2–3 workers — and then _degrades_, because the workers
+ * contend for the shared resource, not the CPU. Start small and sweep; don't reach for `availableParallelism()`. Only
+ * CPU-bound per-row work (pure compute) scales out toward the core count.
+ *
+ * All workers are terminated on completion, error, or early `return()`.
+ *
+ * @see `parallelMap` for the same shape on the caller's thread — it takes a closure, which is why it cannot cross a
+ *   thread boundary and this takes a module path instead.
+ * @see The "Choosing a primitive" table in the README, which keys the decision off per-row work.
+ */
+export function parallelMapWorkers(source, options) {
+    const handlerUrl = options.worker instanceof URL ? options.worker.href : new URL(options.worker, `file://${process.cwd()}/`).href;
+    const concurrency = Math.max(1, Math.floor(options.concurrency));
+    const batchSize = options.batchSize ?? 64;
+    const entryUrl = new URL("./parallel-map-worker-entry.js", import.meta.url);
+    const workers = [];
+    async function* run() {
+        try {
+            const pool = Array.from({ length: concurrency }, () => {
+                const worker = new Worker(entryUrl, { workerData: { handlerUrl, userData: options.workerData } });
+                workers.push(worker);
+                return workerHandle(worker);
+            });
+            yield* runPool(pool, source, batchSize);
+        }
+        finally {
+            await Promise.all(workers.map((worker) => worker.terminate()));
+        }
+    }
+    return run();
+}
+//# sourceMappingURL=parallel-map-workers.js.map

package/out/lib/parallel/parallel-map-workers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel-map-workers.js","sourceRoot":"","sources":["../../../lib/parallel/parallel-map-workers.ts"],"names":[],"mappings":"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"}

package/out/lib/parallel/parallel-map.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @copyright Sister Software
+ * @license MIT
+ * @author Teffen Ellis, et al.
+ */
+import { AsyncSequence, type ParallelMapSequenceOptions } from "../iterators/AsyncSequence.js";
+/**
+ * Map an iterable through a callback with up to `concurrency` calls in flight, yielding in **completion order** — not
+ * input order.
+ *
+ * The callback is a closure, so every call runs on the caller's thread. This overlaps _latency_ — file reads, network
+ * round-trips, anything that spends its time waiting — and does nothing for CPU-bound work, which still occupies the
+ * one thread it always did.
+ *
+ * **Concurrency is not core count.** Work that contends for a shared resource (one disk, one socket pool, one on-disk
+ * database) peaks _low_ — often ~2–3 — and then degrades. Sweep it.
+ *
+ * @param source The collection to map.
+ * @param fn The callback, receiving `(value, counter)`.
+ * @param options Concurrency ceiling and optional abort signal.
+ *
+ * @yields Each result, in completion order.
+ * @see {@linkcode parallelMapWorkers} to run the handler on worker threads instead — it takes a module path rather than
+ *   a closure, because a closure cannot cross a thread boundary.
+ * @see The "Choosing a primitive" table in the README, which keys the decision off per-row work.
+ */
+export declare function parallelMap<T, U>(source: AsyncIterable<T> | Iterable<T>, fn: (value: T, counter: number) => U | PromiseLike<U>, options: ParallelMapSequenceOptions): AsyncSequence<U>;
+//# sourceMappingURL=parallel-map.d.ts.map

package/out/lib/parallel/parallel-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel-map.d.ts","sourceRoot":"","sources":["../../../lib/parallel/parallel-map.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,KAAK,0BAA0B,EAAE,MAAM,+BAA+B,CAAA;AAE9F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAC/B,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,EACtC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EACrD,OAAO,EAAE,0BAA0B,GACjC,aAAa,CAAC,CAAC,CAAC,CAElB"}