pi-cursor-sdk 0.1.50 → 0.1.51

package/node_modules/@connectrpc/connect-node/dist/esm/node-universal-client.js

@@ -1,324 +0,0 @@
-// Copyright 2021-2024 The Connect Authors
-//
-// Licensed 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 * as http2 from "http2";
-import * as http from "http";
-import * as https from "https";
-import { Code, ConnectError } from "@connectrpc/connect";
-import { nodeHeaderToWebHeader, webHeaderToNodeHeaders, } from "./node-universal-header.js";
-import { connectErrorFromH2ResetCode, connectErrorFromNodeReason, getNodeErrorProps, H2Code, unwrapNodeErrorChain, } from "./node-error.js";
-import { getAbortSignalReason } from "@connectrpc/connect/protocol";
-import { Http2SessionManager } from "./http2-session-manager.js";
-/**
- * Create a universal client function, a minimal abstraction of an HTTP client,
- * using the Node.js `http`, `https`, or `http2` module.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export function createNodeHttpClient(options) {
-    var _a;
-    if (options.httpVersion == "1.1") {
-        return createNodeHttp1Client(options.nodeOptions);
-    }
-    const sessionProvider = (_a = options.sessionProvider) !== null && _a !== void 0 ? _a : ((url) => new Http2SessionManager(url));
-    return createNodeHttp2Client(sessionProvider);
-}
-/**
- * Create an HTTP client using the Node.js `http` or `https` package.
- *
- * The HTTP client is a simple function conforming to the type UniversalClientFn.
- * It takes an UniversalClientRequest as an argument, and returns a promise for
- * an UniversalClientResponse.
- */
-function createNodeHttp1Client(httpOptions) {
-    return async function request(req) {
-        const sentinel = createSentinel(req.signal);
-        return new Promise((resolve, reject) => {
-            sentinel.catch((e) => {
-                reject(e);
-            });
-            h1Request(sentinel, req.url, Object.assign(Object.assign({}, httpOptions), { headers: webHeaderToNodeHeaders(req.header, httpOptions === null || httpOptions === void 0 ? void 0 : httpOptions.headers), method: req.method }), (request) => {
-                void sinkRequest(req, request, sentinel);
-                request.on("response", (response) => {
-                    var _a;
-                    response.on("error", sentinel.reject);
-                    sentinel.catch((reason) => response.destroy(connectErrorFromNodeReason(reason)));
-                    const trailer = new Headers();
-                    resolve({
-                        status: (_a = response.statusCode) !== null && _a !== void 0 ? _a : 0,
-                        header: nodeHeaderToWebHeader(response.headers),
-                        body: h1ResponseIterable(sentinel, response, trailer),
-                        trailer,
-                    });
-                });
-            });
-        });
-    };
-}
-/**
- * Create an HTTP client using the Node.js `http2` package.
- *
- * The HTTP client is a simple function conforming to the type UniversalClientFn.
- * It takes an UniversalClientRequest as an argument, and returns a promise for
- * an UniversalClientResponse.
- */
-function createNodeHttp2Client(sessionProvider) {
-    return function request(req) {
-        const sentinel = createSentinel(req.signal);
-        const sessionManager = sessionProvider(req.url);
-        return new Promise((resolve, reject) => {
-            sentinel.catch((e) => {
-                reject(e);
-            });
-            h2Request(sentinel, sessionManager, req.url, req.method, webHeaderToNodeHeaders(req.header), {}, (stream) => {
-                void sinkRequest(req, stream, sentinel);
-                stream.on("response", (headers) => {
-                    var _a;
-                    const response = {
-                        status: (_a = headers[":status"]) !== null && _a !== void 0 ? _a : 0,
-                        header: nodeHeaderToWebHeader(headers),
-                        body: h2ResponseIterable(sentinel, stream, sessionManager),
-                        trailer: h2ResponseTrailer(stream),
-                    };
-                    resolve(response);
-                });
-            });
-        });
-    };
-}
-function h1Request(sentinel, url, options, onRequest) {
-    let request;
-    if (new URL(url).protocol.startsWith("https")) {
-        request = https.request(url, options);
-    }
-    else {
-        request = http.request(url, options);
-    }
-    sentinel.catch((reason) => request.destroy(connectErrorFromNodeReason(reason)));
-    // Node.js will only send headers with the first request body byte by default.
-    // We force it to send headers right away for consistent behavior between
-    // HTTP/1.1 and HTTP/2.2 clients.
-    request.flushHeaders();
-    request.on("error", sentinel.reject);
-    request.on("socket", function onRequestSocket(socket) {
-        function onSocketConnect() {
-            socket.off("connect", onSocketConnect);
-            onRequest(request);
-        }
-        // If readyState is open, then socket is already open due to keepAlive, so
-        // the 'connect' event will never fire so call onRequest explicitly
-        if (socket.readyState === "open") {
-            onRequest(request);
-        }
-        else {
-            socket.on("connect", onSocketConnect);
-        }
-    });
-}
-function h1ResponseIterable(sentinel, response, trailer) {
-    const inner = response[Symbol.asyncIterator]();
-    return {
-        [Symbol.asyncIterator]() {
-            return {
-                async next() {
-                    const r = await sentinel.race(inner.next());
-                    if (r.done === true) {
-                        nodeHeaderToWebHeader(response.trailers).forEach((value, key) => {
-                            trailer.set(key, value);
-                        });
-                        sentinel.resolve();
-                        await sentinel;
-                    }
-                    return r;
-                },
-                throw(e) {
-                    sentinel.reject(e);
-                    throw e;
-                },
-            };
-        },
-    };
-}
-function h2Request(sentinel, sm, url, method, headers, options, onStream) {
-    const requestUrl = new URL(url);
-    if (requestUrl.origin !== sm.authority) {
-        const message = `cannot make a request to ${requestUrl.origin}: the http2 session is connected to ${sm.authority}`;
-        sentinel.reject(new ConnectError(message, Code.Internal));
-        return;
-    }
-    sm.request(method, requestUrl.pathname + requestUrl.search, headers, {}).then((stream) => {
-        sentinel.catch((reason) => {
-            if (stream.closed) {
-                return;
-            }
-            // Node.js http2 streams that are aborted via an AbortSignal close with
-            // an RST_STREAM with code INTERNAL_ERROR.
-            // To comply with the mapping between gRPC and HTTP/2 codes, we need to
-            // close with code CANCEL.
-            // See https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#errors
-            // See https://www.rfc-editor.org/rfc/rfc7540#section-7
-            const rstCode = reason instanceof ConnectError && reason.code == Code.Canceled
-                ? H2Code.CANCEL
-                : H2Code.INTERNAL_ERROR;
-            return new Promise((resolve) => stream.close(rstCode, resolve));
-        });
-        stream.on("error", function h2StreamError(e) {
-            if (stream.writableEnded &&
-                unwrapNodeErrorChain(e)
-                    .map(getNodeErrorProps)
-                    .some((p) => p.code == "ERR_STREAM_WRITE_AFTER_END")) {
-                return;
-            }
-            sentinel.reject(e);
-        });
-        stream.on("close", function h2StreamClose() {
-            const err = connectErrorFromH2ResetCode(stream.rstCode);
-            if (err) {
-                sentinel.reject(err);
-            }
-        });
-        onStream(stream);
-    }, (reason) => {
-        sentinel.reject(reason);
-    });
-}
-function h2ResponseTrailer(response) {
-    const trailer = new Headers();
-    response.on("trailers", (args) => {
-        nodeHeaderToWebHeader(args).forEach((value, key) => {
-            trailer.set(key, value);
-        });
-    });
-    return trailer;
-}
-function h2ResponseIterable(sentinel, response, sm) {
-    const inner = response[Symbol.asyncIterator]();
-    return {
-        [Symbol.asyncIterator]() {
-            return {
-                async next() {
-                    const r = await sentinel.race(inner.next());
-                    if (r.done === true) {
-                        sentinel.resolve();
-                        await sentinel;
-                    }
-                    sm === null || sm === void 0 ? void 0 : sm.notifyResponseByteRead(response);
-                    return r;
-                },
-                throw(e) {
-                    sentinel.reject(e);
-                    throw e;
-                },
-            };
-        },
-    };
-}
-async function sinkRequest(request, nodeRequest, sentinel) {
-    if (request.body === undefined) {
-        await new Promise((resolve) => nodeRequest.end(resolve));
-        return;
-    }
-    const it = request.body[Symbol.asyncIterator]();
-    return new Promise((resolve) => {
-        writeNext();
-        function writeNext() {
-            if (sentinel.isRejected()) {
-                return;
-            }
-            it.next().then((r) => {
-                if (r.done === true) {
-                    nodeRequest.end(resolve);
-                    return;
-                }
-                nodeRequest.write(r.value, "binary", function (e) {
-                    if (e === null || e === undefined) {
-                        writeNext();
-                        return;
-                    }
-                    if (it.throw !== undefined) {
-                        it.throw(connectErrorFromNodeReason(e)).catch(() => {
-                            //
-                        });
-                    }
-                    // If the server responds and closes the connection before the client has written the entire response
-                    // body, we get an ERR_STREAM_WRITE_AFTER_END error code from Node.js here.
-                    // We do want to notify the iterable of the error condition, but we do not want to reject our sentinel,
-                    // because that would also affect the reading side.
-                    if (nodeRequest.writableEnded &&
-                        unwrapNodeErrorChain(e)
-                            .map(getNodeErrorProps)
-                            .some((p) => p.code == "ERR_STREAM_WRITE_AFTER_END")) {
-                        return;
-                    }
-                    sentinel.reject(e);
-                });
-            }, (e) => {
-                sentinel.reject(e);
-            });
-        }
-    });
-}
-function createSentinel(signal) {
-    let res;
-    let rej;
-    let resolved = false;
-    let rejected = false;
-    const p = new Promise((resolve, reject) => {
-        res = resolve;
-        rej = reject;
-    });
-    const c = {
-        resolve() {
-            if (!resolved && !rejected) {
-                resolved = true;
-                res === null || res === void 0 ? void 0 : res();
-            }
-        },
-        isResolved() {
-            return resolved;
-        },
-        reject(reason) {
-            if (!resolved && !rejected) {
-                rejected = true;
-                rej === null || rej === void 0 ? void 0 : rej(connectErrorFromNodeReason(reason));
-            }
-        },
-        isRejected() {
-            return rejected;
-        },
-        async race(promise) {
-            const r = await Promise.race([promise, p]);
-            if (r === undefined && resolved) {
-                throw new ConnectError("sentinel completed early", Code.Internal);
-            }
-            return r;
-        },
-    };
-    const s = Object.assign(p, c);
-    function onSignalAbort() {
-        c.reject(getAbortSignalReason(this));
-    }
-    if (signal) {
-        if (signal.aborted) {
-            c.reject(getAbortSignalReason(signal));
-        }
-        else {
-            signal.addEventListener("abort", onSignalAbort);
-        }
-        p.finally(() => signal.removeEventListener("abort", onSignalAbort)).catch(() => {
-            // We intentionally swallow sentinel rejection - errors must
-            // propagate through the request or response iterables.
-        });
-    }
-    return s;
-}

package/node_modules/@connectrpc/connect-node/dist/esm/node-universal-handler.d.ts

@@ -1,41 +0,0 @@
-import type * as http from "http";
-import type * as http2 from "http2";
-import type { JsonValue } from "@bufbuild/protobuf";
-import type { UniversalServerRequest, UniversalServerResponse } from "@connectrpc/connect/protocol";
-import type { ContextValues } from "@connectrpc/connect";
-/**
- * NodeHandlerFn is compatible with http.RequestListener and its equivalent
- * for http2.
- */
-export type NodeHandlerFn = (request: NodeServerRequest, response: NodeServerResponse) => void;
-/**
- * A Node.js server request from the http, https, or the http2 module.
- */
-export type NodeServerRequest = http.IncomingMessage | http2.Http2ServerRequest;
-/**
- * A Node.js server response from the http, https, or the http2 module.
- * Note that we are taking the liberty to patch the type of write() so
- * that they are compatible with each other.
- */
-export type NodeServerResponse = (Omit<http.ServerResponse, "write"> | Omit<http2.Http2ServerResponse, "write">) & {
-    write(chunk: string | Uint8Array, callback?: (err: Error | null | undefined) => void): boolean;
-    write(chunk: string | Uint8Array, encoding: BufferEncoding, callback?: (err: Error | null | undefined) => void): boolean;
-};
-/**
- * Converts a Node.js server request to a UniversalServerRequest.
- * This function helps to implement adapters to server frameworks running
- * on Node.js. Please be careful using this function in your own code, as we
- * may have to make changes to it in the future.
- */
-export declare function universalRequestFromNodeRequest(nodeRequest: NodeServerRequest, nodeResponse: NodeServerResponse, parsedJsonBody: JsonValue | undefined, contextValues: ContextValues | undefined): UniversalServerRequest;
-/**
- * @deprecated
- */
-export declare function universalRequestFromNodeRequest(nodeRequest: NodeServerRequest, parsedJsonBody: JsonValue | undefined, contextValues: ContextValues | undefined): UniversalServerRequest;
-/**
- * Writes a UniversalServerResponse to a Node.js server response.
- * This function helps to implement adapters to server frameworks running
- * on Node.js. Please be careful using this function in your own code, as we
- * may have to make changes to it in the future.
- */
-export declare function universalResponseToNodeResponse(universalResponse: UniversalServerResponse, nodeResponse: NodeServerResponse): Promise<void>;

package/node_modules/@connectrpc/connect-node/dist/esm/node-universal-handler.js

@@ -1,230 +0,0 @@
-// Copyright 2021-2024 The Connect Authors
-//
-// Licensed 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.
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-import { Code, ConnectError } from "@connectrpc/connect";
-import { nodeHeaderToWebHeader, webHeaderToNodeHeaders, } from "./node-universal-header.js";
-import { connectErrorFromH2ResetCode, connectErrorFromNodeReason, } from "./node-error.js";
-export function universalRequestFromNodeRequest(nodeRequest, ...rest) {
-    var _a, _b;
-    const nodeResponse = rest.length === 3 ? rest[0] : undefined;
-    const parsedJsonBody = rest.length === 3 ? rest[1] : rest[0];
-    const contextValues = rest.length === 3 ? rest[2] : rest[1];
-    const encrypted = "encrypted" in nodeRequest.socket && nodeRequest.socket.encrypted;
-    const protocol = encrypted ? "https" : "http";
-    const authority = "authority" in nodeRequest
-        ? nodeRequest.authority
-        : nodeRequest.headers.host;
-    const pathname = (_a = nodeRequest.url) !== null && _a !== void 0 ? _a : "";
-    if (authority === undefined) {
-        throw new ConnectError("unable to determine request authority from Node.js server request", Code.Internal);
-    }
-    const body = parsedJsonBody !== undefined
-        ? parsedJsonBody
-        : asyncIterableFromNodeServerRequest(nodeRequest);
-    const abortController = new AbortController();
-    if ("stream" in nodeRequest) {
-        // HTTP/2 has error codes we want to honor
-        nodeRequest.once("close", () => {
-            const err = connectErrorFromH2ResetCode(nodeRequest.stream.rstCode);
-            if (err !== undefined) {
-                abortController.abort(err);
-            }
-            else {
-                abortController.abort();
-            }
-        });
-    }
-    else {
-        // HTTP/1.1 does not have error codes, but Node.js has ECONNRESET
-        const nodeResponsOrRequest = nodeResponse !== null && nodeResponse !== void 0 ? nodeResponse : nodeRequest;
-        const onH1Error = (e) => {
-            nodeRequest.off("error", onH1Error);
-            nodeResponsOrRequest.off("close", onH1Close);
-            abortController.abort(connectErrorFromNodeReason(e));
-        };
-        const onH1Close = () => {
-            nodeRequest.off("error", onH1Error);
-            nodeResponsOrRequest.off("close", onH1Close);
-            // When subscribed to the response, this can get called before "error"
-            abortController.abort(nodeRequest.errored
-                ? connectErrorFromNodeReason(nodeRequest.errored)
-                : undefined);
-        };
-        nodeRequest.once("error", onH1Error);
-        // Node emits close on the request as soon as all data is read.
-        // We instead subscribe to the response (if available)
-        //
-        // Ref: https://github.com/nodejs/node/issues/40775
-        nodeResponsOrRequest.once("close", onH1Close);
-    }
-    return {
-        httpVersion: nodeRequest.httpVersion,
-        method: (_b = nodeRequest.method) !== null && _b !== void 0 ? _b : "",
-        url: new URL(pathname, `${protocol}://${authority}`).toString(),
-        header: nodeHeaderToWebHeader(nodeRequest.headers),
-        body,
-        signal: abortController.signal,
-        contextValues: contextValues,
-    };
-}
-/**
- * Writes a UniversalServerResponse to a Node.js server response.
- * This function helps to implement adapters to server frameworks running
- * on Node.js. Please be careful using this function in your own code, as we
- * may have to make changes to it in the future.
- */
-export async function universalResponseToNodeResponse(universalResponse, nodeResponse) {
-    var _a, _b, _c;
-    const it = (_a = universalResponse.body) === null || _a === void 0 ? void 0 : _a[Symbol.asyncIterator]();
-    let isWriteError = false;
-    try {
-        if (it !== undefined) {
-            let chunk = await it.next();
-            isWriteError = true;
-            // we deliberately send headers after first read, not before,
-            // because we have to give the implementation a chance to
-            // set response headers
-            nodeResponse.writeHead(universalResponse.status, webHeaderToNodeHeaders(universalResponse.header));
-            isWriteError = false;
-            for (; chunk.done !== true; chunk = await it.next()) {
-                isWriteError = true;
-                await write(nodeResponse, chunk.value);
-                if ("flush" in nodeResponse &&
-                    typeof nodeResponse.flush == "function") {
-                    // The npm package "compression" is an express middleware that is widely used,
-                    // for example in next.js. It uses the npm package "compressible" to determine
-                    // whether to apply compression to a response. Unfortunately, "compressible"
-                    // matches every mime type that ends with "+json", causing our server-streaming
-                    // RPCs to be buffered.
-                    // The package modifies the response object, and adds a flush() method, which
-                    // flushes the underlying gzip or deflate stream from the Node.js zlib module.
-                    // The method is added here:
-                    // https://github.com/expressjs/compression/blob/ad5113b98cafe1382a0ece30bb4673707ac59ce7/index.js#L70
-                    nodeResponse.flush();
-                }
-                isWriteError = false;
-            }
-        }
-        if (!nodeResponse.headersSent) {
-            nodeResponse.writeHead(universalResponse.status, webHeaderToNodeHeaders(universalResponse.header));
-        }
-        if (universalResponse.trailer) {
-            nodeResponse.addTrailers(webHeaderToNodeHeaders(universalResponse.trailer));
-        }
-        await new Promise((resolve) => {
-            // The npm package "compression" crashes when a callback is passed to end()
-            // https://github.com/expressjs/compression/blob/ad5113b98cafe1382a0ece30bb4673707ac59ce7/index.js#L115
-            nodeResponse.once("end", resolve);
-            nodeResponse.end();
-        });
-    }
-    catch (e) {
-        // Report write errors to the handler.
-        if (isWriteError) {
-            (_b = it === null || it === void 0 ? void 0 : it.throw) === null || _b === void 0 ? void 0 : _b.call(it, e).catch(() => { });
-        }
-        throw connectErrorFromNodeReason(e);
-    }
-    finally {
-        (_c = it === null || it === void 0 ? void 0 : it.return) === null || _c === void 0 ? void 0 : _c.call(it).catch(() => { });
-    }
-}
-function asyncIterableFromNodeServerRequest(request) {
-    return __asyncGenerator(this, arguments, function* asyncIterableFromNodeServerRequest_1() {
-        var _a, e_1, _b, _c;
-        const it = request.iterator({
-            // Node.js v16 closes request and response when this option isn't disabled.
-            // When one of our handlers receives invalid data (such as an unexpected
-            // compression flag in a streaming request), we're unable to write the error
-            // response.
-            // Later major versions have a more sensible behavior - we can revert this
-            // workaround once we stop supporting v16.
-            destroyOnReturn: false,
-        });
-        try {
-            for (var _d = true, it_1 = __asyncValues(it), it_1_1; it_1_1 = yield __await(it_1.next()), _a = it_1_1.done, !_a; _d = true) {
-                _c = it_1_1.value;
-                _d = false;
-                const chunk = _c;
-                yield yield __await(chunk);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = it_1.return)) yield __await(_b.call(it_1));
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    });
-}
-function write(stream, data) {
-    return new Promise((resolve, reject) => {
-        if (stream.errored) {
-            return error(stream.errored);
-        }
-        stream.once("error", error);
-        stream.once("drain", drain);
-        // flushed == false: the stream wishes for the calling code to wait for
-        // the 'drain' event to be emitted before continuing to write additional
-        // data.
-        const flushed = stream.write(data, "binary", function (err) {
-            if (err && !flushed) {
-                // We are never getting a "drain" nor an "error" event if the stream
-                // has already ended (ERR_STREAM_WRITE_AFTER_END), so we have to
-                // resolve our promise in this callback.
-                error(err);
-                // However, once we do that (and remove our event listeners), we _do_
-                // get an "error" event, which ends up as an uncaught exception.
-                // We silence this error specifically with the following listener.
-                // All of this seems very fragile.
-                stream.once("error", () => {
-                    //
-                });
-            }
-        });
-        if (flushed) {
-            drain();
-        }
-        function error(err) {
-            stream.off("error", error);
-            stream.off("drain", drain);
-            reject(err);
-        }
-        function drain() {
-            stream.off("error", error);
-            stream.off("drain", drain);
-            resolve();
-        }
-    });
-}

package/node_modules/@connectrpc/connect-node/dist/esm/node-universal-header.d.ts

@@ -1,19 +0,0 @@
-import type * as http from "http";
-import type * as http2 from "http2";
-/**
- * Convert a Node.js header object to a fetch API Headers object.
- *
- * This function works for Node.js incoming and outgoing headers, and for the
- * http and the http2 package.
- *
- * HTTP/2 pseudo-headers (:method, :path, etc.) are stripped.
- */
-export declare function nodeHeaderToWebHeader(nodeHeaders: http.OutgoingHttpHeaders | http.IncomingHttpHeaders | http2.IncomingHttpHeaders | http.IncomingMessage["trailers"]): Headers;
-/**
- * Convert a fetch API Headers object to a Node.js headers object.
- *
- * Optionally accepts default Node.js headers. If provided, fetch API headers
- * are appended to the defaults. The original defaults headers are not modified.
- */
-export declare function webHeaderToNodeHeaders(headersInit: HeadersInit, defaultNodeHeaders?: http.OutgoingHttpHeaders): http.OutgoingHttpHeaders;
-export declare function webHeaderToNodeHeaders(headersInit: HeadersInit | undefined): http.OutgoingHttpHeaders | undefined;