@nmtjs/protocol 0.15.0-beta.35 → 0.15.0-beta.37

package/dist/client/protocol.js

@@ -1,9 +1,8 @@
-import { concat } from '../common/binary.js';
-export class ProtocolVersionInterface {
-    encode(...chunks) {
-        return concat(...chunks);
-    }
-}
+import { createPromise } from '@nmtjs/common';
+import { concat, decodeNumber, encodeNumber } from "../common/binary.js";
+import { ClientMessageType, ErrorCode, ServerMessageType, } from "../common/enums.js";
+import { EventEmitter } from "./events.js";
+import { ProtocolClientBlobStream, ProtocolServerBlobStream, ProtocolServerStream, } from "./stream.js";
 export class ProtocolError extends Error {
     code;
     data;
@@ -22,4 +21,334 @@ export class ProtocolError extends Error {
         return { code: this.code, message: this.message, data: this.data };
     }
 }
-//# sourceMappingURL=protocol.js.map
+export class ProtocolClientStreams {
+    #collection = new Map();
+    get(streamId) {
+        const stream = this.#collection.get(streamId);
+        if (!stream)
+            throw new Error('Stream not found');
+        return stream;
+    }
+    add(source, streamId, metadata) {
+        const stream = new ProtocolClientBlobStream(source, streamId, metadata);
+        this.#collection.set(streamId, stream);
+        return stream;
+    }
+    remove(streamId) {
+        this.#collection.delete(streamId);
+    }
+    abort(streamId, error) {
+        const stream = this.get(streamId);
+        stream.abort(error);
+        this.remove(streamId);
+    }
+    pull(streamId, size) {
+        const stream = this.get(streamId);
+        return stream.read(size);
+    }
+    end(streamId) {
+        this.get(streamId).end();
+        this.remove(streamId);
+    }
+    clear(error) {
+        if (error) {
+            for (const stream of this.#collection.values()) {
+                stream.abort(error);
+            }
+        }
+        this.#collection.clear();
+    }
+}
+export class ProtocolServerStreams {
+    #collection = new Map();
+    has(streamId) {
+        return this.#collection.has(streamId);
+    }
+    get(streamId) {
+        const stream = this.#collection.get(streamId);
+        if (!stream)
+            throw new Error('Stream not found');
+        return stream;
+    }
+    add(streamId, stream) {
+        this.#collection.set(streamId, stream);
+        return stream;
+    }
+    remove(streamId) {
+        this.#collection.delete(streamId);
+    }
+    abort(streamId) {
+        if (this.has(streamId)) {
+            const stream = this.get(streamId);
+            stream.abort();
+            this.remove(streamId);
+        }
+    }
+    async push(streamId, chunk) {
+        const stream = this.get(streamId);
+        return await stream.push(chunk);
+    }
+    end(streamId) {
+        const stream = this.get(streamId);
+        stream.end();
+        this.remove(streamId);
+    }
+    clear(error) {
+        if (error) {
+            for (const stream of this.#collection.values()) {
+                stream.abort(error);
+            }
+        }
+        this.#collection.clear();
+    }
+}
+export var ProtocolTransportStatus;
+(function (ProtocolTransportStatus) {
+    ProtocolTransportStatus["CONNECTED"] = "CONNECTED";
+    ProtocolTransportStatus["DISCONNECTED"] = "DISCONNECTED";
+    ProtocolTransportStatus["CONNECTING"] = "CONNECTING";
+})(ProtocolTransportStatus || (ProtocolTransportStatus = {}));
+export class ProtocolTransport extends EventEmitter {
+    options;
+    status = ProtocolTransportStatus.DISCONNECTED;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+}
+export class ProtocolBaseTransformer {
+    encodeRPC(_procedure, payload) {
+        return payload;
+    }
+    decodeRPC(_procedure, payload) {
+        return payload;
+    }
+    decodeRPCChunk(_procedure, payload) {
+        return payload;
+    }
+    decodeEvent(_event, payload) {
+        return payload;
+    }
+}
+export class BaseProtocol extends EventEmitter {
+    format;
+    clientStreams = new ProtocolClientStreams();
+    serverStreams = new ProtocolServerStreams();
+    rpcStreams = new ProtocolServerStreams();
+    calls = new Map();
+    callId = 0;
+    streamId = 0;
+    constructor(format) {
+        super();
+        this.format = format;
+    }
+    get contentType() {
+        return this.format.contentType;
+    }
+    handleCallResponse(callId, call, response, transformer) {
+        if (response.error) {
+            call.reject(new ProtocolError(response.error.code, response.error.message, response.error.data));
+        }
+        else {
+            try {
+                const transformed = transformer.decodeRPC(call.procedure, response.result);
+                if (response.stream)
+                    call.resolve({ result: transformed, stream: response.stream });
+                else
+                    call.resolve(transformed);
+            }
+            catch (error) {
+                call.reject(new ProtocolError(ErrorCode.ClientRequestError, 'Unable to decode response', error));
+            }
+        }
+        this.calls.delete(callId);
+    }
+    handleRpcResponse({ callId, error, result, streams }, transformer, stream) {
+        const call = this.calls.get(callId);
+        if (!call)
+            throw new Error('Call not found');
+        for (const key in streams) {
+            const stream = streams[key];
+            this.serverStreams.add(stream.id, stream);
+        }
+        this.handleCallResponse(callId, call, error ? { error } : { result, stream }, transformer);
+        return call;
+    }
+    handleRpcStreamResponse(response, stream, transformer) {
+        const call = this.handleRpcResponse(response, transformer, stream);
+        this.rpcStreams.add(response.callId, stream);
+        return call;
+    }
+    createCall(procedure, options) {
+        const timeoutSignal = AbortSignal.timeout(options.timeout);
+        const signal = options.signal
+            ? AbortSignal.any([options.signal, timeoutSignal])
+            : timeoutSignal;
+        const call = Object.assign(createPromise(), { procedure, signal });
+        timeoutSignal.addEventListener('abort', () => {
+            const error = new ProtocolError(ErrorCode.RequestTimeout, 'Request timeout');
+            call.reject(error);
+        }, { once: true });
+        return call;
+    }
+    createRpc(procedure, payload, options, transformer) {
+        const callId = ++this.callId;
+        const call = this.createCall(procedure, options);
+        const { buffer, streams } = this.format.encodeRPC({ callId, procedure, payload: transformer.encodeRPC(procedure, payload) }, {
+            addStream: (blob) => {
+                const streamId = ++this.streamId;
+                return this.clientStreams.add(blob.source, streamId, blob.metadata);
+            },
+            getStream: (id) => {
+                const stream = this.clientStreams.get(id);
+                return stream;
+            },
+        });
+        this.calls.set(callId, call);
+        return { callId, call, streams, buffer };
+    }
+    pushRpcStream(callId, chunk) {
+        this.rpcStreams.push(callId, chunk);
+    }
+    endRpcStream(callId) {
+        this.rpcStreams.end(callId);
+    }
+    abortRpcStream(callId) {
+        this.rpcStreams.abort(callId);
+    }
+    removeClientStream(streamId) {
+        this.clientStreams.remove(streamId);
+    }
+    pullClientStream(streamId, size) {
+        return this.clientStreams.pull(streamId, size);
+    }
+    endClientStream(streamId) {
+        this.clientStreams.end(streamId);
+    }
+    abortClientStream(streamId, error) {
+        this.clientStreams.abort(streamId, error);
+    }
+    addServerStream(stream) {
+        this.serverStreams.add(stream.id, stream);
+    }
+    removeServerStream(streamId) {
+        this.serverStreams.remove(streamId);
+    }
+    pushServerStream(streamId, chunk) {
+        return this.serverStreams.push(streamId, chunk);
+    }
+    endServerStream(streamId) {
+        this.serverStreams.end(streamId);
+    }
+    abortServerStream(streamId, _error) {
+        this.serverStreams.abort(streamId);
+    }
+    emitEvent(event, payload, transformer) {
+        const transformed = transformer.decodeEvent(event, payload);
+        this.emit(event, 
+        //@ts-expect-error
+        transformed);
+    }
+}
+export class Protocol extends BaseProtocol {
+    handleServerMessage(buffer, transport, transformer) {
+        const type = decodeNumber(buffer, 'Uint8');
+        const messageBuffer = buffer.slice(Uint8Array.BYTES_PER_ELEMENT);
+        if (type in ServerMessageType) {
+            const messageType = type;
+            if (typeof ServerMessageType[messageType] !== 'undefined') {
+                this[messageType](messageBuffer, transport, transformer);
+            }
+            else {
+                throw new Error(`Unknown message type: ${messageType}`);
+            }
+        }
+    }
+    [ServerMessageType.Event](buffer, _transport, transformer) {
+        const [event, payload] = this.format.decode(buffer);
+        this.emitEvent(event, payload, transformer);
+    }
+    [ServerMessageType.RpcResponse](buffer, transport, transformer) {
+        const response = this.format.decodeRPC(buffer, {
+            addStream: (id, callId, metadata) => {
+                return new ProtocolServerBlobStream(id, metadata, {
+                    start: () => {
+                        transport.send(ClientMessageType.ServerStreamPull, encodeNumber(id, 'Uint32'), { callId, streamId: id });
+                    },
+                });
+            },
+            getStream: (id) => {
+                return this.serverStreams.get(id);
+            },
+        });
+        this.handleRpcResponse(response, transformer);
+    }
+    [ServerMessageType.RpcStreamResponse](buffer, transport, transformer) {
+        const response = this.format.decodeRPC(buffer, {
+            addStream: (id, callId, metadata) => {
+                return new ProtocolServerBlobStream(id, metadata, {
+                    start: () => {
+                        transport.send(ClientMessageType.ServerStreamPull, encodeNumber(id, 'Uint32'), { callId, streamId: id });
+                    },
+                });
+            },
+            getStream: (id) => {
+                return this.serverStreams.get(id);
+            },
+        });
+        const stream = new ProtocolServerStream({
+            transform: (chunk, controller) => {
+                const transformed = transformer.decodeRPCChunk(call.procedure, chunk);
+                controller.enqueue(transformed);
+            },
+        });
+        const call = this.handleRpcStreamResponse(response, stream, transformer);
+    }
+    [ServerMessageType.RpcStreamChunk](buffer, _transport, _transformer) {
+        const callId = decodeNumber(buffer, 'Uint32');
+        const chunk = buffer.slice(Uint32Array.BYTES_PER_ELEMENT);
+        const payload = this.format.decode(chunk);
+        this.pushRpcStream(callId, payload);
+    }
+    [ServerMessageType.RpcStreamEnd](buffer, _transport, _transformer) {
+        const callId = decodeNumber(buffer, 'Uint32');
+        this.endRpcStream(callId);
+    }
+    [ServerMessageType.RpcStreamAbort](buffer, _transport, _transformer) {
+        const callId = decodeNumber(buffer, 'Uint32');
+        this.abortRpcStream(callId);
+    }
+    [ServerMessageType.ServerStreamPush](buffer, transport, _transformer) {
+        const streamId = decodeNumber(buffer, 'Uint32');
+        const chunk = buffer.slice(Uint32Array.BYTES_PER_ELEMENT);
+        this.pushServerStream(streamId, chunk);
+        transport.send(ClientMessageType.ServerStreamPull, encodeNumber(streamId, 'Uint32'), { streamId });
+    }
+    [ServerMessageType.ServerStreamEnd](buffer, _transport, _transformer) {
+        const streamId = decodeNumber(buffer, 'Uint32');
+        this.endServerStream(streamId);
+    }
+    [ServerMessageType.ServerStreamAbort](buffer, _transport, _transformer) {
+        const streamId = decodeNumber(buffer, 'Uint32');
+        this.abortServerStream(streamId);
+    }
+    [ServerMessageType.ClientStreamPull](buffer, transport, _transformer) {
+        const streamId = decodeNumber(buffer, 'Uint32');
+        const size = decodeNumber(buffer, 'Uint32', Uint32Array.BYTES_PER_ELEMENT);
+        this.pullClientStream(streamId, size).then((chunk) => {
+            if (chunk) {
+                transport.send(ClientMessageType.ClientStreamPush, concat(encodeNumber(streamId, 'Uint32'), chunk), { streamId });
+            }
+            else {
+                transport.send(ClientMessageType.ClientStreamEnd, encodeNumber(streamId, 'Uint32'), { streamId });
+                this.endClientStream(streamId);
+            }
+        }, () => {
+            transport.send(ClientMessageType.ClientStreamAbort, encodeNumber(streamId, 'Uint32'), { streamId });
+        });
+    }
+    [ServerMessageType.ClientStreamAbort](buffer, _transport, _transformer) {
+        const streamId = decodeNumber(buffer, 'Uint32');
+        this.abortClientStream(streamId);
+    }
+}

package/dist/client/stream.d.ts

@@ -1,49 +1,31 @@
-import type { Callback, DuplexStreamOptions } from '@nmtjs/common';
-import { DuplexStream } from '@nmtjs/common';
 import type { ProtocolBlobInterface, ProtocolBlobMetadata } from '../common/blob.ts';
-import { kBlobKey } from '../common/constants.ts';
-export declare class ProtocolClientBlobStream extends DuplexStream<any, ArrayBufferView> implements ProtocolBlobInterface {
+import { BlobKey } from '../common/blob.ts';
+export declare class ProtocolClientBlobStream extends TransformStream<any, ArrayBuffer> implements ProtocolBlobInterface {
     #private;
     readonly source: ReadableStream;
     readonly id: number;
     readonly metadata: ProtocolBlobMetadata;
-    readonly [kBlobKey] = true;
+    readonly [BlobKey] = true;
     constructor(source: ReadableStream, id: number, metadata: ProtocolBlobMetadata);
-    abort(reason?: string): Promise<void>;
+    read(size: number): Promise<ArrayBuffer | null>;
+    abort(error?: Error): void;
     end(): Promise<void>;
-    read(size: number): Promise<Uint8Array<ArrayBufferLike> | null>;
 }
-export declare abstract class ProtocolServerStreamInterface<O = unknown> extends DuplexStream<O, ArrayBufferView> {
-    [Symbol.asyncIterator](): AsyncGenerator<Awaited<O>, void, unknown>;
+export interface ProtocolServerStreamInterface<T = any> {
+    [Symbol.asyncIterator](): AsyncGenerator<T>;
+    abort(error?: Error): void;
 }
-export declare class ProtocolServerStream<T = unknown> extends ProtocolServerStreamInterface<T> implements ProtocolServerStreamInterface<T> {
-}
-export declare class ProtocolServerRPCStream<T = unknown> extends ProtocolServerStream<T> {
-    createAsyncIterable(onDone: Callback): {
-        [Symbol.asyncIterator]: () => {
-            next(): Promise<IteratorResult<Awaited<T>, void>>;
-            return(value: any): Promise<IteratorResult<Awaited<T>, void>>;
-            throw(error: any): Promise<IteratorResult<Awaited<T>, void>>;
-        };
-    };
+export declare class ProtocolServerStream<T = any> extends TransformStream<any, T> implements ProtocolServerStreamInterface<T> {
+    #private;
+    constructor(options?: Transformer<any, T>);
+    [Symbol.asyncIterator](): AsyncGenerator<Awaited<T>, void, unknown>;
+    push(chunk: T): Promise<void>;
+    end(): Promise<void>;
+    abort(error?: Error): Promise<void>;
 }
-export declare class ProtocolServerBlobStream extends ProtocolServerStreamInterface<ArrayBufferView> implements ProtocolBlobInterface, Blob {
+export declare class ProtocolServerBlobStream extends ProtocolServerStream<ArrayBuffer> implements ProtocolBlobInterface {
+    readonly id: number;
     readonly metadata: ProtocolBlobMetadata;
-    readonly [kBlobKey] = true;
-    constructor(metadata: ProtocolBlobMetadata, options?: DuplexStreamOptions<ArrayBufferView, ArrayBufferView>);
-    get size(): number;
-    get type(): string;
-    text(): Promise<string>;
-    bytes(): Promise<Uint8Array<ArrayBuffer>>;
-    arrayBuffer(): Promise<ArrayBuffer>;
-    json<T = unknown>(): Promise<T>;
-    stream(): ReadableStream<Uint8Array<ArrayBuffer>>;
-    /**
-     * Throws an error
-     */
-    formData(): Promise<FormData>;
-    /**
-     * Throws an error
-     */
-    slice(): Blob;
+    readonly [BlobKey] = true;
+    constructor(id: number, metadata: ProtocolBlobMetadata, options?: Transformer<any, ArrayBuffer>);
 }

package/dist/client/stream.js

@@ -1,71 +1,38 @@
-import { DuplexStream } from '@nmtjs/common';
-import { concat, decodeText, encodeText } from '../common/binary.js';
-import { kBlobKey } from '../common/constants.js';
-export class ProtocolClientBlobStream extends DuplexStream {
+import { defer } from '@nmtjs/common';
+import { concat, encodeText } from "../common/binary.js";
+import { BlobKey } from "../common/blob.js";
+export class ProtocolClientBlobStream extends TransformStream {
     source;
     id;
     metadata;
-    [kBlobKey] = true;
+    [BlobKey] = true;
     #queue;
     #reader;
-    #sourceReader = null;
     constructor(source, id, metadata) {
-        let sourceReader = null;
         super({
             start: () => {
-                sourceReader = source.getReader();
+                defer(() => source.pipeThrough(this));
             },
-            pull: async (controller) => {
-                const { done, value } = await sourceReader.read();
-                if (done) {
-                    controller.close();
-                    return;
-                }
-                const chunk = value;
-                controller.enqueue(chunk instanceof Uint8Array
-                    ? chunk
-                    : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
-            },
-            transform: (chunk) => {
+            transform: (chunk, controller) => {
                 if (chunk instanceof ArrayBuffer) {
-                    return new Uint8Array(chunk);
+                    controller.enqueue(chunk);
                 }
                 else if (chunk instanceof Uint8Array) {
-                    return chunk;
+                    controller.enqueue(chunk.buffer);
                 }
                 else if (typeof chunk === 'string') {
-                    return encodeText(chunk);
+                    controller.enqueue(encodeText(chunk));
                 }
                 else {
                     throw new Error('Invalid chunk data type. Expected ArrayBuffer, Uint8Array, or string.');
                 }
             },
-            cancel: (reason) => {
-                // Use reader.cancel() if reader exists (stream is locked), otherwise source.cancel()
-                if (sourceReader) {
-                    sourceReader.cancel(reason);
-                }
-                else {
-                    source.cancel(reason);
-                }
-            },
         });
         this.source = source;
         this.id = id;
         this.metadata = metadata;
-        this.#queue = new Uint8Array(0);
+        this.#queue = new ArrayBuffer(0);
         this.#reader = this.readable.getReader();
-        this.#sourceReader = sourceReader;
-    }
-    async abort(reason = 'Stream aborted') {
-        await this.#reader.cancel(reason);
-        this.#reader.releaseLock();
-        this.#sourceReader?.releaseLock();
-    }
-    async end() {
-        // Release the reader lock when the stream is finished
-        this.#reader.releaseLock();
-        this.#sourceReader?.releaseLock();
     }
     async read(size) {
         while (this.#queue.byteLength < size) {
@@ -73,7 +40,7 @@ export class ProtocolClientBlobStream extends DuplexStream {
             if (done) {
                 if (this.#queue.byteLength > 0) {
                     const chunk = this.#queue;
-                    this.#queue = new Uint8Array(0);
+                    this.#queue = new ArrayBuffer(0);
                     return chunk;
                 }
                 return null;
@@ -81,110 +48,51 @@ export class ProtocolClientBlobStream extends DuplexStream {
             const buffer = value;
             this.#queue = concat(this.#queue, buffer);
         }
-        const chunk = this.#queue.subarray(0, size);
-        this.#queue = this.#queue.subarray(size);
+        const chunk = this.#queue.slice(0, size);
+        this.#queue = this.#queue.slice(size);
         return chunk;
     }
+    abort(error = new Error('Stream aborted')) {
+        this.#reader.cancel(error);
+        this.source.cancel(error);
+    }
+    end() {
+        return this.source.cancel('Stream ended');
+    }
 }
-export class ProtocolServerStreamInterface extends DuplexStream {
+export class ProtocolServerStream extends TransformStream {
+    #writer;
+    constructor(options) {
+        super(options);
+        this.#writer = this.writable.getWriter();
+    }
     async *[Symbol.asyncIterator]() {
         const reader = this.readable.getReader();
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (!done)
-                    yield value;
-                else
-                    break;
-            }
-        }
-        finally {
-            reader.releaseLock();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (!done)
+                yield value;
+            else
+                break;
         }
     }
-}
-export class ProtocolServerStream extends ProtocolServerStreamInterface {
-}
-export class ProtocolServerRPCStream extends ProtocolServerStream {
-    createAsyncIterable(onDone) {
-        return {
-            [Symbol.asyncIterator]: () => {
-                const iterator = this[Symbol.asyncIterator]();
-                return {
-                    async next() {
-                        const result = await iterator.next();
-                        if (result.done)
-                            onDone();
-                        return result;
-                    },
-                    async return(value) {
-                        onDone();
-                        return iterator.return?.(value) ?? { done: true, value };
-                    },
-                    async throw(error) {
-                        onDone();
-                        return iterator.throw?.(error) ?? Promise.reject(error);
-                    },
-                };
-            },
-        };
+    async push(chunk) {
+        await this.#writer.write(chunk);
+    }
+    async end() {
+        await this.#writer.close();
+    }
+    async abort(error = new Error('Stream aborted')) {
+        await this.#writer.abort(error);
     }
 }
-export class ProtocolServerBlobStream extends ProtocolServerStreamInterface {
+export class ProtocolServerBlobStream extends ProtocolServerStream {
+    id;
     metadata;
-    [kBlobKey] = true;
-    constructor(metadata, options) {
+    [BlobKey] = true;
+    constructor(id, metadata, options) {
         super(options);
+        this.id = id;
         this.metadata = metadata;
     }
-    get size() {
-        return this.metadata.size || Number.NaN;
-    }
-    get type() {
-        return this.metadata.type || 'application/octet-stream';
-    }
-    async text() {
-        const chunks = [];
-        for await (const chunk of this)
-            chunks.push(chunk);
-        return decodeText(concat(...chunks));
-    }
-    async bytes() {
-        const chunks = [];
-        for await (const chunk of this)
-            chunks.push(chunk);
-        return concat(...chunks);
-    }
-    async arrayBuffer() {
-        const bytes = await this.bytes();
-        return bytes.buffer;
-    }
-    async json() {
-        const text = await this.text();
-        return JSON.parse(text);
-    }
-    stream() {
-        const transform = new TransformStream({
-            transform: (chunk, controller) => {
-                controller.enqueue(chunk instanceof Uint8Array
-                    ? chunk
-                    : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
-            },
-        });
-        this.readable.pipeThrough(transform);
-        return transform.readable;
-    }
-    /**
-     * Throws an error
-     */
-    async formData() {
-        throw new Error('Method not implemented.');
-    }
-    /**
-     * Throws an error
-     */
-    slice() {
-        throw new Error('Unable to slice');
-    }
 }
-//# sourceMappingURL=stream.js.map

package/dist/common/binary.d.ts

@@ -1,3 +1,4 @@
+declare const utf8decoder: TextDecoder;
 export type BinaryTypes = {
     Int8: number;
     Int16: number;
@@ -11,8 +12,8 @@ export type BinaryTypes = {
     BigUint64: bigint;
 };
 export declare const encodeNumber: <T extends keyof BinaryTypes>(value: BinaryTypes[T], type: T, littleEndian?: boolean) => ArrayBuffer;
-export declare const decodeNumber: <T extends keyof BinaryTypes>(buffer: ArrayBuffer | ArrayBufferView<ArrayBufferLike>, type: T, offset?: number, littleEndian?: boolean) => BinaryTypes[T];
-export declare const encodeText: (text: string) => Uint8Array<ArrayBuffer>;
-export declare const decodeText: (buffer: AllowSharedBufferSource | undefined) => string;
-export declare const concat: (...buffers: (ArrayBuffer | ArrayBufferView<ArrayBufferLike>)[]) => Uint8Array<ArrayBuffer>;
-export declare const UTF8Transform: () => TransformStream<string, Uint8Array<ArrayBufferLike>>;
+export declare const decodeNumber: <T extends keyof BinaryTypes>(buffer: ArrayBuffer, type: T, offset?: number, littleEndian?: boolean) => BinaryTypes[T];
+export declare const encodeText: (text: string) => ArrayBuffer;
+export declare const decodeText: (buffer: Parameters<typeof utf8decoder.decode>[0]) => string;
+export declare const concat: (...buffers: ArrayBuffer[]) => ArrayBuffer;
+export {};