openrod 0.0.0 → 0.1.0

package/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc-web/handler-factory.js

@@ -0,0 +1,130 @@
+"use strict";
+// Copyright 2021-2026 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.createHandlerFactory = createHandlerFactory;
+const connect_error_js_1 = require("../connect-error.js");
+const code_js_1 = require("../code.js");
+const implementation_js_1 = require("../implementation.js");
+const trailer_js_1 = require("./trailer.js");
+const headers_js_1 = require("./headers.js");
+const content_type_js_1 = require("./content-type.js");
+const parse_timeout_js_1 = require("../protocol-grpc/parse-timeout.js");
+const trailer_status_js_1 = require("../protocol-grpc/trailer-status.js");
+const async_iterable_js_1 = require("../protocol/async-iterable.js");
+const compression_js_1 = require("../protocol/compression.js");
+const content_type_matcher_js_1 = require("../protocol/content-type-matcher.js");
+const create_method_url_js_1 = require("../protocol/create-method-url.js");
+const invoke_implementation_js_1 = require("../protocol/invoke-implementation.js");
+const serialization_js_1 = require("../protocol/serialization.js");
+const universal_handler_js_1 = require("../protocol/universal-handler.js");
+const universal_js_1 = require("../protocol/universal.js");
+const protocolName = "grpc-web";
+const methodPost = "POST";
+/**
+ * Create a factory that creates gRPC-web handlers.
+ */
+function createHandlerFactory(options) {
+    const opt = (0, universal_handler_js_1.validateUniversalHandlerOptions)(options);
+    const trailerSerialization = (0, trailer_js_1.createTrailerSerialization)();
+    function fact(spec) {
+        const h = createHandler(opt, trailerSerialization, spec);
+        return Object.assign(h, {
+            protocolNames: [protocolName],
+            allowedMethods: [methodPost],
+            supportedContentType: (0, content_type_matcher_js_1.contentTypeMatcher)(content_type_js_1.contentTypeRegExp),
+            requestPath: (0, create_method_url_js_1.createMethodUrl)("/", spec.method),
+            service: spec.method.parent,
+            method: spec.method,
+        });
+    }
+    fact.protocolName = protocolName;
+    return fact;
+}
+function createHandler(opt, trailerSerialization, spec) {
+    const serialization = (0, serialization_js_1.createMethodSerializationLookup)(spec.method, opt.binaryOptions, opt.jsonOptions, opt);
+    return async function handle(req) {
+        (0, universal_js_1.assertByteStreamRequest)(req);
+        const type = (0, content_type_js_1.parseContentType)(req.header.get(headers_js_1.headerContentType));
+        if (type == undefined || type.text) {
+            return universal_js_1.uResponseUnsupportedMediaType;
+        }
+        if (req.method !== methodPost) {
+            return universal_js_1.uResponseMethodNotAllowed;
+        }
+        const timeout = (0, parse_timeout_js_1.parseTimeout)(req.header.get(headers_js_1.headerTimeout), opt.maxTimeoutMs);
+        const context = (0, implementation_js_1.createHandlerContext)(Object.assign(Object.assign({}, spec), { service: spec.method.parent, requestMethod: req.method, protocolName, timeoutMs: timeout.timeoutMs, shutdownSignal: opt.shutdownSignal, requestSignal: req.signal, requestHeader: req.header, url: req.url, responseHeader: {
+                [headers_js_1.headerContentType]: type.binary ? content_type_js_1.contentTypeProto : content_type_js_1.contentTypeJson,
+            }, responseTrailer: {
+                [headers_js_1.headerGrpcStatus]: trailer_status_js_1.grpcStatusOk,
+            }, contextValues: req.contextValues }));
+        const compression = (0, compression_js_1.compressionNegotiate)(opt.acceptCompression, req.header.get(headers_js_1.headerEncoding), req.header.get(headers_js_1.headerAcceptEncoding), headers_js_1.headerAcceptEncoding);
+        if (compression.response) {
+            context.responseHeader.set(headers_js_1.headerEncoding, compression.response.name);
+        }
+        // We split the pipeline into two parts: The request iterator, and the
+        // response iterator. We do this because the request iterator is responsible
+        // for parsing the request body, and we don't want write errors of the response
+        // iterator to affect the request iterator.
+        const inputIt = (0, async_iterable_js_1.pipe)(req.body, (0, async_iterable_js_1.transformPrepend)(() => {
+            // raise compression error to serialize it as a trailer status
+            if (compression.error)
+                throw compression.error;
+            // raise timeout parsing error to serialize it as a trailer status
+            if (timeout.error)
+                throw timeout.error;
+            return undefined;
+        }), (0, async_iterable_js_1.transformSplitEnvelope)(opt.readMaxBytes), (0, async_iterable_js_1.transformDecompressEnvelope)(compression.request, opt.readMaxBytes), (0, async_iterable_js_1.transformParseEnvelope)(serialization.getI(type.binary), trailer_js_1.trailerFlag));
+        // We run the request gate before receiving the body, so that a request it
+        // rejects is never read, decompressed, or parsed.
+        const it = await (0, invoke_implementation_js_1.applyRequestGate)(context, opt.requestGate, () => (0, invoke_implementation_js_1.transformInvokeImplementation)(spec, context, opt.interceptors)(inputIt));
+        const outputIt = (0, async_iterable_js_1.pipe)(
+        // We wrap the iterator in an async iterator to ensure that the
+        // abort signal is aborted when the iterator is done.
+        {
+            [Symbol.asyncIterator]() {
+                return {
+                    next: () => it.next(),
+                    throw: (e) => {
+                        var _a, _b;
+                        context.abort(e);
+                        return (_b = (_a = it.throw) === null || _a === void 0 ? void 0 : _a.call(it, e)) !== null && _b !== void 0 ? _b : Promise.reject({ done: true });
+                    },
+                    return: (v) => {
+                        var _a, _b;
+                        context.abort();
+                        return ((_b = (_a = it.return) === null || _a === void 0 ? void 0 : _a.call(it, v)) !== null && _b !== void 0 ? _b : Promise.resolve({ done: true, value: v }));
+                    },
+                };
+            },
+        }, (0, async_iterable_js_1.transformSerializeEnvelope)(serialization.getO(type.binary)), (0, async_iterable_js_1.transformCatchFinally)((e) => {
+            context.abort(e);
+            if (e instanceof connect_error_js_1.ConnectError) {
+                (0, trailer_status_js_1.setTrailerStatus)(context.responseTrailer, e);
+            }
+            else if (e !== undefined) {
+                (0, trailer_status_js_1.setTrailerStatus)(context.responseTrailer, new connect_error_js_1.ConnectError("internal error", code_js_1.Code.Internal, undefined, undefined, e));
+            }
+            return {
+                flags: trailer_js_1.trailerFlag,
+                data: trailerSerialization.serialize(context.responseTrailer),
+            };
+        }), (0, async_iterable_js_1.transformCompressEnvelope)(compression.response, opt.compressMinBytes), (0, async_iterable_js_1.transformJoinEnvelopes)(), { propagateDownStreamError: true });
+        return Object.assign(Object.assign({}, universal_js_1.uResponseOk), { 
+            // We wait for the first response body bytes before resolving, so that
+            // implementations have a chance to add headers before an adapter commits
+            // them to the wire.
+            body: await (0, async_iterable_js_1.untilFirst)(outputIt), header: context.responseHeader });
+    };
+}

package/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc-web/headers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+export { headerContentType, headerEncoding, headerAcceptEncoding, headerTimeout, headerGrpcStatus, headerGrpcMessage, headerStatusDetailsBin, headerUserAgent, } from "../protocol-grpc/headers.js";
+/**
+ * gRPC-web does not use the standard header User-Agent.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const headerXUserAgent = "X-User-Agent";
+/**
+ * The canonical grpc/grpc-web JavaScript implementation sets
+ * this request header with value "1".
+ * Some servers may rely on the header to identify gRPC-web
+ * requests. For example the proxy by improbable:
+ * https://github.com/improbable-eng/grpc-web/blob/53aaf4cdc0fede7103c1b06f0cfc560c003a5c41/go/grpcweb/wrapper.go#L231
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const headerXGrpcWeb = "X-Grpc-Web";

package/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc-web/headers.js

@@ -0,0 +1,44 @@
+"use strict";
+// Copyright 2021-2026 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.headerXGrpcWeb = exports.headerXUserAgent = exports.headerUserAgent = exports.headerStatusDetailsBin = exports.headerGrpcMessage = exports.headerGrpcStatus = exports.headerTimeout = exports.headerAcceptEncoding = exports.headerEncoding = exports.headerContentType = void 0;
+/**
+ * @private Internal code, does not follow semantic versioning.
+ */
+var headers_js_1 = require("../protocol-grpc/headers.js");
+Object.defineProperty(exports, "headerContentType", { enumerable: true, get: function () { return headers_js_1.headerContentType; } });
+Object.defineProperty(exports, "headerEncoding", { enumerable: true, get: function () { return headers_js_1.headerEncoding; } });
+Object.defineProperty(exports, "headerAcceptEncoding", { enumerable: true, get: function () { return headers_js_1.headerAcceptEncoding; } });
+Object.defineProperty(exports, "headerTimeout", { enumerable: true, get: function () { return headers_js_1.headerTimeout; } });
+Object.defineProperty(exports, "headerGrpcStatus", { enumerable: true, get: function () { return headers_js_1.headerGrpcStatus; } });
+Object.defineProperty(exports, "headerGrpcMessage", { enumerable: true, get: function () { return headers_js_1.headerGrpcMessage; } });
+Object.defineProperty(exports, "headerStatusDetailsBin", { enumerable: true, get: function () { return headers_js_1.headerStatusDetailsBin; } });
+Object.defineProperty(exports, "headerUserAgent", { enumerable: true, get: function () { return headers_js_1.headerUserAgent; } });
+/**
+ * gRPC-web does not use the standard header User-Agent.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.headerXUserAgent = "X-User-Agent";
+/**
+ * The canonical grpc/grpc-web JavaScript implementation sets
+ * this request header with value "1".
+ * Some servers may rely on the header to identify gRPC-web
+ * requests. For example the proxy by improbable:
+ * https://github.com/improbable-eng/grpc-web/blob/53aaf4cdc0fede7103c1b06f0cfc560c003a5c41/go/grpcweb/wrapper.go#L231
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.headerXGrpcWeb = "X-Grpc-Web";

package/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc-web/index.d.ts

@@ -0,0 +1,8 @@
+export { createHandlerFactory } from "./handler-factory.js";
+export { createTransport } from "./transport.js";
+export { requestHeader, requestHeaderWithCompression, } from "./request-header.js";
+export { parseContentType, contentTypeRegExp, contentTypeProto, contentTypeJson, } from "./content-type.js";
+export { validateResponse, validateResponseWithCompression, } from "./validate-response.js";
+export { trailerFlag, trailerParse, trailerSerialize, createTrailerSerialization, } from "./trailer.js";
+export { parseTimeout, setTrailerStatus, validateTrailer, grpcStatusOk, } from "../protocol-grpc/index.js";
+export * from "./headers.js";

package/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc-web/index.js

@@ -0,0 +1,61 @@
+"use strict";
+// Copyright 2021-2026 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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcStatusOk = exports.validateTrailer = exports.setTrailerStatus = exports.parseTimeout = exports.createTrailerSerialization = exports.trailerSerialize = exports.trailerParse = exports.trailerFlag = exports.validateResponseWithCompression = exports.validateResponse = exports.contentTypeJson = exports.contentTypeProto = exports.contentTypeRegExp = exports.parseContentType = exports.requestHeaderWithCompression = exports.requestHeader = exports.createTransport = exports.createHandlerFactory = void 0;
+var handler_factory_js_1 = require("./handler-factory.js");
+Object.defineProperty(exports, "createHandlerFactory", { enumerable: true, get: function () { return handler_factory_js_1.createHandlerFactory; } });
+var transport_js_1 = require("./transport.js");
+Object.defineProperty(exports, "createTransport", { enumerable: true, get: function () { return transport_js_1.createTransport; } });
+// All exports below are private — internal code that does not follow semantic
+// versioning.
+// We will try hard to avoid breaking changes, but if you depend on the
+// following exports, we recommend that you do so with an exact version
+// constraint (no ~ or ^).
+var request_header_js_1 = require("./request-header.js");
+Object.defineProperty(exports, "requestHeader", { enumerable: true, get: function () { return request_header_js_1.requestHeader; } });
+Object.defineProperty(exports, "requestHeaderWithCompression", { enumerable: true, get: function () { return request_header_js_1.requestHeaderWithCompression; } });
+var content_type_js_1 = require("./content-type.js");
+Object.defineProperty(exports, "parseContentType", { enumerable: true, get: function () { return content_type_js_1.parseContentType; } });
+Object.defineProperty(exports, "contentTypeRegExp", { enumerable: true, get: function () { return content_type_js_1.contentTypeRegExp; } });
+Object.defineProperty(exports, "contentTypeProto", { enumerable: true, get: function () { return content_type_js_1.contentTypeProto; } });
+Object.defineProperty(exports, "contentTypeJson", { enumerable: true, get: function () { return content_type_js_1.contentTypeJson; } });
+var validate_response_js_1 = require("./validate-response.js");
+Object.defineProperty(exports, "validateResponse", { enumerable: true, get: function () { return validate_response_js_1.validateResponse; } });
+Object.defineProperty(exports, "validateResponseWithCompression", { enumerable: true, get: function () { return validate_response_js_1.validateResponseWithCompression; } });
+var trailer_js_1 = require("./trailer.js");
+Object.defineProperty(exports, "trailerFlag", { enumerable: true, get: function () { return trailer_js_1.trailerFlag; } });
+Object.defineProperty(exports, "trailerParse", { enumerable: true, get: function () { return trailer_js_1.trailerParse; } });
+Object.defineProperty(exports, "trailerSerialize", { enumerable: true, get: function () { return trailer_js_1.trailerSerialize; } });
+Object.defineProperty(exports, "createTrailerSerialization", { enumerable: true, get: function () { return trailer_js_1.createTrailerSerialization; } });
+var index_js_1 = require("../protocol-grpc/index.js");
+Object.defineProperty(exports, "parseTimeout", { enumerable: true, get: function () { return index_js_1.parseTimeout; } });
+Object.defineProperty(exports, "setTrailerStatus", { enumerable: true, get: function () { return index_js_1.setTrailerStatus; } });
+Object.defineProperty(exports, "validateTrailer", { enumerable: true, get: function () { return index_js_1.validateTrailer; } });
+Object.defineProperty(exports, "grpcStatusOk", { enumerable: true, get: function () { return index_js_1.grpcStatusOk; } });
+__exportStar(require("./headers.js"), exports);

package/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc-web/request-header.d.ts

@@ -0,0 +1,13 @@
+import type { Compression } from "../protocol/compression.js";
+/**
+ * Creates headers for a gRPC-web request.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function requestHeader(useBinaryFormat: boolean, timeoutMs: number | undefined, userProvidedHeaders: HeadersInit | undefined, setUserAgent: boolean): Headers;
+/**
+ * Creates headers for a gRPC-web request with compression.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function requestHeaderWithCompression(useBinaryFormat: boolean, timeoutMs: number | undefined, userProvidedHeaders: HeadersInit | undefined, acceptCompression: Compression[], sendCompression: Compression | null, setUserAgent: boolean): Headers;

package/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc-web/request-header.js

@@ -0,0 +1,59 @@
+"use strict";
+// Copyright 2021-2026 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.requestHeader = requestHeader;
+exports.requestHeaderWithCompression = requestHeaderWithCompression;
+const headers_js_1 = require("./headers.js");
+const content_type_js_1 = require("./content-type.js");
+/**
+ * Creates headers for a gRPC-web request.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function requestHeader(useBinaryFormat, timeoutMs, userProvidedHeaders, setUserAgent) {
+    var _a, _b;
+    const result = new Headers(userProvidedHeaders !== null && userProvidedHeaders !== void 0 ? userProvidedHeaders : {});
+    // Note that we do not support the grpc-web-text format.
+    // https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-WEB.md#protocol-differences-vs-grpc-over-http2
+    result.set(headers_js_1.headerContentType, useBinaryFormat ? content_type_js_1.contentTypeProto : content_type_js_1.contentTypeJson);
+    result.set(headers_js_1.headerXGrpcWeb, "1");
+    // Note that we do not strictly comply with gRPC user agents.
+    // We use "connect-es/1.2.3" where gRPC would use "grpc-es/1.2.3".
+    // See https://github.com/grpc/grpc/blob/c462bb8d485fc1434ecfae438823ca8d14cf3154/doc/PROTOCOL-HTTP2.md#user-agents
+    const userAgent = (_b = (_a = result.get(headers_js_1.headerUserAgent)) !== null && _a !== void 0 ? _a : result.get(headers_js_1.headerXUserAgent)) !== null && _b !== void 0 ? _b : "connect-es/2.2.0";
+    result.set(headers_js_1.headerXUserAgent, userAgent);
+    if (setUserAgent) {
+        result.set(headers_js_1.headerUserAgent, userAgent);
+    }
+    if (timeoutMs !== undefined) {
+        result.set(headers_js_1.headerTimeout, `${timeoutMs}m`);
+    }
+    return result;
+}
+/**
+ * Creates headers for a gRPC-web request with compression.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function requestHeaderWithCompression(useBinaryFormat, timeoutMs, userProvidedHeaders, acceptCompression, sendCompression, setUserAgent) {
+    const result = requestHeader(useBinaryFormat, timeoutMs, userProvidedHeaders, setUserAgent);
+    if (sendCompression != null) {
+        result.set(headers_js_1.headerEncoding, sendCompression.name);
+    }
+    if (acceptCompression.length > 0) {
+        result.set(headers_js_1.headerAcceptEncoding, acceptCompression.map((c) => c.name).join(","));
+    }
+    return result;
+}

package/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc-web/trailer.d.ts

@@ -0,0 +1,27 @@
+import type { Serialization } from "../protocol/serialization.js";
+/**
+ * trailerFlag indicates that the data in a EnvelopedMessage
+ * is a set of trailers of the gRPC-web protocol.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare const trailerFlag = 128;
+/**
+ * Parse a gRPC-web trailer, a set of header fields separated by CRLF.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function trailerParse(data: Uint8Array): Headers;
+/**
+ * Serialize a Headers object as a gRPC-web trailer.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function trailerSerialize(trailer: Headers): Uint8Array<ArrayBuffer>;
+/**
+ * Create a Serialization object that serializes a gRPC-web trailer, a Headers
+ * object that is serialized as a set of header fields, separated by CRLF.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+export declare function createTrailerSerialization(): Serialization<Headers>;

package/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc-web/trailer.js

@@ -0,0 +1,71 @@
+"use strict";
+// Copyright 2021-2026 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.trailerFlag = void 0;
+exports.trailerParse = trailerParse;
+exports.trailerSerialize = trailerSerialize;
+exports.createTrailerSerialization = createTrailerSerialization;
+/**
+ * trailerFlag indicates that the data in a EnvelopedMessage
+ * is a set of trailers of the gRPC-web protocol.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+exports.trailerFlag = 0b10000000;
+/**
+ * Parse a gRPC-web trailer, a set of header fields separated by CRLF.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function trailerParse(data) {
+    const headers = new Headers();
+    const lines = new TextDecoder().decode(data).split("\r\n");
+    for (const line of lines) {
+        if (line === "") {
+            continue;
+        }
+        const i = line.indexOf(":");
+        if (i > 0) {
+            const name = line.substring(0, i).trim();
+            const value = line.substring(i + 1).trim();
+            headers.append(name, value);
+        }
+    }
+    return headers;
+}
+/**
+ * Serialize a Headers object as a gRPC-web trailer.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function trailerSerialize(trailer) {
+    const lines = [];
+    trailer.forEach((value, key) => {
+        lines.push(`${key}: ${value}\r\n`);
+    });
+    return new TextEncoder().encode(lines.join(""));
+}
+/**
+ * Create a Serialization object that serializes a gRPC-web trailer, a Headers
+ * object that is serialized as a set of header fields, separated by CRLF.
+ *
+ * @private Internal code, does not follow semantic versioning.
+ */
+function createTrailerSerialization() {
+    return {
+        serialize: trailerSerialize,
+        parse: trailerParse,
+    };
+}

package/node_modules/@connectrpc/connect/dist/cjs/protocol-grpc-web/transport.d.ts

@@ -0,0 +1,6 @@
+import type { CommonTransportOptions } from "../protocol/transport-options.js";
+import type { Transport } from "../transport.js";
+/**
+ * Create a Transport for the gRPC-web protocol.
+ */
+export declare function createTransport(opt: CommonTransportOptions): Transport;