apache-iggy 0.5.0-edge.1

package/dist/src/client/client.connection.js

@@ -0,0 +1,171 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { EventEmitter } from 'node:events';
+import { createConnection } from 'node:net';
+import { connect as TLSConnect } from 'node:tls';
+import { serializeCommand } from './client.utils.js';
+import { debug } from './client.debug.js';
+const createTcpSocket = (options) => {
+    return createConnection(options);
+};
+const createTlsSocket = ({ port, ...options }) => {
+    const socket = TLSConnect(port, options);
+    return socket;
+};
+const getTransport = (config) => {
+    const { transport, options } = config;
+    switch (transport) {
+        case 'TLS': return createTlsSocket(options);
+        case 'TCP':
+        default:
+            return createTcpSocket(options);
+    }
+};
+const DefaultReconnectOption = {
+    enabled: true,
+    interval: 5 * 1000,
+    maxRetries: 12
+};
+function recreate(option, timer = 1000) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve(getTransport(option));
+        }, timer);
+    });
+}
+export class IggyConnection extends EventEmitter {
+    config;
+    socket;
+    connected;
+    connecting;
+    ending;
+    waitingResponseEnd;
+    reconnectOption;
+    reconnectCount;
+    readBuffers;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.socket = getTransport(config);
+        this.connected = false;
+        this.connecting = false;
+        this.ending = false;
+        this.waitingResponseEnd = false;
+        this.reconnectOption = { ...DefaultReconnectOption, ...config.reconnect };
+        this.reconnectCount = 0;
+        this.readBuffers = Buffer.allocUnsafe(0);
+    }
+    connect() {
+        this.connecting = true;
+        this.socket.on('data', this._onData.bind(this));
+        this.socket.on('error', async (err) => {
+            debug('socket/error event', err, err.code, this.ending);
+            // errors about disconnections should be ignored during disconnect
+            if (this.ending && (err?.code === 'ECONNRESET' || err?.code === 'EPIPE'))
+                return;
+            this.reconnect(err);
+        });
+        this.socket.once('end', async (hadError) => {
+            debug('socket/close#END event', hadError);
+            this.connected = false;
+            this.emit('disconnected', hadError);
+            this.reconnect();
+        });
+        return new Promise((resolve /**, reject*/) => {
+            this.socket.once('connect', () => {
+                debug('socket/connect event');
+                this.connected = true;
+                this.connecting = false;
+                this.reconnectCount = 0;
+                this.emit('connect');
+                resolve(this);
+            });
+        });
+    }
+    async reconnect(err) {
+        const { enabled, interval, maxRetries } = this.reconnectOption;
+        debug('reconnect# event/reconnect?', {
+            reconnect: { enabled, interval, maxRetries },
+            count: this.reconnectCount,
+            lastError: err
+        });
+        if (!enabled || this.reconnectCount > maxRetries) {
+            debug(`reconnect reached maxRetries of ${maxRetries}`, err);
+            return this.emit('error', new Error(`reconnect maxRetries exceeded (count: ${this.reconnectCount})`, { cause: err }));
+        }
+        /** recreate socket */
+        this.connecting = true;
+        this.reconnectCount += 1;
+        this.socket = await recreate(this.config, interval);
+        this.connect();
+    }
+    _destroy() {
+        this.ending = true;
+        this.socket.destroy();
+    }
+    _endResponseWait() {
+        this.readBuffers = Buffer.allocUnsafe(0);
+        this.waitingResponseEnd = false;
+    }
+    _onData(data) {
+        debug('ONDATA', typeof data, Buffer.isBuffer(data), data?.length, this.waitingResponseEnd);
+        if (this.waitingResponseEnd) {
+            data = Buffer.concat([this.readBuffers, data]);
+        }
+        if (data.length < 8) {
+            this.socket.unshift(data);
+            return;
+        }
+        /**
+         * data[0:4] hold response status code
+         * const status = data.readUInt32LE(0);
+         * data[4:8] hold response length
+         */
+        const responseSize = data.readUInt32LE(4);
+        /** response is just head, no payload */
+        if (responseSize === 0 && data.length === 8) {
+            this.emit('response', data);
+            return;
+        }
+        const payloadLength = data.length - 8;
+        /** payload is complete */
+        if (payloadLength === responseSize) {
+            this.emit('response', data);
+            this._endResponseWait();
+            return;
+        }
+        /** payload is incomplete, buffering until next data event */
+        if (payloadLength < responseSize) {
+            this.waitingResponseEnd = true;
+            this.readBuffers = data;
+            return;
+        }
+        /** payload is bigger than expected, cut response and unshift extra data  */
+        if (payloadLength > responseSize) {
+            this.emit('response', data.subarray(0, 8 + responseSize));
+            this._endResponseWait();
+            this.socket.unshift(data.subarray(8 + responseSize));
+        }
+    }
+    writeCommand(command, payload) {
+        const cmd = serializeCommand(command, payload);
+        return this.socket.write(cmd);
+    }
+}
+//# sourceMappingURL=client.connection.js.map

package/dist/src/client/client.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { type Pool } from 'generic-pool';
+import type { RawClient, ClientConfig } from "./client.type.js";
+import { CommandAPI } from '../wire/command-set.js';
+export declare class Client extends CommandAPI {
+    _config: ClientConfig;
+    _pool: Pool<RawClient>;
+    constructor(config: ClientConfig);
+    destroy(): Promise<void>;
+}
+export declare class SingleClient extends CommandAPI {
+    _config: ClientConfig;
+    constructor(config: ClientConfig);
+    destroy(): Promise<void>;
+}
+export declare class SimpleClient extends CommandAPI {
+    constructor(client: RawClient);
+    destroy(): Promise<void>;
+}
+export declare const getClient: (config: ClientConfig) => Promise<SimpleClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/src/client/client.debug.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import Debug from 'debug';
+export declare const debug: Debug.Debugger;
+//# sourceMappingURL=client.debug.d.ts.map

package/dist/src/client/client.debug.js

@@ -0,0 +1,21 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import Debug from 'debug';
+export const debug = Debug('iggy:client');
+//# sourceMappingURL=client.debug.js.map

package/dist/src/client/client.js

@@ -0,0 +1,97 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { createPool } from 'generic-pool';
+import { getRawClient } from '../client/client.socket.js';
+import { CommandAPI } from '../wire/command-set.js';
+import { debug } from './client.debug.js';
+// create & destroy must be async
+const createPoolFactory = (config) => ({
+    create: async function () {
+        return getRawClient(config);
+    },
+    destroy: async function (client) {
+        return client.destroy();
+    }
+});
+const poolClientProvider = (config) => {
+    const min = config.poolSize?.min || 1;
+    const max = config.poolSize?.max || 4;
+    const pool = createPool(createPoolFactory(config), { min, max });
+    const poolClientProvider = async () => {
+        const c = await pool.acquire();
+        debug('client acquired from pool. pool size is', pool.size);
+        c.once('finishQueue', () => {
+            pool.release(c);
+            debug('client released to pool. pool size is', pool.size);
+        });
+        return c;
+    };
+    poolClientProvider._pool = pool;
+    return poolClientProvider;
+};
+export class Client extends CommandAPI {
+    _config;
+    _pool;
+    constructor(config) {
+        const pcp = poolClientProvider(config);
+        super(pcp);
+        this._config = config;
+        this._pool = pcp._pool;
+    }
+    ;
+    async destroy() {
+        debug('destroying client pool. pool size is', this._pool.size);
+        await this._pool.drain();
+        await this._pool.clear();
+        debug('destroyed client pool. pool size is', this._pool.size);
+    }
+}
+const singleClientProvider = (config) => {
+    const c = getRawClient(config);
+    return async function singleClientProvider() {
+        return c;
+    };
+};
+export class SingleClient extends CommandAPI {
+    _config;
+    constructor(config) {
+        super(singleClientProvider(config));
+        this._config = config;
+    }
+    async destroy() {
+        const s = await this.clientProvider();
+        s.destroy();
+    }
+}
+;
+export class SimpleClient extends CommandAPI {
+    constructor(client) {
+        super(() => Promise.resolve(client));
+    }
+    async destroy() {
+        const s = await this.clientProvider();
+        s.destroy();
+    }
+}
+;
+export const getClient = async (config) => {
+    const cli = getRawClient(config);
+    return new SimpleClient(cli);
+};
+//# sourceMappingURL=client.js.map

package/dist/src/client/client.socket.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { EventEmitter } from 'node:events';
+import type { ClientConfig, ClientCredentials, CommandResponse, PasswordCredentials, RawClient, TokenCredentials } from '../client/client.type.js';
+export declare class CommandResponseStream extends EventEmitter {
+    private options;
+    private connection;
+    private _execQueue;
+    busy: boolean;
+    isAuthenticated: boolean;
+    userId?: number;
+    heartbeatIntervalHandler?: NodeJS.Timeout;
+    constructor(options: ClientConfig);
+    _init(): void;
+    sendCommand(command: number, payload: Buffer, handleResponse?: boolean, last?: boolean): Promise<CommandResponse>;
+    _processQueue(handleResponse?: boolean): Promise<void>;
+    _processNext(command: number, payload: Buffer, handleResp?: boolean): Promise<CommandResponse>;
+    _failQueue(err: Error): void;
+    authenticate(creds: ClientCredentials): Promise<boolean>;
+    _authWithPassword(creds: PasswordCredentials): Promise<{
+        userId: number;
+    }>;
+    _authWithToken(creds: TokenCredentials): Promise<{
+        userId: number;
+    }>;
+    ping(): Promise<boolean>;
+    heartbeat(interval?: number): void;
+    getReadStream(): import("net").Socket;
+    destroy(): void;
+}
+export declare function getRawClient(options: ClientConfig): RawClient;
+//# sourceMappingURL=client.socket.d.ts.map

package/dist/src/client/client.socket.js

@@ -0,0 +1,156 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { EventEmitter } from 'node:events';
+import { handleResponse } from './client.utils.js';
+import { responseError } from '../wire/error.utils.js';
+import { debug } from './client.debug.js';
+import { IggyConnection } from './client.connection.js';
+import { LOGIN, LOGIN_WITH_TOKEN, PING } from '../wire/index.js';
+const UNLOGGED_COMMAND_CODE = [
+    PING.code,
+    LOGIN.code,
+    LOGIN_WITH_TOKEN.code
+];
+export class CommandResponseStream extends EventEmitter {
+    options;
+    connection;
+    _execQueue;
+    busy;
+    isAuthenticated;
+    userId;
+    heartbeatIntervalHandler;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.connection = new IggyConnection(options);
+        this.busy = false;
+        this.isAuthenticated = false;
+        this._execQueue = [];
+        this._init();
+    }
+    ;
+    _init() {
+        this.heartbeat(this.options.heartbeatInterval);
+        this.connection.on('disconnected', async () => {
+            this.isAuthenticated = false;
+        });
+    }
+    async sendCommand(command, payload, handleResponse = true, last = true) {
+        if (!this.connection.connected)
+            await this.connection.connect();
+        if (!this.isAuthenticated && !UNLOGGED_COMMAND_CODE.includes(command))
+            await this.authenticate(this.options.credentials);
+        return new Promise(async (resolve, reject) => {
+            if (last)
+                this._execQueue.push({ command, payload, resolve, reject });
+            else
+                this._execQueue.unshift({ command, payload, resolve, reject });
+            this._processQueue(handleResponse);
+        });
+    }
+    async _processQueue(handleResponse = true) {
+        if (this.busy)
+            return;
+        this.busy = true;
+        while (this._execQueue.length > 0 && this.connection.socket.writable) {
+            const next = this._execQueue.shift();
+            if (!next)
+                break;
+            const { command, payload, resolve, reject } = next;
+            try {
+                resolve(await this._processNext(command, payload, handleResponse));
+            }
+            catch (err) {
+                reject(err);
+            }
+        }
+        this.busy = false;
+        this.emit('finishQueue');
+    }
+    _processNext(command, payload, handleResp = true) {
+        const lastWrite = this.connection.writeCommand(command, payload);
+        debug('==> writeCommand', lastWrite);
+        return new Promise((resolve, reject) => {
+            if (!lastWrite)
+                return reject(new Error('failed to write to socket'));
+            const errCb = (err) => reject(err);
+            this.connection.once('error', errCb);
+            this.connection.once('response', (resp) => {
+                this.connection.removeListener('error', errCb);
+                if (!handleResp)
+                    return resolve(resp);
+                const r = handleResponse(resp);
+                if (r.status !== 0) {
+                    return reject(responseError(command, r.status));
+                }
+                return resolve(r);
+            });
+        });
+    }
+    _failQueue(err) {
+        this._execQueue.forEach(({ reject }) => reject(err));
+        this._execQueue = [];
+    }
+    async authenticate(creds) {
+        const r = ('token' in creds) ?
+            await this._authWithToken(creds) :
+            await this._authWithPassword(creds);
+        this.isAuthenticated = true;
+        this.userId = r.userId;
+        return this.isAuthenticated;
+    }
+    async _authWithPassword(creds) {
+        const pl = LOGIN.serialize(creds);
+        const logr = await this.sendCommand(LOGIN.code, pl, true, false);
+        return LOGIN.deserialize(logr);
+    }
+    async _authWithToken(creds) {
+        const pl = LOGIN_WITH_TOKEN.serialize(creds);
+        const logr = await this.sendCommand(LOGIN_WITH_TOKEN.code, pl, true, false);
+        return LOGIN_WITH_TOKEN.deserialize(logr);
+    }
+    async ping() {
+        const pl = PING.serialize();
+        const pingR = await this.sendCommand(PING.code, pl, true);
+        return PING.deserialize(pingR);
+    }
+    heartbeat(interval) {
+        if (!interval)
+            return;
+        this.heartbeatIntervalHandler = setInterval(async () => {
+            if (this.connection.connected) {
+                debug(`sending hearbeat ping (interval: ${interval} ms)`);
+                await this.ping();
+            }
+        }, interval);
+    }
+    getReadStream() {
+        return this.connection.socket;
+    }
+    destroy() {
+        if (this.heartbeatIntervalHandler)
+            clearInterval(this.heartbeatIntervalHandler);
+        return this.connection._destroy();
+    }
+}
+;
+export function getRawClient(options) {
+    return new CommandResponseStream(options);
+}
+//# sourceMappingURL=client.socket.js.map

package/dist/src/client/client.type.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import type { Readable } from 'stream';
+import { type TcpSocketConnectOpts } from 'node:net';
+import { type ConnectionOptions } from 'node:tls';
+export type TcpOption = TcpSocketConnectOpts;
+export type TlsOption = {
+    port: number;
+} & ConnectionOptions;
+export type CommandResponse = {
+    status: number;
+    length: number;
+    data: Buffer;
+};
+export type RawClient = {
+    sendCommand: (code: number, payload: Buffer, handleResponse?: boolean) => Promise<CommandResponse>;
+    isAuthenticated: boolean;
+    authenticate: (c: ClientCredentials) => Promise<boolean>;
+    destroy: () => void;
+    on: (ev: string, cb: (e?: unknown) => void) => void;
+    once: (ev: string, cb: (e?: unknown) => void) => void;
+    getReadStream: () => Readable;
+};
+export type ClientProvider = () => Promise<RawClient>;
+export declare const Transports: readonly ["TCP", "TLS"];
+export type TransportType = typeof Transports[number];
+export type ReconnectOption = {
+    enabled: boolean;
+    interval: number;
+    maxRetries: number;
+};
+export type TransportOption = TcpOption | TlsOption;
+export type TokenCredentials = {
+    token: string;
+};
+export type PasswordCredentials = {
+    username: string;
+    password: string;
+};
+export type ClientCredentials = TokenCredentials | PasswordCredentials;
+export type PoolSizeOption = {
+    min?: number;
+    max?: number;
+};
+export type ClientConfig = {
+    transport: TransportType;
+    options: TransportOption;
+    credentials: ClientCredentials;
+    poolSize?: PoolSizeOption;
+    reconnect?: ReconnectOption;
+    heartbeatInterval?: number;
+};
+//# sourceMappingURL=client.type.d.ts.map

package/dist/src/client/client.type.js

@@ -0,0 +1,20 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export const Transports = ['TCP', 'TLS' /**, 'QUIC' */];
+//# sourceMappingURL=client.type.js.map

package/dist/src/client/client.utils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Transform } from 'node:stream';
+import type { CommandResponse } from './client.type.js';
+export declare const handleResponse: (r: Buffer) => {
+    status: number;
+    length: number;
+    data: Buffer<ArrayBufferLike>;
+};
+export declare const handleResponseTransform: () => Transform;
+export declare const deserializeVoidResponse: (r: CommandResponse) => boolean;
+export declare const serializeCommand: (command: number, payload: Buffer) => Buffer<ArrayBuffer>;
+//# sourceMappingURL=client.utils.d.ts.map