spliterator 6.2.0 → 6.3.1

package/out/lib/chunks.d.ts

@@ -1,20 +0,0 @@
-/**
- * @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 declare function chunks<T>(collection: Iterable<T>, size: number): Generator<T[]>;
-//# sourceMappingURL=chunks.d.ts.map

package/out/lib/chunks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunks.d.ts","sourceRoot":"","sources":["../../lib/chunks.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAiB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAsBhF"}

package/out/lib/chunks.js

@@ -1,36 +0,0 @@
-/**
- * @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/chunks.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunks.js","sourceRoot":"","sources":["../../lib/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/merge-async-iterators.d.ts

@@ -1,12 +0,0 @@
-/**
- * @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/merge-async-iterators.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge-async-iterators.d.ts","sourceRoot":"","sources":["../../lib/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/merge-async-iterators.js

@@ -1,39 +0,0 @@
-/**
- * @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/merge-async-iterators.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge-async-iterators.js","sourceRoot":"","sources":["../../lib/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-map-runtime.d.ts

@@ -1,22 +0,0 @@
-/**
- * @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-map-runtime.d.ts.map

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

@@ -1,60 +0,0 @@
-/**
- * @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-map-runtime.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parallel-map-runtime.js","sourceRoot":"","sources":["../../lib/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-map-worker-entry.d.ts

@@ -1,11 +0,0 @@
-/**
- * @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-map-worker-entry.d.ts.map

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

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

@@ -1,41 +0,0 @@
-/**
- * @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-map-worker-entry.js.map

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

@@ -1,57 +0,0 @@
-/**
- * @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-map-workers.d.ts.map

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

@@ -1,82 +0,0 @@
-/**
- * @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-map-workers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parallel-map-workers.js","sourceRoot":"","sources":["../../lib/parallel-map-workers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAE5C,OAAO,EAAmB,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAgCpE;;GAEG;AACH,SAAS,YAAY,CAAO,MAAc;IACzC,IAAI,OAAO,GAA+E,IAAI,CAAA;IAE9F,MAAM,MAAM,GAAG,CAAC,EAA4C,EAAE,EAAE;QAC/D,IAAI,CAAC,OAAO;YAAE,OAAM;QACpB,MAAM,CAAC,GAAG,OAAO,CAAA;QACjB,OAAO,GAAG,IAAI,CAAA;QACd,EAAE,CAAC,CAAC,CAAC,CAAA;IACN,CAAC,CAAA;IAED,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,GAA0E,EAAE,EAAE;QACnG,IAAI,GAAG,EAAE,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC5B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;QACtC,CAAC;aAAM,IAAI,GAAG,EAAE,IAAI,KAAK,OAAO,EAAE,CAAC;YAClC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;QAChD,CAAC;IACF,CAAC,CAAC,CAAA;IAEF,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAc,EAAE,EAAE,CACrC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAClF,CAAA;IAED,OAAO;QACN,OAAO,CAAC,KAAK;YACZ,OAAO,IAAI,OAAO,CAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBAC3C,OAAO,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,CAAA;gBAC7B,MAAM,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAA;YAC7C,CAAC,CAAC,CAAA;QACH,CAAC;KACD,CAAA;AACF,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,kBAAkB,CACjC,MAAsC,EACtC,OAAkC;IAElC,MAAM,UAAU,GACf,OAAO,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,UAAU,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,IAAI,CAAA;IAE/G,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAA;IAChE,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,EAAE,CAAA;IACzC,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,gCAAgC,EAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAA;IAC3E,MAAM,OAAO,GAAa,EAAE,CAAA;IAE5B,KAAK,SAAS,CAAC,CAAC,GAAG;QAClB,IAAI,CAAC;YACJ,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,GAAG,EAAE;gBACrD,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,QAAQ,EAAE,EAAE,UAAU,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAA;gBACjG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;gBAEpB,OAAO,YAAY,CAAO,MAAM,CAAC,CAAA;YAClC,CAAC,CAAC,CAAA;YAEF,KAAK,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,CAAA;QACxC,CAAC;gBAAS,CAAC;YACV,MAAM,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAA;QAC/D,CAAC;IACF,CAAC;IAED,OAAO,GAAG,EAAE,CAAA;AACb,CAAC"}

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

@@ -1,28 +0,0 @@
-/**
- * @copyright Sister Software
- * @license MIT
- * @author Teffen Ellis, et al.
- */
-import { AsyncSequence, type ParallelMapSequenceOptions } from "./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-map.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parallel-map.d.ts","sourceRoot":"","sources":["../../lib/parallel-map.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,KAAK,0BAA0B,EAAE,MAAM,oBAAoB,CAAA;AAEnF;;;;;;;;;;;;;;;;;;;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"}

package/out/lib/parallel-map.js

@@ -1,30 +0,0 @@
-/**
- * @copyright Sister Software
- * @license MIT
- * @author Teffen Ellis, et al.
- */
-import { AsyncSequence } from "./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 function parallelMap(source, fn, options) {
-    return AsyncSequence.from(source).parallelMap(fn, options);
-}
-//# sourceMappingURL=parallel-map.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"parallel-map.js","sourceRoot":"","sources":["../../lib/parallel-map.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAmC,MAAM,oBAAoB,CAAA;AAEnF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,WAAW,CAC1B,MAAsC,EACtC,EAAqD,EACrD,OAAmC;IAEnC,OAAO,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,EAAE,EAAE,OAAO,CAAC,CAAA;AAC3D,CAAC"}

package/out/lib/pivot.d.ts

@@ -1,30 +0,0 @@
-/**
- * @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/pivot.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pivot.d.ts","sourceRoot":"","sources":["../../lib/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/pivot.js

@@ -1,47 +0,0 @@
-/**
- * @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/pivot.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pivot.js","sourceRoot":"","sources":["../../lib/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/row-emitters.d.ts

@@ -1,35 +0,0 @@
-/**
- * @copyright Sister Software
- * @license MIT
- * @author Teffen Ellis, et al.
- */
-/**
- * An output mode for row-emitting spliterators.
- */
-export type RowOutputMode = "array" | "object" | "entries";
-export type RowTransformer<V, T = unknown> = (value: V) => T;
-export type RowTransformerEntry<V, T = unknown> = [columnName: string, transformer: RowTransformer<V, T>];
-export type RowTransformerRecord<V> = Record<string, RowTransformer<V> | undefined>;
-export type RowEmitter<V, T = unknown> = (columns: Iterable<V>, headerColumns?: Iterable<RowTransformerEntry<V>>) => T;
-export type EmittedRecord<V = unknown> = Record<string, V>;
-/**
- * A row emitted in `entries` mode, as a 3-tuple:
- *
- * - The key of the column.
- * - The value of the column.
- * - The index of the row.
- */
-export type RowTuple<V = string | number> = [key: string, value: V, idx: number];
-export declare const identity: <V>(value: V) => V;
-/**
- * Create the `mode`-keyed emitter table for a cell type.
- *
- * `missingValue` fills columns absent from a short row (CSV binds `""`, XLSX binds `null`).
- */
-export declare function createRowEmitters<V>(missingValue: V): Record<RowOutputMode, RowEmitter<V> | null>;
-/**
- * Bind a header row to the caller's transformers, producing the `headerColumns` entries the emitters consume. Columns
- * without a transformer pass through {@linkcode identity}.
- */
-export declare function bindTransformers<V>(headers: string[], transformersInput: Iterable<RowTransformerEntry<V>> | RowTransformerRecord<V>): RowTransformerEntry<V>[];
-//# sourceMappingURL=row-emitters.d.ts.map

package/out/lib/row-emitters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"row-emitters.d.ts","sourceRoot":"","sources":["../../lib/row-emitters.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAA;AAE1D,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAA;AAE5D,MAAM,MAAM,mBAAmB,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AAEzG,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAA;AAEnF,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,EAAE,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;AAEtH,MAAM,MAAM,aAAa,CAAC,CAAC,GAAG,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;AAE1D;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,GAAG,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,CAAA;AAEhF,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,CAAC,KAAG,CAAU,CAAA;AAEjD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,MAAM,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAyBjG;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EACjC,OAAO,EAAE,MAAM,EAAE,EACjB,iBAAiB,EAAE,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,GAC3E,mBAAmB,CAAC,CAAC,CAAC,EAAE,CAa1B"}