recker 1.0.2-0

package/dist/utils/progress.js

@@ -0,0 +1,49 @@
+export function createProgressStream(stream, onProgress, total) {
+    let loaded = 0;
+    let startTime = Date.now();
+    let lastUpdate = startTime;
+    return new ReadableStream({
+        async start(controller) {
+            const reader = stream.getReader();
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        controller.close();
+                        break;
+                    }
+                    loaded += value.byteLength;
+                    const now = Date.now();
+                    const elapsed = (now - startTime) / 1000;
+                    const rate = elapsed > 0 ? loaded / elapsed : 0;
+                    if (now - lastUpdate > 100 || loaded === total) {
+                        const progress = {
+                            loaded,
+                            total,
+                            percent: total ? (loaded / total) * 100 : undefined,
+                            rate,
+                            estimated: total && rate > 0 ? ((total - loaded) / rate) * 1000 : undefined,
+                        };
+                        onProgress(progress);
+                        lastUpdate = now;
+                    }
+                    controller.enqueue(value);
+                }
+            }
+            catch (error) {
+                controller.error(error);
+                throw error;
+            }
+        },
+    });
+}
+export function calculateProgress(loaded, total) {
+    const progress = {
+        loaded,
+        total,
+    };
+    if (total && total > 0) {
+        progress.percent = (loaded / total) * 100;
+    }
+    return progress;
+}

package/dist/utils/request-pool.d.ts

@@ -0,0 +1,23 @@
+import type { Middleware } from '../types/index.js';
+export interface RequestPoolOptions {
+    concurrency?: number;
+    requestsPerInterval?: number;
+    interval?: number;
+}
+export declare class RequestPool {
+    private readonly concurrency;
+    private readonly requestsPerInterval?;
+    private readonly interval?;
+    private queue;
+    private active;
+    private windowStart;
+    private startedInWindow;
+    private waitingTimer?;
+    constructor(options?: RequestPoolOptions);
+    run<T>(fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+    private _removeFromQueue;
+    private _canStart;
+    private _schedule;
+    asMiddleware(): Middleware;
+}
+//# sourceMappingURL=request-pool.d.ts.map

package/dist/utils/request-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-pool.d.ts","sourceRoot":"","sources":["../../src/utils/request-pool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAA+C,MAAM,mBAAmB,CAAC;AAEjG,MAAM,WAAW,kBAAkB;IAKjC,WAAW,CAAC,EAAE,MAAM,CAAC;IAKrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAI7B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAiBD,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAS;IAC9C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAS;IACnC,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,YAAY,CAAC,CAAiB;gBAE1B,OAAO,GAAE,kBAAuB;IAM5C,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC;IAuB9D,OAAO,CAAC,gBAAgB;IAOxB,OAAO,CAAC,SAAS;IAqBjB,OAAO,CAAC,SAAS;IA4DjB,YAAY,IAAI,UAAU;CAM3B"}

package/dist/utils/request-pool.js

@@ -0,0 +1,100 @@
+export class RequestPool {
+    concurrency;
+    requestsPerInterval;
+    interval;
+    queue = [];
+    active = 0;
+    windowStart = 0;
+    startedInWindow = 0;
+    waitingTimer;
+    constructor(options = {}) {
+        this.concurrency = options.concurrency ?? Number.POSITIVE_INFINITY;
+        this.requestsPerInterval = options.requestsPerInterval;
+        this.interval = options.interval;
+    }
+    run(fn, signal) {
+        if (signal?.aborted) {
+            return Promise.reject(signal.reason ?? new Error('Request aborted before enqueue'));
+        }
+        return new Promise((resolve, reject) => {
+            const request = { fn, resolve, reject, signal };
+            if (signal) {
+                const onAbort = () => {
+                    this._removeFromQueue(request);
+                    reject(signal.reason ?? new Error('Request aborted while queued'));
+                    this._schedule();
+                };
+                signal.addEventListener('abort', onAbort, { once: true });
+                request.abortCleanup = () => signal.removeEventListener('abort', onAbort);
+            }
+            this.queue.push(request);
+            this._schedule();
+        });
+    }
+    _removeFromQueue(request) {
+        const index = this.queue.indexOf(request);
+        if (index >= 0) {
+            this.queue.splice(index, 1);
+        }
+    }
+    _canStart(now) {
+        if (this.active >= this.concurrency) {
+            return false;
+        }
+        if (this.requestsPerInterval == null || this.interval == null) {
+            return true;
+        }
+        if (now - this.windowStart >= this.interval) {
+            this.windowStart = now;
+            this.startedInWindow = 0;
+        }
+        if (this.startedInWindow < this.requestsPerInterval) {
+            return true;
+        }
+        return false;
+    }
+    _schedule() {
+        if (this.waitingTimer) {
+            return;
+        }
+        const now = Date.now();
+        while (this.queue.length > 0 && this._canStart(Date.now())) {
+            const request = this.queue.shift();
+            if (request.signal?.aborted) {
+                request.abortCleanup?.();
+                request.reject(request.signal.reason ?? new Error('Request aborted while queued'));
+                continue;
+            }
+            this.active++;
+            this.startedInWindow++;
+            const clearAbort = request.abortCleanup;
+            if (clearAbort) {
+                clearAbort();
+                request.abortCleanup = undefined;
+            }
+            Promise.resolve()
+                .then(() => request.fn())
+                .then((result) => request.resolve(result))
+                .catch((error) => request.reject(error))
+                .finally(() => {
+                this.active--;
+                this._schedule();
+            });
+        }
+        if (this.queue.length > 0 &&
+            this.requestsPerInterval != null &&
+            this.interval != null &&
+            !this._canStart(Date.now())) {
+            const wait = Math.max(0, this.windowStart + this.interval - Date.now());
+            this.waitingTimer = setTimeout(() => {
+                this.waitingTimer = undefined;
+                this._schedule();
+            }, wait);
+        }
+    }
+    asMiddleware() {
+        return async (req, next) => {
+            return this.run(() => next(req), req.signal);
+        };
+    }
+}

package/dist/utils/sse.d.ts

@@ -0,0 +1,8 @@
+export interface SSEEvent {
+    id?: string;
+    event?: string;
+    data: string;
+    retry?: number;
+}
+export declare function parseSSE(response: Response): AsyncGenerator<SSEEvent>;
+//# sourceMappingURL=sse.d.ts.map

package/dist/utils/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../src/utils/sse.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAuB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,cAAc,CAAC,QAAQ,CAAC,CA4E5E"}

package/dist/utils/sse.js

@@ -0,0 +1,62 @@
+export async function* parseSSE(response) {
+    if (!response.body)
+        throw new Error('Response body is null');
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let currentEvent = { data: '' };
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(/\r\n|\r|\n/);
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (line.trim() === '') {
+                    if (currentEvent.data || currentEvent.event || currentEvent.id) {
+                        if (currentEvent.data.endsWith('\n')) {
+                            currentEvent.data = currentEvent.data.slice(0, -1);
+                        }
+                        yield currentEvent;
+                        currentEvent = { data: '' };
+                    }
+                    continue;
+                }
+                const colonIndex = line.indexOf(':');
+                let field = line;
+                let value = '';
+                if (colonIndex !== -1) {
+                    field = line.slice(0, colonIndex);
+                    value = line.slice(colonIndex + 1);
+                    if (value.startsWith(' ')) {
+                        value = value.slice(1);
+                    }
+                }
+                switch (field) {
+                    case 'data':
+                        currentEvent.data += value + '\n';
+                        break;
+                    case 'event':
+                        currentEvent.event = value;
+                        break;
+                    case 'id':
+                        currentEvent.id = value;
+                        break;
+                    case 'retry':
+                        const retry = parseInt(value, 10);
+                        if (!isNaN(retry)) {
+                            currentEvent.retry = retry;
+                        }
+                        break;
+                }
+            }
+        }
+        if (buffer.trim() !== '') {
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/dist/utils/streaming.d.ts

@@ -0,0 +1,18 @@
+import { Readable } from 'node:stream';
+export declare function webToNodeStream(webStream: ReadableStream): Readable;
+export declare function nodeToWebStream(nodeStream: Readable): ReadableStream<Uint8Array>;
+export interface StreamProgressOptions {
+    onProgress?: (progress: {
+        loaded: number;
+        total?: number;
+        percent?: number;
+    }) => void;
+    total?: number;
+}
+export declare function trackStreamProgress(stream: Readable, options?: StreamProgressOptions): Readable;
+export declare function pipeStream(source: Readable, destination: NodeJS.WritableStream, options?: StreamProgressOptions): Promise<void>;
+export declare function createUploadStream(source: Readable): {
+    stream: ReadableStream<Uint8Array<ArrayBufferLike>>;
+    promise: Promise<void>;
+};
+//# sourceMappingURL=streaming.d.ts.map

package/dist/utils/streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["../../src/utils/streaming.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,QAAQ,EAAe,MAAM,aAAa,CAAC;AAOpD,wBAAgB,eAAe,CAAC,SAAS,EAAE,cAAc,GAAG,QAAQ,CAsBnE;AAMD,wBAAgB,eAAe,CAAC,UAAU,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,CAoBhF;AAMD,MAAM,WAAW,qBAAqB;IACpC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IACtF,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,QAAQ,EAChB,OAAO,GAAE,qBAA0B,GAClC,QAAQ,CA6BV;AAMD,wBAAsB,UAAU,CAC9B,MAAM,EAAE,QAAQ,EAChB,WAAW,EAAE,MAAM,CAAC,cAAc,EAClC,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,IAAI,CAAC,CAMf;AAMD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,QAAQ;;;EAYlD"}

package/dist/utils/streaming.js

@@ -0,0 +1,83 @@
+import { Readable, PassThrough } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+export function webToNodeStream(webStream) {
+    const reader = webStream.getReader();
+    return new Readable({
+        async read() {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    this.push(null);
+                }
+                else {
+                    this.push(value);
+                }
+            }
+            catch (error) {
+                this.destroy(error);
+            }
+        },
+        destroy(error, callback) {
+            reader.cancel().finally(() => callback(error));
+        }
+    });
+}
+export function nodeToWebStream(nodeStream) {
+    return new ReadableStream({
+        start(controller) {
+            nodeStream.on('data', (chunk) => {
+                controller.enqueue(new Uint8Array(chunk));
+            });
+            nodeStream.on('end', () => {
+                controller.close();
+            });
+            nodeStream.on('error', (err) => {
+                controller.error(err);
+            });
+        },
+        cancel() {
+            nodeStream.destroy();
+        }
+    });
+}
+export function trackStreamProgress(stream, options = {}) {
+    const { onProgress, total } = options;
+    let loaded = 0;
+    const startTime = Date.now();
+    let lastUpdate = startTime;
+    const passThrough = new PassThrough();
+    stream.on('data', (chunk) => {
+        loaded += chunk.length;
+        const now = Date.now();
+        if (onProgress && now - lastUpdate > 100) {
+            const percent = total ? (loaded / total) * 100 : undefined;
+            onProgress({ loaded, total, percent });
+            lastUpdate = now;
+        }
+    });
+    stream.on('end', () => {
+        if (onProgress) {
+            const percent = total ? 100 : undefined;
+            onProgress({ loaded, total, percent });
+        }
+    });
+    stream.pipe(passThrough);
+    return passThrough;
+}
+export async function pipeStream(source, destination, options = {}) {
+    const tracked = options.onProgress
+        ? trackStreamProgress(source, options)
+        : source;
+    await pipeline(tracked, destination);
+}
+export function createUploadStream(source) {
+    const passThrough = new PassThrough();
+    source.pipe(passThrough);
+    return {
+        stream: nodeToWebStream(passThrough),
+        promise: new Promise((resolve, reject) => {
+            passThrough.on('finish', resolve);
+            passThrough.on('error', reject);
+        })
+    };
+}

package/dist/utils/task-pool.d.ts

@@ -0,0 +1,38 @@
+export interface TaskPoolOptions {
+    /**
+     * Max concurrent tasks allowed to execute at once.
+     * @default Infinity (no concurrency cap)
+     */
+    concurrency?: number;
+    /**
+     * Requests allowed per interval window.
+     * When provided with `interval`, starts will be spaced to respect the cap.
+     */
+    requestsPerInterval?: number;
+    /**
+     * Interval window length in milliseconds.
+     */
+    interval?: number;
+}
+/**
+ * Lightweight TaskPool for rate limiting and concurrency control.
+ *
+ * - Limits concurrent executions.
+ * - Enforces a max start rate (`requestsPerInterval` / `interval`) via a sliding window.
+ * - Respects AbortSignal both while queued and while running.
+ */
+export declare class TaskPool {
+    private readonly concurrency;
+    private readonly requestsPerInterval?;
+    private readonly interval?;
+    private queue;
+    private active;
+    private windowStart;
+    private startedInWindow;
+    private waitingTimer?;
+    constructor(options?: TaskPoolOptions);
+    run<T>(fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+    private _removeFromQueue;
+    private _canStart;
+    private _schedule;
+}

package/dist/utils/task-pool.js

@@ -0,0 +1,104 @@
+/**
+ * Lightweight TaskPool for rate limiting and concurrency control.
+ *
+ * - Limits concurrent executions.
+ * - Enforces a max start rate (`requestsPerInterval` / `interval`) via a sliding window.
+ * - Respects AbortSignal both while queued and while running.
+ */
+export class TaskPool {
+    concurrency;
+    requestsPerInterval;
+    interval;
+    queue = [];
+    active = 0;
+    windowStart = 0;
+    startedInWindow = 0;
+    waitingTimer;
+    constructor(options = {}) {
+        this.concurrency = options.concurrency ?? Number.POSITIVE_INFINITY;
+        this.requestsPerInterval = options.requestsPerInterval;
+        this.interval = options.interval;
+    }
+    run(fn, signal) {
+        if (signal?.aborted) {
+            return Promise.reject(signal.reason ?? new Error('Task aborted before enqueue'));
+        }
+        return new Promise((resolve, reject) => {
+            const task = { fn, resolve, reject, signal };
+            if (signal) {
+                const onAbort = () => {
+                    this._removeFromQueue(task);
+                    reject(signal.reason ?? new Error('Task aborted while queued'));
+                    this._schedule();
+                };
+                signal.addEventListener('abort', onAbort, { once: true });
+                task.abortCleanup = () => signal.removeEventListener('abort', onAbort);
+            }
+            this.queue.push(task);
+            this._schedule();
+        });
+    }
+    _removeFromQueue(task) {
+        const index = this.queue.indexOf(task);
+        if (index >= 0) {
+            this.queue.splice(index, 1);
+        }
+    }
+    _canStart(now) {
+        if (this.active >= this.concurrency) {
+            return false;
+        }
+        if (this.requestsPerInterval == null || this.interval == null) {
+            return true;
+        }
+        if (now - this.windowStart >= this.interval) {
+            this.windowStart = now;
+            this.startedInWindow = 0;
+        }
+        if (this.startedInWindow < this.requestsPerInterval) {
+            return true;
+        }
+        return false;
+    }
+    _schedule() {
+        if (this.waitingTimer) {
+            // There's already a timer waiting for the next window; let it fire.
+            return;
+        }
+        const now = Date.now();
+        while (this.queue.length > 0 && this._canStart(Date.now())) {
+            const task = this.queue.shift();
+            if (task.signal?.aborted) {
+                task.abortCleanup?.();
+                task.reject(task.signal.reason ?? new Error('Task aborted while queued'));
+                continue;
+            }
+            this.active++;
+            this.startedInWindow++;
+            const clearAbort = task.abortCleanup;
+            if (clearAbort) {
+                clearAbort();
+                task.abortCleanup = undefined;
+            }
+            Promise.resolve()
+                .then(() => task.fn())
+                .then((result) => task.resolve(result))
+                .catch((error) => task.reject(error))
+                .finally(() => {
+                this.active--;
+                this._schedule();
+            });
+        }
+        // If rate limit prevents starting now, schedule when the window resets
+        if (this.queue.length > 0 &&
+            this.requestsPerInterval != null &&
+            this.interval != null &&
+            !this._canStart(Date.now())) {
+            const wait = Math.max(0, this.windowStart + this.interval - Date.now());
+            this.waitingTimer = setTimeout(() => {
+                this.waitingTimer = undefined;
+                this._schedule();
+            }, wait);
+        }
+    }
+}

package/dist/utils/try-fn.d.ts

@@ -0,0 +1,4 @@
+export declare function tryFn<T>(fnOrPromise: (() => Promise<T>) | Promise<T> | (() => T) | T): Promise<[boolean, Error | null, T | undefined]> | [boolean, Error | null, T | undefined];
+export declare function tryFnSync<T>(fn: () => T): [boolean, Error | null, T | undefined];
+export default tryFn;
+//# sourceMappingURL=try-fn.d.ts.map

package/dist/utils/try-fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"try-fn.d.ts","sourceRoot":"","sources":["../../src/utils/try-fn.ts"],"names":[],"mappings":"AAqBA,wBAAgB,KAAK,CAAC,CAAC,EACrB,WAAW,EAAE,CAAC,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAC3D,OAAO,CAAC,CAAC,OAAO,EAAE,KAAK,GAAG,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,GAAG,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,CAwD1F;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,GAAG,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,CAOhF;AAED,eAAe,KAAK,CAAC"}

package/dist/utils/try-fn.js

@@ -0,0 +1,53 @@
+export function tryFn(fnOrPromise) {
+    if (fnOrPromise == null) {
+        const err = new Error('fnOrPromise cannot be null or undefined');
+        err.stack = new Error().stack;
+        return [false, err, undefined];
+    }
+    if (typeof fnOrPromise === 'function') {
+        try {
+            const result = fnOrPromise();
+            if (result == null) {
+                return [true, null, result];
+            }
+            if (typeof result.then === 'function') {
+                return result
+                    .then((data) => [true, null, data])
+                    .catch((error) => {
+                    if (error instanceof Error &&
+                        Object.isExtensible(error)) {
+                        const desc = Object.getOwnPropertyDescriptor(error, 'stack');
+                        if (!desc || (desc.writable && desc.configurable)) {
+                            try {
+                            }
+                            catch (_) { }
+                        }
+                    }
+                    return [false, error instanceof Error ? error : new Error(String(error)), undefined];
+                });
+            }
+            return [true, null, result];
+        }
+        catch (error) {
+            return [false, error instanceof Error ? error : new Error(String(error)), undefined];
+        }
+    }
+    if (typeof fnOrPromise.then === 'function') {
+        return Promise.resolve(fnOrPromise)
+            .then((data) => [true, null, data])
+            .catch((error) => {
+            return [false, error instanceof Error ? error : new Error(String(error)), undefined];
+        });
+    }
+    return [true, null, fnOrPromise];
+}
+export function tryFnSync(fn) {
+    try {
+        const result = fn();
+        return [true, null, result];
+    }
+    catch (err) {
+        return [false, err instanceof Error ? err : new Error(String(err)), undefined];
+    }
+}
+export default tryFn;

package/dist/utils/upload.d.ts

@@ -0,0 +1,10 @@
+import { Readable } from 'node:stream';
+export interface UploadOptions {
+    file: Readable | Buffer;
+    chunkSize?: number;
+    concurrency?: number;
+    uploadChunk: (chunk: Buffer, index: number, total: number) => Promise<void>;
+    onProgress?: (loaded: number, total: number) => void;
+}
+export declare function uploadParallel(options: UploadOptions): Promise<void>;
+//# sourceMappingURL=upload.d.ts.map

package/dist/utils/upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/utils/upload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5E,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACtD;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,aAAa,iBAiE1D"}

package/dist/utils/upload.js

@@ -0,0 +1,45 @@
+export async function uploadParallel(options) {
+    const chunkSize = options.chunkSize || 5 * 1024 * 1024;
+    const concurrency = options.concurrency || 3;
+    let buffer = Buffer.alloc(0);
+    let chunkIndex = 0;
+    let loaded = 0;
+    const queue = [];
+    const processChunk = async (chunk, idx) => {
+        await options.uploadChunk(chunk, idx, 0);
+        loaded += chunk.length;
+        if (options.onProgress)
+            options.onProgress(loaded, 0);
+    };
+    if (Buffer.isBuffer(options.file)) {
+        const total = options.file.length;
+        for (let i = 0; i < total; i += chunkSize) {
+            const chunk = options.file.slice(i, i + chunkSize);
+            const p = processChunk(chunk, chunkIndex++);
+            queue.push(p);
+            if (queue.length >= concurrency) {
+                await Promise.race(queue);
+            }
+        }
+        await Promise.all(queue);
+        return;
+    }
+    for await (const chunk of options.file) {
+        buffer = Buffer.concat([buffer, chunk]);
+        while (buffer.length >= chunkSize) {
+            const chunkToUpload = buffer.slice(0, chunkSize);
+            buffer = buffer.slice(chunkSize);
+            const p = processChunk(chunkToUpload, chunkIndex++);
+            queue.push(p);
+            if (queue.length >= concurrency) {
+                const finished = await Promise.race(queue);
+                await Promise.all(queue);
+                queue.length = 0;
+            }
+        }
+    }
+    if (buffer.length > 0) {
+        queue.push(processChunk(buffer, chunkIndex++));
+    }
+    await Promise.all(queue);
+}