pi-cursor-sdk 0.1.12 → 0.1.13

package/node_modules/@connectrpc/connect/dist/cjs/protocol/serialization.d.ts

@@ -1,104 +0,0 @@
-import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions, Message, MessageType, MethodInfo } from "@bufbuild/protobuf";
-/**
- * Serialization provides methods to serialize or parse data with a certain
- * format.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export interface Serialization<T> {
-    /**
-     * Serialize T. Raises a ConnectError with Code.Internal if an error occurs.
-     */
-    serialize: (data: T) => Uint8Array;
-    /**
-     * Parse T. Raises a ConnectError with Code.InvalidArgument if an error occurs.
-     */
-    parse: (data: Uint8Array) => T;
-}
-/**
- * Sets default JSON serialization options for connect-es.
- *
- * With standard protobuf JSON serialization, unknown JSON fields are
- * rejected by default. In connect-es, unknown JSON fields are ignored
- * by default.
- */
-export declare function getJsonOptions(options: Partial<JsonReadOptions & JsonWriteOptions> | undefined): {
-    ignoreUnknownFields?: boolean | undefined;
-    typeRegistry?: import("@bufbuild/protobuf").IMessageTypeRegistry & Partial<import("@bufbuild/protobuf").IExtensionRegistry>;
-    emitDefaultValues?: boolean | undefined;
-    enumAsInteger?: boolean | undefined;
-    useProtoFieldName?: boolean | undefined;
-};
-/**
- * Create an object that provides convenient access to request and response
- * message serialization for a given method.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function createMethodSerializationLookup<I extends Message<I>, O extends Message<O>>(method: MethodInfo<I, O>, binaryOptions: Partial<BinaryReadOptions & BinaryWriteOptions> | undefined, jsonOptions: Partial<JsonReadOptions & JsonWriteOptions> | undefined, limitOptions: {
-    writeMaxBytes: number;
-    readMaxBytes: number;
-}): MethodSerializationLookup<I, O>;
-/**
- * MethodSerializationLookup provides convenient access to request and response
- * message serialization for a given method.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export interface MethodSerializationLookup<I extends Message<I>, O extends Message<O>> {
-    /**
-     * Get the JSON or binary serialization for the request message type.
-     */
-    getI(useBinaryFormat: boolean): Serialization<I>;
-    /**
-     * Get the JSON or binary serialization for the response message type.
-     */
-    getO(useBinaryFormat: boolean): Serialization<O>;
-}
-/**
- * Returns functions to normalize and serialize the input message
- * of an RPC, and to parse the output message of an RPC.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function createClientMethodSerializers<I extends Message<I>, O extends Message<O>>(method: MethodInfo<I, O>, useBinaryFormat: boolean, jsonOptions?: JsonSerializationOptions, binaryOptions?: BinarySerializationOptions): {
-    parse: (data: Uint8Array) => O;
-    serialize: (data: I) => Uint8Array;
-};
-/**
- * Apply I/O limits to a Serialization object, returning a new object.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function limitSerialization<T>(serialization: Serialization<T>, limitOptions: {
-    writeMaxBytes: number;
-    readMaxBytes: number;
-}): Serialization<T>;
-/**
- * Options for createBinarySerialization()
- */
-type BinarySerializationOptions = Partial<BinaryReadOptions & BinaryWriteOptions>;
-/**
- * Creates a Serialization object for serializing the given protobuf message
- * with the protobuf binary format.
- */
-export declare function createBinarySerialization<T extends Message<T>>(messageType: MessageType<T>, options: BinarySerializationOptions | undefined): Serialization<T>;
-/**
- * Options for createJsonSerialization()
- */
-type JsonSerializationOptions = Partial<JsonReadOptions & JsonWriteOptions> & {
-    textEncoder?: {
-        encode(input?: string): Uint8Array;
-    };
-    textDecoder?: {
-        decode(input?: Uint8Array): string;
-    };
-};
-/**
- * Creates a Serialization object for serializing the given protobuf message
- * with the protobuf canonical JSON encoding.
- *
- * By default, unknown fields are ignored.
- */
-export declare function createJsonSerialization<T extends Message<T>>(messageType: MessageType<T>, options: JsonSerializationOptions | undefined): Serialization<T>;
-export {};

package/node_modules/@connectrpc/connect/dist/cjs/protocol/serialization.js

@@ -1,148 +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.getJsonOptions = getJsonOptions;
-exports.createMethodSerializationLookup = createMethodSerializationLookup;
-exports.createClientMethodSerializers = createClientMethodSerializers;
-exports.limitSerialization = limitSerialization;
-exports.createBinarySerialization = createBinarySerialization;
-exports.createJsonSerialization = createJsonSerialization;
-const connect_error_js_1 = require("../connect-error.js");
-const code_js_1 = require("../code.js");
-const limit_io_js_1 = require("./limit-io.js");
-/**
- * Sets default JSON serialization options for connect-es.
- *
- * With standard protobuf JSON serialization, unknown JSON fields are
- * rejected by default. In connect-es, unknown JSON fields are ignored
- * by default.
- */
-function getJsonOptions(options) {
-    var _a;
-    const o = Object.assign({}, options);
-    (_a = o.ignoreUnknownFields) !== null && _a !== void 0 ? _a : (o.ignoreUnknownFields = true);
-    return o;
-}
-/**
- * Create an object that provides convenient access to request and response
- * message serialization for a given method.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-function createMethodSerializationLookup(method, binaryOptions, jsonOptions, limitOptions) {
-    const inputBinary = limitSerialization(createBinarySerialization(method.I, binaryOptions), limitOptions);
-    const inputJson = limitSerialization(createJsonSerialization(method.I, jsonOptions), limitOptions);
-    const outputBinary = limitSerialization(createBinarySerialization(method.O, binaryOptions), limitOptions);
-    const outputJson = limitSerialization(createJsonSerialization(method.O, jsonOptions), limitOptions);
-    return {
-        getI(useBinaryFormat) {
-            return useBinaryFormat ? inputBinary : inputJson;
-        },
-        getO(useBinaryFormat) {
-            return useBinaryFormat ? outputBinary : outputJson;
-        },
-    };
-}
-/**
- * Returns functions to normalize and serialize the input message
- * of an RPC, and to parse the output message of an RPC.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-function createClientMethodSerializers(method, useBinaryFormat, jsonOptions, binaryOptions) {
-    const input = useBinaryFormat
-        ? createBinarySerialization(method.I, binaryOptions)
-        : createJsonSerialization(method.I, jsonOptions);
-    const output = useBinaryFormat
-        ? createBinarySerialization(method.O, binaryOptions)
-        : createJsonSerialization(method.O, jsonOptions);
-    return { parse: output.parse, serialize: input.serialize };
-}
-/**
- * Apply I/O limits to a Serialization object, returning a new object.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-function limitSerialization(serialization, limitOptions) {
-    return {
-        serialize(data) {
-            const bytes = serialization.serialize(data);
-            (0, limit_io_js_1.assertWriteMaxBytes)(limitOptions.writeMaxBytes, bytes.byteLength);
-            return bytes;
-        },
-        parse(data) {
-            (0, limit_io_js_1.assertReadMaxBytes)(limitOptions.readMaxBytes, data.byteLength, true);
-            return serialization.parse(data);
-        },
-    };
-}
-/**
- * Creates a Serialization object for serializing the given protobuf message
- * with the protobuf binary format.
- */
-function createBinarySerialization(messageType, options) {
-    return {
-        parse(data) {
-            try {
-                return messageType.fromBinary(data, options);
-            }
-            catch (e) {
-                const m = e instanceof Error ? e.message : String(e);
-                throw new connect_error_js_1.ConnectError(`parse binary: ${m}`, code_js_1.Code.Internal);
-            }
-        },
-        serialize(data) {
-            try {
-                return data.toBinary(options);
-            }
-            catch (e) {
-                const m = e instanceof Error ? e.message : String(e);
-                throw new connect_error_js_1.ConnectError(`serialize binary: ${m}`, code_js_1.Code.Internal);
-            }
-        },
-    };
-}
-/**
- * Creates a Serialization object for serializing the given protobuf message
- * with the protobuf canonical JSON encoding.
- *
- * By default, unknown fields are ignored.
- */
-function createJsonSerialization(messageType, options) {
-    var _a, _b;
-    const textEncoder = (_a = options === null || options === void 0 ? void 0 : options.textEncoder) !== null && _a !== void 0 ? _a : new TextEncoder();
-    const textDecoder = (_b = options === null || options === void 0 ? void 0 : options.textDecoder) !== null && _b !== void 0 ? _b : new TextDecoder();
-    const o = getJsonOptions(options);
-    return {
-        parse(data) {
-            try {
-                const json = textDecoder.decode(data);
-                return messageType.fromJsonString(json, o);
-            }
-            catch (e) {
-                throw connect_error_js_1.ConnectError.from(e, code_js_1.Code.InvalidArgument);
-            }
-        },
-        serialize(data) {
-            try {
-                const json = data.toJsonString(o);
-                return textEncoder.encode(json);
-            }
-            catch (e) {
-                throw connect_error_js_1.ConnectError.from(e, code_js_1.Code.Internal);
-            }
-        },
-    };
-}

package/node_modules/@connectrpc/connect/dist/cjs/protocol/signals.d.ts

@@ -1,36 +0,0 @@
-/**
- * Create an AbortController that is automatically aborted if one of the given
- * signals is aborted.
- *
- * For convenience, the linked AbortSignals can be undefined.
- *
- * If the controller or any of the signals is aborted, all event listeners are
- * removed.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function createLinkedAbortController(...signals: (AbortSignal | undefined)[]): AbortController;
-/**
- * Create a deadline signal. The returned object contains an AbortSignal, but
- * also a cleanup function to stop the timer, which must be called once the
- * calling code is no longer interested in the signal.
- *
- * Ideally, we would simply use AbortSignal.timeout(), but it is not widely
- * available yet.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function createDeadlineSignal(timeoutMs: number | undefined): {
-    signal: AbortSignal;
-    cleanup: () => void;
-};
-/**
- * Returns the reason why an AbortSignal was aborted. Returns undefined if the
- * signal has not been aborted.
- *
- * The property AbortSignal.reason is not widely available. This function
- * returns an AbortError if the signal is aborted, but reason is undefined.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function getAbortSignalReason(signal: AbortSignal): unknown;

package/node_modules/@connectrpc/connect/dist/cjs/protocol/signals.js

@@ -1,100 +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.createLinkedAbortController = createLinkedAbortController;
-exports.createDeadlineSignal = createDeadlineSignal;
-exports.getAbortSignalReason = getAbortSignalReason;
-const connect_error_js_1 = require("../connect-error.js");
-const code_js_1 = require("../code.js");
-/**
- * Create an AbortController that is automatically aborted if one of the given
- * signals is aborted.
- *
- * For convenience, the linked AbortSignals can be undefined.
- *
- * If the controller or any of the signals is aborted, all event listeners are
- * removed.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-function createLinkedAbortController(...signals) {
-    const controller = new AbortController();
-    const sa = signals.filter((s) => s !== undefined).concat(controller.signal);
-    for (const signal of sa) {
-        if (signal.aborted) {
-            onAbort.apply(signal);
-            break;
-        }
-        signal.addEventListener("abort", onAbort);
-    }
-    function onAbort() {
-        if (!controller.signal.aborted) {
-            controller.abort(getAbortSignalReason(this));
-        }
-        for (const signal of sa) {
-            signal.removeEventListener("abort", onAbort);
-        }
-    }
-    return controller;
-}
-/**
- * Create a deadline signal. The returned object contains an AbortSignal, but
- * also a cleanup function to stop the timer, which must be called once the
- * calling code is no longer interested in the signal.
- *
- * Ideally, we would simply use AbortSignal.timeout(), but it is not widely
- * available yet.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-function createDeadlineSignal(timeoutMs) {
-    const controller = new AbortController();
-    const listener = () => {
-        controller.abort(new connect_error_js_1.ConnectError("the operation timed out", code_js_1.Code.DeadlineExceeded));
-    };
-    let timeoutId;
-    if (timeoutMs !== undefined) {
-        if (timeoutMs <= 0)
-            listener();
-        else
-            timeoutId = setTimeout(listener, timeoutMs);
-    }
-    return {
-        signal: controller.signal,
-        cleanup: () => clearTimeout(timeoutId),
-    };
-}
-/**
- * Returns the reason why an AbortSignal was aborted. Returns undefined if the
- * signal has not been aborted.
- *
- * The property AbortSignal.reason is not widely available. This function
- * returns an AbortError if the signal is aborted, but reason is undefined.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-function getAbortSignalReason(signal) {
-    if (!signal.aborted) {
-        return undefined;
-    }
-    if (signal.reason !== undefined) {
-        return signal.reason;
-    }
-    // AbortSignal.reason is available in Node.js v16, v18, and later,
-    // and in all browsers since early 2022.
-    const e = new Error("This operation was aborted");
-    e.name = "AbortError";
-    return e;
-}

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

@@ -1,98 +0,0 @@
-import type { BinaryReadOptions, BinaryWriteOptions, JsonReadOptions, JsonWriteOptions } from "@bufbuild/protobuf";
-import type { UniversalClientFn } from "./universal.js";
-import type { Interceptor } from "../interceptor.js";
-import type { Compression } from "./compression.js";
-/**
- * @private Internal code, does not follow semantic versioning.
- */
-export interface CommonTransportOptions {
-    /**
-     * The HTTP client to use.
-     */
-    httpClient: UniversalClientFn;
-    /**
-     * 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 | null;
-    /**
-     * 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;
-}

package/node_modules/@connectrpc/connect/dist/cjs/protocol/transport-options.js

@@ -1,15 +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 });

package/node_modules/@connectrpc/connect/dist/cjs/protocol/universal-fetch.d.ts

@@ -1,35 +0,0 @@
-import type { UniversalClientFn, UniversalClientRequest, UniversalClientResponse, UniversalHandlerFn, UniversalServerRequest, UniversalServerResponse } from "./universal.js";
-/**
- * Create a universal client function, a minimal abstraction of an HTTP client,
- * using the given fetch() implementation.
- */
-export declare function createFetchClient(fetchFn: typeof fetch): UniversalClientFn;
-/**
- * FetchHandlerFn is a minimal abstraction of an HTTP handler with the fetch API
- * Request and Response types.
- */
-type FetchHandlerFn = (req: Request) => Promise<Response>;
-interface FetchHandlerOptions {
-    httpVersion?: string;
-}
-/**
- * Convert a universal handler function to a fetch handler.
- */
-export declare function createFetchHandler(uHandler: UniversalHandlerFn, options?: FetchHandlerOptions): FetchHandlerFn;
-/**
- * Convert a universal client request to a fetch request.
- */
-export declare function universalClientRequestToFetch(req: UniversalClientRequest): Request;
-/**
- * Convert a fetch response to a universal client response.
- */
-export declare function universalClientResponseFromFetch(res: Response): UniversalClientResponse;
-/**
- * Convert a fetch request to a universal server request.
- */
-export declare function universalServerRequestFromFetch(req: Request, options: FetchHandlerOptions): UniversalServerRequest;
-/**
- * Convert a universal server response to a fetch response.
- */
-export declare function universalServerResponseToFetch(res: UniversalServerResponse): Response;
-export {};

package/node_modules/@connectrpc/connect/dist/cjs/protocol/universal-fetch.js

@@ -1,150 +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.createFetchClient = createFetchClient;
-exports.createFetchHandler = createFetchHandler;
-exports.universalClientRequestToFetch = universalClientRequestToFetch;
-exports.universalClientResponseFromFetch = universalClientResponseFromFetch;
-exports.universalServerRequestFromFetch = universalServerRequestFromFetch;
-exports.universalServerResponseToFetch = universalServerResponseToFetch;
-/**
- * Create a universal client function, a minimal abstraction of an HTTP client,
- * using the given fetch() implementation.
- */
-function createFetchClient(fetchFn) {
-    return async function fetchClient(request) {
-        const res = await fetchFn(universalClientRequestToFetch(request));
-        return universalClientResponseFromFetch(res);
-    };
-}
-/**
- * Convert a universal handler function to a fetch handler.
- */
-function createFetchHandler(uHandler, options) {
-    async function handleFetch(req) {
-        const uReq = universalServerRequestFromFetch(req, options !== null && options !== void 0 ? options : {});
-        const uRes = await uHandler(uReq);
-        return universalServerResponseToFetch(uRes);
-    }
-    return Object.assign(handleFetch, uHandler);
-}
-/**
- * Convert a universal client request to a fetch request.
- */
-function universalClientRequestToFetch(req) {
-    const body = req.body === undefined ? null : iterableToReadableStream(req.body);
-    return new Request(req.url, {
-        method: req.method,
-        headers: req.header,
-        signal: req.signal,
-        body,
-    });
-}
-/**
- * Convert a fetch response to a universal client response.
- */
-function universalClientResponseFromFetch(res) {
-    return {
-        status: res.status,
-        header: res.headers,
-        body: iterableFromReadableStream(res.body),
-        trailer: new Headers(),
-    };
-}
-/**
- * Convert a fetch request to a universal server request.
- */
-function universalServerRequestFromFetch(req, options) {
-    var _a;
-    return {
-        httpVersion: (_a = options.httpVersion) !== null && _a !== void 0 ? _a : "",
-        method: req.method,
-        url: req.url,
-        header: req.headers,
-        body: iterableFromReadableStream(req.body),
-        signal: req.signal,
-    };
-}
-/**
- * Convert a universal server response to a fetch response.
- */
-function universalServerResponseToFetch(res) {
-    let body = null;
-    if (res.body !== undefined) {
-        body = iterableToReadableStream(res.body);
-    }
-    return new Response(body, {
-        status: res.status,
-        headers: res.header,
-    });
-}
-function iterableToReadableStream(iterable) {
-    const it = iterable[Symbol.asyncIterator]();
-    return new ReadableStream({
-        async pull(controller) {
-            const r = await it.next();
-            if (r.done === true) {
-                controller.close();
-                return;
-            }
-            controller.enqueue(r.value);
-        },
-        async cancel(reason) {
-            if (it.throw) {
-                try {
-                    await it.throw(reason);
-                }
-                catch (_a) {
-                    // iterator.throw on a generator function rethrows unless the
-                    // body catches and swallows.
-                }
-            }
-        },
-    });
-}
-function iterableFromReadableStream(body) {
-    const reader = body === null || body === void 0 ? void 0 : body.getReader();
-    return {
-        [Symbol.asyncIterator]() {
-            return {
-                async next() {
-                    if (reader !== undefined) {
-                        const r = await reader.read();
-                        if (r.done) {
-                            return {
-                                done: true,
-                                value: undefined,
-                            };
-                        }
-                        return r;
-                    }
-                    return {
-                        done: true,
-                        value: undefined,
-                    };
-                },
-                async throw(e) {
-                    if (reader !== undefined) {
-                        await reader.cancel(e);
-                    }
-                    return {
-                        done: true,
-                        value: undefined,
-                    };
-                },
-            };
-        },
-    };
-}