pi-cursor-sdk 0.1.49 → 0.1.51

package/node_modules/@connectrpc/connect-node/dist/cjs/node-universal-header.js

@@ -1,97 +0,0 @@
-"use strict";
-// 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.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nodeHeaderToWebHeader = nodeHeaderToWebHeader;
-exports.webHeaderToNodeHeaders = webHeaderToNodeHeaders;
-/**
- * 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.
- */
-function nodeHeaderToWebHeader(nodeHeaders) {
-    const header = new Headers();
-    for (const [k, v] of Object.entries(nodeHeaders)) {
-        if (k.startsWith(":")) {
-            continue;
-        }
-        if (v === undefined) {
-            continue;
-        }
-        if (typeof v == "string") {
-            header.append(k, v);
-        }
-        else if (typeof v == "number") {
-            header.append(k, String(v));
-        }
-        else {
-            for (const e of v) {
-                header.append(k, e);
-            }
-        }
-    }
-    return header;
-}
-function webHeaderToNodeHeaders(headersInit, defaultNodeHeaders) {
-    if (headersInit === undefined && defaultNodeHeaders === undefined) {
-        return undefined;
-    }
-    const o = Object.create(null);
-    if (defaultNodeHeaders !== undefined) {
-        for (const [key, value] of Object.entries(defaultNodeHeaders)) {
-            if (Array.isArray(value)) {
-                o[key] = value.concat();
-            }
-            else if (value !== undefined) {
-                o[key] = value;
-            }
-        }
-    }
-    if (headersInit !== undefined) {
-        if (Array.isArray(headersInit)) {
-            for (const [key, value] of headersInit) {
-                appendWebHeader(o, key, value);
-            }
-        }
-        else if ("forEach" in headersInit) {
-            if (typeof headersInit.forEach == "function") {
-                headersInit.forEach((value, key) => {
-                    appendWebHeader(o, key, value);
-                });
-            }
-        }
-        else {
-            for (const [key, value] of Object.entries(headersInit)) {
-                appendWebHeader(o, key, value);
-            }
-        }
-    }
-    return o;
-}
-function appendWebHeader(o, key, value) {
-    key = key.toLowerCase();
-    const existing = o[key];
-    if (Array.isArray(existing)) {
-        existing.push(value);
-    }
-    else if (existing === undefined) {
-        o[key] = value;
-    }
-    else {
-        o[key] = [existing.toString(), value];
-    }
-}

package/node_modules/@connectrpc/connect-node/dist/cjs/package.json

@@ -1 +0,0 @@
-{"type":"commonjs"}

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

@@ -1,15 +0,0 @@
-import type { Compression } from "@connectrpc/connect/protocol";
-/**
- * The gzip compression algorithm, implemented with the Node.js built-in module
- * zlib. This value can be used for the `sendCompression` and `acceptCompression`
- * option of client transports, or for the `acceptCompression` option of server
- * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
- */
-export declare const compressionGzip: Compression;
-/**
- * The brotli compression algorithm, implemented with the Node.js built-in module
- * zlib. This value can be used for the `sendCompression` and `acceptCompression`
- * option of client transports, or for the `acceptCompression` option of server
- * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
- */
-export declare const compressionBrotli: Compression;

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

@@ -1,86 +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 zlib from "zlib";
-import { promisify } from "util";
-import { Code, ConnectError } from "@connectrpc/connect";
-import { getNodeErrorProps } from "./node-error.js";
-const gzip = promisify(zlib.gzip);
-const gunzip = promisify(zlib.gunzip);
-const brotliCompress = promisify(zlib.brotliCompress);
-const brotliDecompress = promisify(zlib.brotliDecompress);
-/**
- * The gzip compression algorithm, implemented with the Node.js built-in module
- * zlib. This value can be used for the `sendCompression` and `acceptCompression`
- * option of client transports, or for the `acceptCompression` option of server
- * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
- */
-export const compressionGzip = {
-    name: "gzip",
-    compress(bytes) {
-        return gzip(bytes, {});
-    },
-    decompress(bytes, readMaxBytes) {
-        if (bytes.length == 0) {
-            return Promise.resolve(new Uint8Array(0));
-        }
-        return wrapZLibErrors(gunzip(bytes, {
-            maxOutputLength: readMaxBytes,
-        }), readMaxBytes);
-    },
-};
-/**
- * The brotli compression algorithm, implemented with the Node.js built-in module
- * zlib. This value can be used for the `sendCompression` and `acceptCompression`
- * option of client transports, or for the `acceptCompression` option of server
- * plugins like `fastifyConnectPlugin` from @connectrpc/connect-fastify.
- */
-export const compressionBrotli = {
-    name: "br",
-    compress(bytes) {
-        return brotliCompress(bytes, {});
-    },
-    decompress(bytes, readMaxBytes) {
-        if (bytes.length == 0) {
-            return Promise.resolve(new Uint8Array(0));
-        }
-        return wrapZLibErrors(brotliDecompress(bytes, {
-            maxOutputLength: readMaxBytes,
-        }), readMaxBytes);
-    },
-};
-function wrapZLibErrors(promise, readMaxBytes) {
-    return promise.catch((e) => {
-        const props = getNodeErrorProps(e);
-        let code = Code.Internal;
-        let message = "decompression failed";
-        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-        switch (props.code) {
-            case "ERR_BUFFER_TOO_LARGE":
-                code = Code.ResourceExhausted;
-                message = `message is larger than configured readMaxBytes ${readMaxBytes} after decompression`;
-                break;
-            case "Z_DATA_ERROR":
-            case "ERR_PADDING_2":
-                code = Code.InvalidArgument;
-                break;
-            default:
-                if (props.code !== undefined &&
-                    props.code.startsWith("ERR__ERROR_FORMAT_")) {
-                    code = Code.InvalidArgument;
-                }
-                break;
-        }
-        return Promise.reject(new ConnectError(message, code, undefined, undefined, e));
-    });
-}

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

@@ -1,42 +0,0 @@
-import type { ConnectRouter, ConnectRouterOptions, ContextValues } from "@connectrpc/connect";
-import type { NodeHandlerFn, NodeServerRequest } from "./node-universal-handler.js";
-export interface ConnectNodeAdapterOptions extends ConnectRouterOptions {
-    /**
-     * Route definitions. We recommend the following pattern:
-     *
-     * Create a file `connect.ts` with a default export such as this:
-     *
-     * ```ts
-     * import {ConnectRouter} from "@connectrpc/connect";
-     *
-     * export default (router: ConnectRouter) => {
-     *   router.service(ElizaService, {});
-     * }
-     * ```
-     *
-     * Then pass this function here.
-     */
-    routes: (router: ConnectRouter) => void;
-    /**
-     * If none of the handler request paths match, a 404 is served. This option
-     * can provide a custom fallback for this case.
-     */
-    fallback?: NodeHandlerFn;
-    /**
-     * Serve all handlers under this prefix. For example, the prefix "/something"
-     * will serve the RPC foo.FooService/Bar under "/something/foo.FooService/Bar".
-     * Note that many gRPC client implementations do not allow for prefixes.
-     */
-    requestPathPrefix?: string;
-    /**
-     * Context values to extract from the request. These values are passed to
-     * the handlers.
-     */
-    contextValues?: (req: NodeServerRequest) => ContextValues;
-}
-/**
- * Create a Node.js request handler from a ConnectRouter.
- *
- * The returned function is compatible with http.RequestListener and its equivalent for http2.
- */
-export declare function connectNodeAdapter(options: ConnectNodeAdapterOptions): NodeHandlerFn;

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

@@ -1,58 +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 { Code, ConnectError, createConnectRouter } from "@connectrpc/connect";
-import { uResponseNotFound } from "@connectrpc/connect/protocol";
-import { universalRequestFromNodeRequest, universalResponseToNodeResponse, } from "./node-universal-handler.js";
-import { compressionBrotli, compressionGzip } from "./compression.js";
-/**
- * Create a Node.js request handler from a ConnectRouter.
- *
- * The returned function is compatible with http.RequestListener and its equivalent for http2.
- */
-export function connectNodeAdapter(options) {
-    var _a;
-    if (options.acceptCompression === undefined) {
-        options.acceptCompression = [compressionGzip, compressionBrotli];
-    }
-    const router = createConnectRouter(options);
-    options.routes(router);
-    const prefix = (_a = options.requestPathPrefix) !== null && _a !== void 0 ? _a : "";
-    const paths = new Map();
-    for (const uHandler of router.handlers) {
-        paths.set(prefix + uHandler.requestPath, uHandler);
-    }
-    return function nodeRequestHandler(req, res) {
-        var _a, _b, _c, _d;
-        // Strip the query parameter when matching paths.
-        const uHandler = paths.get((_b = (_a = req.url) === null || _a === void 0 ? void 0 : _a.split("?", 2)[0]) !== null && _b !== void 0 ? _b : "");
-        if (!uHandler) {
-            ((_c = options.fallback) !== null && _c !== void 0 ? _c : fallback)(req, res);
-            return;
-        }
-        const uReq = universalRequestFromNodeRequest(req, res, undefined, (_d = options.contextValues) === null || _d === void 0 ? void 0 : _d.call(options, req));
-        uHandler(uReq)
-            .then((uRes) => universalResponseToNodeResponse(uRes, res))
-            .catch((reason) => {
-            if (ConnectError.from(reason).code == Code.Aborted) {
-                return;
-            }
-            // eslint-disable-next-line no-console
-            console.error(`handler for rpc ${uHandler.method.name} of ${uHandler.service.typeName} failed`, reason);
-        });
-    };
-}
-const fallback = (request, response) => {
-    response.writeHead(uResponseNotFound.status);
-    response.end();
-};

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

@@ -1,100 +0,0 @@
-import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions } from "@bufbuild/protobuf";
-import type { Interceptor, Transport } from "@connectrpc/connect";
-import type { Compression } from "@connectrpc/connect/protocol";
-import type { NodeTransportOptions } from "./node-transport-options.js";
-/**
- * Options used to configure the Connect transport.
- *
- * See createConnectTransport().
- */
-export type ConnectTransportOptions = NodeTransportOptions & {
-    /**
-     * Base URI for all HTTP requests.
-     *
-     * Requests will be made to <baseUrl>/<package>.<service>/method
-     *
-     * Example: `baseUrl: "https://example.com/my-api"`
-     *
-     * This will make a `POST /my-api/my_package.MyService/Foo` to
-     * `example.com` via HTTPS.
-     */
-    baseUrl: string;
-    /**
-     * By default, connect-node clients use the binary format.
-     */
-    useBinaryFormat?: boolean;
-    /**
-     * Interceptors that should be applied to all calls running through
-     * this transport. See the Interceptor type for details.
-     */
-    interceptors?: Interceptor[];
-    /**
-     * Options for the JSON format.
-     * By default, unknown fields are ignored.
-     */
-    jsonOptions?: Partial<JsonReadOptions & JsonWriteOptions>;
-    /**
-     * Options for the binary wire format.
-     */
-    binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>;
-    /**
-     * Compression algorithms available to a client. Clients ask servers to
-     * compress responses using any of the registered algorithms. The first
-     * registered algorithm is the most preferred.
-     *
-     * It is safe to use this option liberally: servers will ignore any
-     * compression algorithms they don't support. To compress requests, pair this
-     * option with `sendCompression`.
-     *
-     * If this option is not provided, the compression algorithms "gzip" and "br"
-     * (Brotli) are accepted. To opt out of response compression, pass an
-     * empty array.
-     */
-    acceptCompression?: Compression[];
-    /**
-     * Configures the client to use the specified algorithm to compress request
-     * messages.
-     *
-     * Because some servers don't support compression, clients default to sending
-     * uncompressed requests.
-     */
-    sendCompression?: Compression;
-    /**
-     * Sets a minimum size threshold for compression: Messages that are smaller
-     * than the configured minimum are sent uncompressed.
-     *
-     * The default value is 1 kibibyte, because the CPU cost of compressing very
-     * small messages usually isn't worth the small reduction in network I/O.
-     */
-    compressMinBytes?: number;
-    /**
-     * Limits the performance impact of pathologically large messages sent by the
-     * server. Limits apply to each individual message, not to the stream as a
-     * whole.
-     *
-     * The default limit is the maximum supported value of ~4GiB.
-     */
-    readMaxBytes?: number;
-    /**
-     * Prevents sending messages too large for the server to handle.
-     *
-     * The default limit is the maximum supported value of ~4GiB.
-     */
-    writeMaxBytes?: number;
-    /**
-     * Controls whether or not Connect GET requests should be used when
-     * available, on side-effect free methods. Defaults to false.
-     */
-    useHttpGet?: boolean;
-    /**
-     * The timeout in milliseconds to apply to all requests.
-     *
-     * This can be overridden on a per-request basis by passing a timeoutMs.
-     */
-    defaultTimeoutMs?: number;
-};
-/**
- * Create a Transport for the Connect protocol using the Node.js `http`, `http2`,
- * or `http2` module.
- */
-export declare function createConnectTransport(options: ConnectTransportOptions): Transport;

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

@@ -1,22 +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 { createTransport } from "@connectrpc/connect/protocol-connect";
-import { validateNodeTransportOptions } from "./node-transport-options.js";
-/**
- * Create a Transport for the Connect protocol using the Node.js `http`, `http2`,
- * or `http2` module.
- */
-export function createConnectTransport(options) {
-    return createTransport(validateNodeTransportOptions(options));
-}

package/node_modules/@connectrpc/connect-node/dist/esm/grpc-transport.d.ts

@@ -1,96 +0,0 @@
-import type { Interceptor, Transport } from "@connectrpc/connect";
-import type { Compression } from "@connectrpc/connect/protocol";
-import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions } from "@bufbuild/protobuf";
-import type { NodeTransportOptions } from "./node-transport-options.js";
-/**
- * Options used to configure the gRPC-web transport.
- *
- * See createGrpcTransport().
- */
-export type GrpcTransportOptions = NodeTransportOptions & {
-    /**
-     * Base URI for all HTTP requests.
-     *
-     * Requests will be made to <baseUrl>/<package>.<service>/method
-     *
-     * Example: `baseUrl: "https://example.com/my-api"`
-     *
-     * This will make a `POST /my-api/my_package.MyService/Foo` to
-     * `example.com` via HTTPS.
-     */
-    baseUrl: string;
-    /**
-     * By default, clients use the binary format for gRPC-web, because
-     * not all gRPC-web implementations support JSON.
-     */
-    useBinaryFormat?: boolean;
-    /**
-     * Interceptors that should be applied to all calls running through
-     * this transport. See the Interceptor type for details.
-     */
-    interceptors?: Interceptor[];
-    /**
-     * Options for the JSON format.
-     * By default, unknown fields are ignored.
-     */
-    jsonOptions?: Partial<JsonReadOptions & JsonWriteOptions>;
-    /**
-     * Options for the binary wire format.
-     */
-    binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>;
-    /**
-     * Compression algorithms available to a client. Clients ask servers to
-     * compress responses using any of the registered algorithms. The first
-     * registered algorithm is the most preferred.
-     *
-     * It is safe to use this option liberally: servers will ignore any
-     * compression algorithms they don't support. To compress requests, pair this
-     * option with `sendCompression`.
-     *
-     * If this option is not provided, the compression algorithms "gzip" and "br"
-     * (Brotli) are accepted. To opt out of response compression, pass an
-     * empty array.
-     */
-    acceptCompression?: Compression[];
-    /**
-     * Configures the client to use the specified algorithm to compress request
-     * messages.
-     *
-     * Because some servers don't support compression, clients default to sending
-     * uncompressed requests.
-     */
-    sendCompression?: Compression;
-    /**
-     * Sets a minimum size threshold for compression: Messages that are smaller
-     * than the configured minimum are sent uncompressed.
-     *
-     * The default value is 1 kibibyte, because the CPU cost of compressing very
-     * small messages usually isn't worth the small reduction in network I/O.
-     */
-    compressMinBytes?: number;
-    /**
-     * Limits the performance impact of pathologically large messages sent by the
-     * server. Limits apply to each individual message, not to the stream as a
-     * whole.
-     *
-     * The default limit is the maximum supported value of ~4GiB.
-     */
-    readMaxBytes?: number;
-    /**
-     * Prevents sending messages too large for the server to handle.
-     *
-     * The default limit is the maximum supported value of ~4GiB.
-     */
-    writeMaxBytes?: number;
-    /**
-     * The timeout in milliseconds to apply to all requests.
-     *
-     * This can be overridden on a per-request basis by passing a timeoutMs.
-     */
-    defaultTimeoutMs?: number;
-};
-/**
- * Create a Transport for the gRPC protocol using the Node.js `http`, `http2`,
- * or `http2` module.
- */
-export declare function createGrpcTransport(options: GrpcTransportOptions): Transport;

package/node_modules/@connectrpc/connect-node/dist/esm/grpc-transport.js

@@ -1,22 +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 { createTransport } from "@connectrpc/connect/protocol-grpc";
-import { validateNodeTransportOptions } from "./node-transport-options.js";
-/**
- * Create a Transport for the gRPC protocol using the Node.js `http`, `http2`,
- * or `http2` module.
- */
-export function createGrpcTransport(options) {
-    return createTransport(validateNodeTransportOptions(options));
-}

package/node_modules/@connectrpc/connect-node/dist/esm/grpc-web-transport.d.ts

@@ -1,96 +0,0 @@
-import type { Interceptor, Transport } from "@connectrpc/connect";
-import type { Compression } from "@connectrpc/connect/protocol";
-import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions } from "@bufbuild/protobuf";
-import type { NodeTransportOptions } from "./node-transport-options.js";
-/**
- * Options used to configure the gRPC-web transport.
- *
- * See createGrpcWebTransport().
- */
-export type GrpcWebTransportOptions = NodeTransportOptions & {
-    /**
-     * Base URI for all HTTP requests.
-     *
-     * Requests will be made to <baseUrl>/<package>.<service>/method
-     *
-     * Example: `baseUrl: "https://example.com/my-api"`
-     *
-     * This will make a `POST /my-api/my_package.MyService/Foo` to
-     * `example.com` via HTTPS.
-     */
-    baseUrl: string;
-    /**
-     * By default, clients use the binary format for gRPC-web, because
-     * not all gRPC-web implementations support JSON.
-     */
-    useBinaryFormat?: boolean;
-    /**
-     * Interceptors that should be applied to all calls running through
-     * this transport. See the Interceptor type for details.
-     */
-    interceptors?: Interceptor[];
-    /**
-     * Options for the JSON format.
-     * By default, unknown fields are ignored.
-     */
-    jsonOptions?: Partial<JsonReadOptions & JsonWriteOptions>;
-    /**
-     * Options for the binary wire format.
-     */
-    binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>;
-    /**
-     * Compression algorithms available to a client. Clients ask servers to
-     * compress responses using any of the registered algorithms. The first
-     * registered algorithm is the most preferred.
-     *
-     * It is safe to use this option liberally: servers will ignore any
-     * compression algorithms they don't support. To compress requests, pair this
-     * option with `sendCompression`.
-     *
-     * If this option is not provided, the compression algorithms "gzip" and "br"
-     * (Brotli) are accepted. To opt out of response compression, pass an
-     * empty array.
-     */
-    acceptCompression?: Compression[];
-    /**
-     * Configures the client to use the specified algorithm to compress request
-     * messages.
-     *
-     * Because some servers don't support compression, clients default to sending
-     * uncompressed requests.
-     */
-    sendCompression?: Compression;
-    /**
-     * Sets a minimum size threshold for compression: Messages that are smaller
-     * than the configured minimum are sent uncompressed.
-     *
-     * The default value is 1 kibibyte, because the CPU cost of compressing very
-     * small messages usually isn't worth the small reduction in network I/O.
-     */
-    compressMinBytes?: number;
-    /**
-     * Limits the performance impact of pathologically large messages sent by the
-     * server. Limits apply to each individual message, not to the stream as a
-     * whole.
-     *
-     * The default limit is the maximum supported value of ~4GiB.
-     */
-    readMaxBytes?: number;
-    /**
-     * Prevents sending messages too large for the server to handle.
-     *
-     * The default limit is the maximum supported value of ~4GiB.
-     */
-    writeMaxBytes?: number;
-    /**
-     * The timeout in milliseconds to apply to all requests.
-     *
-     * This can be overridden on a per-request basis by passing a timeoutMs.
-     */
-    defaultTimeoutMs?: number;
-};
-/**
- * Create a Transport for the gRPC-web protocol using the Node.js `http`,
- * `http2`, or `http2` module.
- */
-export declare function createGrpcWebTransport(options: GrpcWebTransportOptions): Transport;

package/node_modules/@connectrpc/connect-node/dist/esm/grpc-web-transport.js

@@ -1,22 +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 { createTransport } from "@connectrpc/connect/protocol-grpc-web";
-import { validateNodeTransportOptions } from "./node-transport-options.js";
-/**
- * Create a Transport for the gRPC-web protocol using the Node.js `http`,
- * `http2`, or `http2` module.
- */
-export function createGrpcWebTransport(options) {
-    return createTransport(validateNodeTransportOptions(options));
-}