@smapiot/piral-cloud-node 0.18.0 → 1.13.0-pre.20240129.1

package/lib/{index.js → index.cjs.js}

@@ -1,9 +1,26 @@
 var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -22,33 +39,12 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
 
-// ../../node_modules/web-streams-polyfill/dist/ponyfill.es2018.js
+// ../../../node_modules/web-streams-polyfill/dist/ponyfill.es2018.js
 var require_ponyfill_es2018 = __commonJS({
-  "../../node_modules/web-streams-polyfill/dist/ponyfill.es2018.js"(exports, module2) {
+  "../../../node_modules/web-streams-polyfill/dist/ponyfill.es2018.js"(exports, module2) {
     (function(global2, factory) {
       typeof exports === "object" && typeof module2 !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.WebStreamsPolyfill = {}));
     })(exports, function(exports2) {
@@ -57,30 +53,27 @@ var require_ponyfill_es2018 = __commonJS({
       function noop2() {
         return void 0;
       }
-      function getGlobals() {
-        if (typeof self !== "undefined") {
-          return self;
-        } else if (typeof window !== "undefined") {
-          return window;
-        } else if (typeof global !== "undefined") {
-          return global;
-        }
-        return void 0;
-      }
-      const globals = getGlobals();
       function typeIsObject(x2) {
         return typeof x2 === "object" && x2 !== null || typeof x2 === "function";
       }
       const rethrowAssertionErrorRejection = noop2;
+      function setFunctionName(fn, name) {
+        try {
+          Object.defineProperty(fn, "name", {
+            value: name,
+            configurable: true
+          });
+        } catch (_a) {
+        }
+      }
       const originalPromise = Promise;
       const originalPromiseThen = Promise.prototype.then;
-      const originalPromiseResolve = Promise.resolve.bind(originalPromise);
       const originalPromiseReject = Promise.reject.bind(originalPromise);
       function newPromise(executor) {
         return new originalPromise(executor);
       }
       function promiseResolvedWith(value) {
-        return originalPromiseResolve(value);
+        return newPromise((resolve) => resolve(value));
       }
       function promiseRejectedWith(reason) {
         return originalPromiseReject(reason);
@@ -103,14 +96,15 @@ var require_ponyfill_es2018 = __commonJS({
       function setPromiseIsHandledToTrue(promise) {
         PerformPromiseThen(promise, void 0, rethrowAssertionErrorRejection);
       }
-      const queueMicrotask = (() => {
-        const globalQueueMicrotask = globals && globals.queueMicrotask;
-        if (typeof globalQueueMicrotask === "function") {
-          return globalQueueMicrotask;
+      let _queueMicrotask = (callback) => {
+        if (typeof queueMicrotask === "function") {
+          _queueMicrotask = queueMicrotask;
+        } else {
+          const resolvedPromise = promiseResolvedWith(void 0);
+          _queueMicrotask = (cb) => PerformPromiseThen(resolvedPromise, cb);
         }
-        const resolvedPromise = promiseResolvedWith(void 0);
-        return (fn) => PerformPromiseThen(resolvedPromise, fn);
-      })();
+        return _queueMicrotask(callback);
+      };
       function reflectCall(F2, V, args) {
         if (typeof F2 !== "function") {
           throw new TypeError("Argument is not a function");
@@ -198,6 +192,11 @@ var require_ponyfill_es2018 = __commonJS({
           return front._elements[cursor];
         }
       }
+      const AbortSteps = SymbolPolyfill("[[AbortSteps]]");
+      const ErrorSteps = SymbolPolyfill("[[ErrorSteps]]");
+      const CancelSteps = SymbolPolyfill("[[CancelSteps]]");
+      const PullSteps = SymbolPolyfill("[[PullSteps]]");
+      const ReleaseSteps = SymbolPolyfill("[[ReleaseSteps]]");
       function ReadableStreamReaderGenericInitialize(reader, stream) {
         reader._ownerReadableStream = stream;
         stream._reader = reader;
@@ -214,12 +213,14 @@ var require_ponyfill_es2018 = __commonJS({
         return ReadableStreamCancel(stream, reason);
       }
       function ReadableStreamReaderGenericRelease(reader) {
-        if (reader._ownerReadableStream._state === "readable") {
+        const stream = reader._ownerReadableStream;
+        if (stream._state === "readable") {
           defaultReaderClosedPromiseReject(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
         } else {
           defaultReaderClosedPromiseResetToRejected(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
         }
-        reader._ownerReadableStream._reader = void 0;
+        stream._readableStreamController[ReleaseSteps]();
+        stream._reader = void 0;
         reader._ownerReadableStream = void 0;
       }
       function readerLockException(name) {
@@ -259,10 +260,6 @@ var require_ponyfill_es2018 = __commonJS({
         reader._closedPromise_resolve = void 0;
         reader._closedPromise_reject = void 0;
       }
-      const AbortSteps = SymbolPolyfill("[[AbortSteps]]");
-      const ErrorSteps = SymbolPolyfill("[[ErrorSteps]]");
-      const CancelSteps = SymbolPolyfill("[[CancelSteps]]");
-      const PullSteps = SymbolPolyfill("[[PullSteps]]");
       const NumberIsFinite = Number.isFinite || function(x2) {
         return typeof x2 === "number" && isFinite(x2);
       };
@@ -412,10 +409,7 @@ var require_ponyfill_es2018 = __commonJS({
           if (this._ownerReadableStream === void 0) {
             return;
           }
-          if (this._readRequests.length > 0) {
-            throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");
-          }
-          ReadableStreamReaderGenericRelease(this);
+          ReadableStreamDefaultReaderRelease(this);
         }
       }
       Object.defineProperties(ReadableStreamDefaultReader.prototype, {
@@ -424,6 +418,9 @@ var require_ponyfill_es2018 = __commonJS({
         releaseLock: { enumerable: true },
         closed: { enumerable: true }
       });
+      setFunctionName(ReadableStreamDefaultReader.prototype.cancel, "cancel");
+      setFunctionName(ReadableStreamDefaultReader.prototype.read, "read");
+      setFunctionName(ReadableStreamDefaultReader.prototype.releaseLock, "releaseLock");
       if (typeof SymbolPolyfill.toStringTag === "symbol") {
         Object.defineProperty(ReadableStreamDefaultReader.prototype, SymbolPolyfill.toStringTag, {
           value: "ReadableStreamDefaultReader",
@@ -450,6 +447,18 @@ var require_ponyfill_es2018 = __commonJS({
           stream._readableStreamController[PullSteps](readRequest);
         }
       }
+      function ReadableStreamDefaultReaderRelease(reader) {
+        ReadableStreamReaderGenericRelease(reader);
+        const e2 = new TypeError("Reader was released");
+        ReadableStreamDefaultReaderErrorReadRequests(reader, e2);
+      }
+      function ReadableStreamDefaultReaderErrorReadRequests(reader, e2) {
+        const readRequests = reader._readRequests;
+        reader._readRequests = new SimpleQueue();
+        readRequests.forEach((readRequest) => {
+          readRequest._errorSteps(e2);
+        });
+      }
       function defaultReaderBrandCheckException(name) {
         return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
       }
@@ -476,9 +485,6 @@ var require_ponyfill_es2018 = __commonJS({
             return Promise.resolve({ value: void 0, done: true });
           }
           const reader = this._reader;
-          if (reader._ownerReadableStream === void 0) {
-            return promiseRejectedWith(readerLockException("iterate"));
-          }
           let resolvePromise;
           let rejectPromise;
           const promise = newPromise((resolve, reject) => {
@@ -488,7 +494,7 @@ var require_ponyfill_es2018 = __commonJS({
           const readRequest = {
             _chunkSteps: (chunk) => {
               this._ongoingPromise = void 0;
-              queueMicrotask(() => resolvePromise({ value: chunk, done: false }));
+              _queueMicrotask(() => resolvePromise({ value: chunk, done: false }));
             },
             _closeSteps: () => {
               this._ongoingPromise = void 0;
@@ -512,9 +518,6 @@ var require_ponyfill_es2018 = __commonJS({
           }
           this._isFinished = true;
           const reader = this._reader;
-          if (reader._ownerReadableStream === void 0) {
-            return promiseRejectedWith(readerLockException("finish iterating"));
-          }
           if (!this._preventCancel) {
             const result = ReadableStreamReaderGenericCancel(reader, value);
             ReadableStreamReaderGenericRelease(reader);
@@ -557,7 +560,7 @@ var require_ponyfill_es2018 = __commonJS({
         }
         try {
           return x2._asyncIteratorImpl instanceof ReadableStreamAsyncIteratorImpl;
-        } catch (_a4) {
+        } catch (_a) {
           return false;
         }
       }
@@ -573,12 +576,24 @@ var require_ponyfill_es2018 = __commonJS({
       function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {
         new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
       }
-      function TransferArrayBuffer(O) {
-        return O;
-      }
-      function IsDetachedBuffer(O) {
-        return false;
-      }
+      let TransferArrayBuffer = (O) => {
+        if (typeof O.transfer === "function") {
+          TransferArrayBuffer = (buffer) => buffer.transfer();
+        } else if (typeof structuredClone === "function") {
+          TransferArrayBuffer = (buffer) => structuredClone(buffer, { transfer: [buffer] });
+        } else {
+          TransferArrayBuffer = (buffer) => buffer;
+        }
+        return TransferArrayBuffer(O);
+      };
+      let IsDetachedBuffer = (O) => {
+        if (typeof O.detached === "boolean") {
+          IsDetachedBuffer = (buffer) => buffer.detached;
+        } else {
+          IsDetachedBuffer = (buffer) => buffer.byteLength === 0;
+        }
+        return IsDetachedBuffer(O);
+      };
       function ArrayBufferSlice(buffer, begin, end) {
         if (buffer.slice) {
           return buffer.slice(begin, end);
@@ -588,6 +603,62 @@ var require_ponyfill_es2018 = __commonJS({
         CopyDataBlockBytes(slice, 0, buffer, begin, length);
         return slice;
       }
+      function GetMethod(receiver, prop) {
+        const func = receiver[prop];
+        if (func === void 0 || func === null) {
+          return void 0;
+        }
+        if (typeof func !== "function") {
+          throw new TypeError(`${String(prop)} is not a function`);
+        }
+        return func;
+      }
+      function CreateAsyncFromSyncIterator(syncIteratorRecord) {
+        const syncIterable = {
+          [SymbolPolyfill.iterator]: () => syncIteratorRecord.iterator
+        };
+        const asyncIterator = async function* () {
+          return yield* syncIterable;
+        }();
+        const nextMethod = asyncIterator.next;
+        return { iterator: asyncIterator, nextMethod, done: false };
+      }
+      function GetIterator(obj, hint = "sync", method) {
+        if (method === void 0) {
+          if (hint === "async") {
+            method = GetMethod(obj, SymbolPolyfill.asyncIterator);
+            if (method === void 0) {
+              const syncMethod = GetMethod(obj, SymbolPolyfill.iterator);
+              const syncIteratorRecord = GetIterator(obj, "sync", syncMethod);
+              return CreateAsyncFromSyncIterator(syncIteratorRecord);
+            }
+          } else {
+            method = GetMethod(obj, SymbolPolyfill.iterator);
+          }
+        }
+        if (method === void 0) {
+          throw new TypeError("The object is not iterable");
+        }
+        const iterator = reflectCall(method, obj, []);
+        if (!typeIsObject(iterator)) {
+          throw new TypeError("The iterator method must return an object");
+        }
+        const nextMethod = iterator.next;
+        return { iterator, nextMethod, done: false };
+      }
+      function IteratorNext(iteratorRecord) {
+        const result = reflectCall(iteratorRecord.nextMethod, iteratorRecord.iterator, []);
+        if (!typeIsObject(result)) {
+          throw new TypeError("The iterator.next() method must return an object");
+        }
+        return result;
+      }
+      function IteratorComplete(iterResult) {
+        return Boolean(iterResult.done);
+      }
+      function IteratorValue(iterResult) {
+        return iterResult.value;
+      }
       function IsNonNegativeNumber(v) {
         if (typeof v !== "number") {
           return false;
@@ -627,6 +698,18 @@ var require_ponyfill_es2018 = __commonJS({
         container._queue = new SimpleQueue();
         container._queueTotalSize = 0;
       }
+      function isDataViewConstructor(ctor) {
+        return ctor === DataView;
+      }
+      function isDataView(view) {
+        return isDataViewConstructor(view.constructor);
+      }
+      function arrayBufferViewElementSize(ctor) {
+        if (isDataViewConstructor(ctor)) {
+          return 1;
+        }
+        return ctor.BYTES_PER_ELEMENT;
+      }
       class ReadableStreamBYOBRequest {
         constructor() {
           throw new TypeError("Illegal constructor");
@@ -646,8 +729,9 @@ var require_ponyfill_es2018 = __commonJS({
           if (this._associatedReadableByteStreamController === void 0) {
             throw new TypeError("This BYOB request has been invalidated");
           }
-          if (IsDetachedBuffer(this._view.buffer))
-            ;
+          if (IsDetachedBuffer(this._view.buffer)) {
+            throw new TypeError(`The BYOB request's buffer has been detached and so cannot be used as a response`);
+          }
           ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
         }
         respondWithNewView(view) {
@@ -661,8 +745,9 @@ var require_ponyfill_es2018 = __commonJS({
           if (this._associatedReadableByteStreamController === void 0) {
             throw new TypeError("This BYOB request has been invalidated");
           }
-          if (IsDetachedBuffer(view.buffer))
-            ;
+          if (IsDetachedBuffer(view.buffer)) {
+            throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
+          }
           ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
         }
       }
@@ -671,6 +756,8 @@ var require_ponyfill_es2018 = __commonJS({
         respondWithNewView: { enumerable: true },
         view: { enumerable: true }
       });
+      setFunctionName(ReadableStreamBYOBRequest.prototype.respond, "respond");
+      setFunctionName(ReadableStreamBYOBRequest.prototype.respondWithNewView, "respondWithNewView");
       if (typeof SymbolPolyfill.toStringTag === "symbol") {
         Object.defineProperty(ReadableStreamBYOBRequest.prototype, SymbolPolyfill.toStringTag, {
           value: "ReadableStreamBYOBRequest",
@@ -745,11 +832,7 @@ var require_ponyfill_es2018 = __commonJS({
         [PullSteps](readRequest) {
           const stream = this._controlledReadableByteStream;
           if (this._queueTotalSize > 0) {
-            const entry = this._queue.shift();
-            this._queueTotalSize -= entry.byteLength;
-            ReadableByteStreamControllerHandleQueueDrain(this);
-            const view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
-            readRequest._chunkSteps(view);
+            ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest);
             return;
           }
           const autoAllocateChunkSize = this._autoAllocateChunkSize;
@@ -767,6 +850,7 @@ var require_ponyfill_es2018 = __commonJS({
               byteOffset: 0,
               byteLength: autoAllocateChunkSize,
               bytesFilled: 0,
+              minimumFill: 1,
               elementSize: 1,
               viewConstructor: Uint8Array,
               readerType: "default"
@@ -776,6 +860,14 @@ var require_ponyfill_es2018 = __commonJS({
           ReadableStreamAddReadRequest(stream, readRequest);
           ReadableByteStreamControllerCallPullIfNeeded(this);
         }
+        [ReleaseSteps]() {
+          if (this._pendingPullIntos.length > 0) {
+            const firstPullInto = this._pendingPullIntos.peek();
+            firstPullInto.readerType = "none";
+            this._pendingPullIntos = new SimpleQueue();
+            this._pendingPullIntos.push(firstPullInto);
+          }
+        }
       }
       Object.defineProperties(ReadableByteStreamController.prototype, {
         close: { enumerable: true },
@@ -784,6 +876,9 @@ var require_ponyfill_es2018 = __commonJS({
         byobRequest: { enumerable: true },
         desiredSize: { enumerable: true }
       });
+      setFunctionName(ReadableByteStreamController.prototype.close, "close");
+      setFunctionName(ReadableByteStreamController.prototype.enqueue, "enqueue");
+      setFunctionName(ReadableByteStreamController.prototype.error, "error");
       if (typeof SymbolPolyfill.toStringTag === "symbol") {
         Object.defineProperty(ReadableByteStreamController.prototype, SymbolPolyfill.toStringTag, {
           value: "ReadableByteStreamController",
@@ -825,8 +920,10 @@ var require_ponyfill_es2018 = __commonJS({
             controller._pullAgain = false;
             ReadableByteStreamControllerCallPullIfNeeded(controller);
           }
+          return null;
         }, (e2) => {
           ReadableByteStreamControllerError(controller, e2);
+          return null;
         });
       }
       function ReadableByteStreamControllerClearPendingPullIntos(controller) {
@@ -854,15 +951,30 @@ var require_ponyfill_es2018 = __commonJS({
         controller._queue.push({ buffer, byteOffset, byteLength });
         controller._queueTotalSize += byteLength;
       }
+      function ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, buffer, byteOffset, byteLength) {
+        let clonedChunk;
+        try {
+          clonedChunk = ArrayBufferSlice(buffer, byteOffset, byteOffset + byteLength);
+        } catch (cloneE) {
+          ReadableByteStreamControllerError(controller, cloneE);
+          throw cloneE;
+        }
+        ReadableByteStreamControllerEnqueueChunkToQueue(controller, clonedChunk, 0, byteLength);
+      }
+      function ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstDescriptor) {
+        if (firstDescriptor.bytesFilled > 0) {
+          ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, firstDescriptor.buffer, firstDescriptor.byteOffset, firstDescriptor.bytesFilled);
+        }
+        ReadableByteStreamControllerShiftPendingPullInto(controller);
+      }
       function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
-        const elementSize = pullIntoDescriptor.elementSize;
-        const currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;
         const maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
         const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
-        const maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;
         let totalBytesToCopyRemaining = maxBytesToCopy;
         let ready = false;
-        if (maxAlignedBytes > currentAlignedBytes) {
+        const remainderBytes = maxBytesFilled % pullIntoDescriptor.elementSize;
+        const maxAlignedBytes = maxBytesFilled - remainderBytes;
+        if (maxAlignedBytes >= pullIntoDescriptor.minimumFill) {
           totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
           ready = true;
         }
@@ -915,20 +1027,36 @@ var require_ponyfill_es2018 = __commonJS({
           }
         }
       }
-      function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest) {
-        const stream = controller._controlledReadableByteStream;
-        let elementSize = 1;
-        if (view.constructor !== DataView) {
-          elementSize = view.constructor.BYTES_PER_ELEMENT;
+      function ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller) {
+        const reader = controller._controlledReadableByteStream._reader;
+        while (reader._readRequests.length > 0) {
+          if (controller._queueTotalSize === 0) {
+            return;
+          }
+          const readRequest = reader._readRequests.shift();
+          ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest);
         }
+      }
+      function ReadableByteStreamControllerPullInto(controller, view, min, readIntoRequest) {
+        const stream = controller._controlledReadableByteStream;
         const ctor = view.constructor;
-        const buffer = TransferArrayBuffer(view.buffer);
+        const elementSize = arrayBufferViewElementSize(ctor);
+        const { byteOffset, byteLength } = view;
+        const minimumFill = min * elementSize;
+        let buffer;
+        try {
+          buffer = TransferArrayBuffer(view.buffer);
+        } catch (e2) {
+          readIntoRequest._errorSteps(e2);
+          return;
+        }
         const pullIntoDescriptor = {
           buffer,
           bufferByteLength: buffer.byteLength,
-          byteOffset: view.byteOffset,
-          byteLength: view.byteLength,
+          byteOffset,
+          byteLength,
           bytesFilled: 0,
+          minimumFill,
           elementSize,
           viewConstructor: ctor,
           readerType: "byob"
@@ -962,6 +1090,9 @@ var require_ponyfill_es2018 = __commonJS({
         ReadableByteStreamControllerCallPullIfNeeded(controller);
       }
       function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
+        if (firstDescriptor.readerType === "none") {
+          ReadableByteStreamControllerShiftPendingPullInto(controller);
+        }
         const stream = controller._controlledReadableByteStream;
         if (ReadableStreamHasBYOBReader(stream)) {
           while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
@@ -972,15 +1103,19 @@ var require_ponyfill_es2018 = __commonJS({
       }
       function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
         ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
-        if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {
+        if (pullIntoDescriptor.readerType === "none") {
+          ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, pullIntoDescriptor);
+          ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
+          return;
+        }
+        if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.minimumFill) {
           return;
         }
         ReadableByteStreamControllerShiftPendingPullInto(controller);
         const remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
         if (remainderSize > 0) {
           const end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
-          const remainder = ArrayBufferSlice(pullIntoDescriptor.buffer, end - remainderSize, end);
-          ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);
+          ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, pullIntoDescriptor.buffer, end - remainderSize, remainderSize);
         }
         pullIntoDescriptor.bytesFilled -= remainderSize;
         ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
@@ -991,7 +1126,7 @@ var require_ponyfill_es2018 = __commonJS({
         ReadableByteStreamControllerInvalidateBYOBRequest(controller);
         const state = controller._controlledReadableByteStream._state;
         if (state === "closed") {
-          ReadableByteStreamControllerRespondInClosedState(controller);
+          ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
         } else {
           ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
         }
@@ -1039,7 +1174,7 @@ var require_ponyfill_es2018 = __commonJS({
         }
         if (controller._pendingPullIntos.length > 0) {
           const firstPendingPullInto = controller._pendingPullIntos.peek();
-          if (firstPendingPullInto.bytesFilled > 0) {
+          if (firstPendingPullInto.bytesFilled % firstPendingPullInto.elementSize !== 0) {
             const e2 = new TypeError("Insufficient bytes to fill elements in the given buffer");
             ReadableByteStreamControllerError(controller, e2);
             throw e2;
@@ -1053,18 +1188,24 @@ var require_ponyfill_es2018 = __commonJS({
         if (controller._closeRequested || stream._state !== "readable") {
           return;
         }
-        const buffer = chunk.buffer;
-        const byteOffset = chunk.byteOffset;
-        const byteLength = chunk.byteLength;
+        const { buffer, byteOffset, byteLength } = chunk;
+        if (IsDetachedBuffer(buffer)) {
+          throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
+        }
         const transferredBuffer = TransferArrayBuffer(buffer);
         if (controller._pendingPullIntos.length > 0) {
           const firstPendingPullInto = controller._pendingPullIntos.peek();
-          if (IsDetachedBuffer(firstPendingPullInto.buffer))
-            ;
+          if (IsDetachedBuffer(firstPendingPullInto.buffer)) {
+            throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");
+          }
+          ReadableByteStreamControllerInvalidateBYOBRequest(controller);
           firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer);
+          if (firstPendingPullInto.readerType === "none") {
+            ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstPendingPullInto);
+          }
         }
-        ReadableByteStreamControllerInvalidateBYOBRequest(controller);
         if (ReadableStreamHasDefaultReader(stream)) {
+          ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller);
           if (ReadableStreamGetNumReadRequests(stream) === 0) {
             ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
           } else {
@@ -1092,6 +1233,13 @@ var require_ponyfill_es2018 = __commonJS({
         ReadableByteStreamControllerClearAlgorithms(controller);
         ReadableStreamError(stream, e2);
       }
+      function ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest) {
+        const entry = controller._queue.shift();
+        controller._queueTotalSize -= entry.byteLength;
+        ReadableByteStreamControllerHandleQueueDrain(controller);
+        const view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
+        readRequest._chunkSteps(view);
+      }
       function ReadableByteStreamControllerGetBYOBRequest(controller) {
         if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {
           const firstDescriptor = controller._pendingPullIntos.peek();
@@ -1174,23 +1322,31 @@ var require_ponyfill_es2018 = __commonJS({
         uponPromise(promiseResolvedWith(startResult), () => {
           controller._started = true;
           ReadableByteStreamControllerCallPullIfNeeded(controller);
+          return null;
         }, (r2) => {
           ReadableByteStreamControllerError(controller, r2);
+          return null;
         });
       }
       function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) {
         const controller = Object.create(ReadableByteStreamController.prototype);
-        let startAlgorithm = () => void 0;
-        let pullAlgorithm = () => promiseResolvedWith(void 0);
-        let cancelAlgorithm = () => promiseResolvedWith(void 0);
+        let startAlgorithm;
+        let pullAlgorithm;
+        let cancelAlgorithm;
         if (underlyingByteSource.start !== void 0) {
           startAlgorithm = () => underlyingByteSource.start(controller);
+        } else {
+          startAlgorithm = () => void 0;
         }
         if (underlyingByteSource.pull !== void 0) {
           pullAlgorithm = () => underlyingByteSource.pull(controller);
+        } else {
+          pullAlgorithm = () => promiseResolvedWith(void 0);
         }
         if (underlyingByteSource.cancel !== void 0) {
           cancelAlgorithm = (reason) => underlyingByteSource.cancel(reason);
+        } else {
+          cancelAlgorithm = () => promiseResolvedWith(void 0);
         }
         const autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
         if (autoAllocateChunkSize === 0) {
@@ -1208,6 +1364,28 @@ var require_ponyfill_es2018 = __commonJS({
       function byteStreamControllerBrandCheckException(name) {
         return new TypeError(`ReadableByteStreamController.prototype.${name} can only be used on a ReadableByteStreamController`);
       }
+      function convertReaderOptions(options, context) {
+        assertDictionary(options, context);
+        const mode = options === null || options === void 0 ? void 0 : options.mode;
+        return {
+          mode: mode === void 0 ? void 0 : convertReadableStreamReaderMode(mode, `${context} has member 'mode' that`)
+        };
+      }
+      function convertReadableStreamReaderMode(mode, context) {
+        mode = `${mode}`;
+        if (mode !== "byob") {
+          throw new TypeError(`${context} '${mode}' is not a valid enumeration value for ReadableStreamReaderMode`);
+        }
+        return mode;
+      }
+      function convertByobReadOptions(options, context) {
+        var _a;
+        assertDictionary(options, context);
+        const min = (_a = options === null || options === void 0 ? void 0 : options.min) !== null && _a !== void 0 ? _a : 1;
+        return {
+          min: convertUnsignedLongLongWithEnforceRange(min, `${context} has member 'min' that`)
+        };
+      }
       function AcquireReadableStreamBYOBReader(stream) {
         return new ReadableStreamBYOBReader(stream);
       }
@@ -1264,7 +1442,7 @@ var require_ponyfill_es2018 = __commonJS({
           }
           return ReadableStreamReaderGenericCancel(this, reason);
         }
-        read(view) {
+        read(view, rawOptions = {}) {
           if (!IsReadableStreamBYOBReader(this)) {
             return promiseRejectedWith(byobReaderBrandCheckException("read"));
           }
@@ -1277,8 +1455,26 @@ var require_ponyfill_es2018 = __commonJS({
           if (view.buffer.byteLength === 0) {
             return promiseRejectedWith(new TypeError(`view's buffer must have non-zero byteLength`));
           }
-          if (IsDetachedBuffer(view.buffer))
-            ;
+          if (IsDetachedBuffer(view.buffer)) {
+            return promiseRejectedWith(new TypeError("view's buffer has been detached"));
+          }
+          let options;
+          try {
+            options = convertByobReadOptions(rawOptions, "options");
+          } catch (e2) {
+            return promiseRejectedWith(e2);
+          }
+          const min = options.min;
+          if (min === 0) {
+            return promiseRejectedWith(new TypeError("options.min must be greater than 0"));
+          }
+          if (!isDataView(view)) {
+            if (min > view.length) {
+              return promiseRejectedWith(new RangeError("options.min must be less than or equal to view's length"));
+            }
+          } else if (min > view.byteLength) {
+            return promiseRejectedWith(new RangeError("options.min must be less than or equal to view's byteLength"));
+          }
           if (this._ownerReadableStream === void 0) {
             return promiseRejectedWith(readerLockException("read from"));
           }
@@ -1293,7 +1489,7 @@ var require_ponyfill_es2018 = __commonJS({
             _closeSteps: (chunk) => resolvePromise({ value: chunk, done: true }),
             _errorSteps: (e2) => rejectPromise(e2)
           };
-          ReadableStreamBYOBReaderRead(this, view, readIntoRequest);
+          ReadableStreamBYOBReaderRead(this, view, min, readIntoRequest);
           return promise;
         }
         releaseLock() {
@@ -1303,10 +1499,7 @@ var require_ponyfill_es2018 = __commonJS({
           if (this._ownerReadableStream === void 0) {
             return;
           }
-          if (this._readIntoRequests.length > 0) {
-            throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");
-          }
-          ReadableStreamReaderGenericRelease(this);
+          ReadableStreamBYOBReaderRelease(this);
         }
       }
       Object.defineProperties(ReadableStreamBYOBReader.prototype, {
@@ -1315,6 +1508,9 @@ var require_ponyfill_es2018 = __commonJS({
         releaseLock: { enumerable: true },
         closed: { enumerable: true }
       });
+      setFunctionName(ReadableStreamBYOBReader.prototype.cancel, "cancel");
+      setFunctionName(ReadableStreamBYOBReader.prototype.read, "read");
+      setFunctionName(ReadableStreamBYOBReader.prototype.releaseLock, "releaseLock");
       if (typeof SymbolPolyfill.toStringTag === "symbol") {
         Object.defineProperty(ReadableStreamBYOBReader.prototype, SymbolPolyfill.toStringTag, {
           value: "ReadableStreamBYOBReader",
@@ -1330,15 +1526,27 @@ var require_ponyfill_es2018 = __commonJS({
         }
         return x2 instanceof ReadableStreamBYOBReader;
       }
-      function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) {
+      function ReadableStreamBYOBReaderRead(reader, view, min, readIntoRequest) {
         const stream = reader._ownerReadableStream;
         stream._disturbed = true;
         if (stream._state === "errored") {
           readIntoRequest._errorSteps(stream._storedError);
         } else {
-          ReadableByteStreamControllerPullInto(stream._readableStreamController, view, readIntoRequest);
+          ReadableByteStreamControllerPullInto(stream._readableStreamController, view, min, readIntoRequest);
         }
       }
+      function ReadableStreamBYOBReaderRelease(reader) {
+        ReadableStreamReaderGenericRelease(reader);
+        const e2 = new TypeError("Reader was released");
+        ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e2);
+      }
+      function ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e2) {
+        const readIntoRequests = reader._readIntoRequests;
+        reader._readIntoRequests = new SimpleQueue();
+        readIntoRequests.forEach((readIntoRequest) => {
+          readIntoRequest._errorSteps(e2);
+        });
+      }
       function byobReaderBrandCheckException(name) {
         return new TypeError(`ReadableStreamBYOBReader.prototype.${name} can only be used on a ReadableStreamBYOBReader`);
       }
@@ -1414,7 +1622,7 @@ var require_ponyfill_es2018 = __commonJS({
         }
         try {
           return typeof value.aborted === "boolean";
-        } catch (_a4) {
+        } catch (_a) {
           return false;
         }
       }
@@ -1483,6 +1691,9 @@ var require_ponyfill_es2018 = __commonJS({
         getWriter: { enumerable: true },
         locked: { enumerable: true }
       });
+      setFunctionName(WritableStream.prototype.abort, "abort");
+      setFunctionName(WritableStream.prototype.close, "close");
+      setFunctionName(WritableStream.prototype.getWriter, "getWriter");
       if (typeof SymbolPolyfill.toStringTag === "symbol") {
         Object.defineProperty(WritableStream.prototype, SymbolPolyfill.toStringTag, {
           value: "WritableStream",
@@ -1527,12 +1738,12 @@ var require_ponyfill_es2018 = __commonJS({
         return true;
       }
       function WritableStreamAbort(stream, reason) {
-        var _a4;
+        var _a;
         if (stream._state === "closed" || stream._state === "errored") {
           return promiseResolvedWith(void 0);
         }
         stream._writableStreamController._abortReason = reason;
-        (_a4 = stream._writableStreamController._abortController) === null || _a4 === void 0 ? void 0 : _a4.abort();
+        (_a = stream._writableStreamController._abortController) === null || _a === void 0 ? void 0 : _a.abort(reason);
         const state = stream._state;
         if (state === "closed" || state === "errored") {
           return promiseResolvedWith(void 0);
@@ -1632,9 +1843,11 @@ var require_ponyfill_es2018 = __commonJS({
         uponPromise(promise, () => {
           abortRequest._resolve();
           WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+          return null;
         }, (reason) => {
           abortRequest._reject(reason);
           WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+          return null;
         });
       }
       function WritableStreamFinishInFlightWrite(stream) {
@@ -1813,6 +2026,10 @@ var require_ponyfill_es2018 = __commonJS({
         desiredSize: { enumerable: true },
         ready: { enumerable: true }
       });
+      setFunctionName(WritableStreamDefaultWriter.prototype.abort, "abort");
+      setFunctionName(WritableStreamDefaultWriter.prototype.close, "close");
+      setFunctionName(WritableStreamDefaultWriter.prototype.releaseLock, "releaseLock");
+      setFunctionName(WritableStreamDefaultWriter.prototype.write, "write");
       if (typeof SymbolPolyfill.toStringTag === "symbol") {
         Object.defineProperty(WritableStreamDefaultWriter.prototype, SymbolPolyfill.toStringTag, {
           value: "WritableStreamDefaultWriter",
@@ -1981,28 +2198,38 @@ var require_ponyfill_es2018 = __commonJS({
         uponPromise(startPromise, () => {
           controller._started = true;
           WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+          return null;
         }, (r2) => {
           controller._started = true;
           WritableStreamDealWithRejection(stream, r2);
+          return null;
         });
       }
       function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) {
         const controller = Object.create(WritableStreamDefaultController.prototype);
-        let startAlgorithm = () => void 0;
-        let writeAlgorithm = () => promiseResolvedWith(void 0);
-        let closeAlgorithm = () => promiseResolvedWith(void 0);
-        let abortAlgorithm = () => promiseResolvedWith(void 0);
+        let startAlgorithm;
+        let writeAlgorithm;
+        let closeAlgorithm;
+        let abortAlgorithm;
         if (underlyingSink.start !== void 0) {
           startAlgorithm = () => underlyingSink.start(controller);
+        } else {
+          startAlgorithm = () => void 0;
         }
         if (underlyingSink.write !== void 0) {
           writeAlgorithm = (chunk) => underlyingSink.write(chunk, controller);
+        } else {
+          writeAlgorithm = () => promiseResolvedWith(void 0);
         }
         if (underlyingSink.close !== void 0) {
           closeAlgorithm = () => underlyingSink.close();
+        } else {
+          closeAlgorithm = () => promiseResolvedWith(void 0);
         }
         if (underlyingSink.abort !== void 0) {
           abortAlgorithm = (reason) => underlyingSink.abort(reason);
+        } else {
+          abortAlgorithm = () => promiseResolvedWith(void 0);
         }
         SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
       }
@@ -2077,8 +2304,10 @@ var require_ponyfill_es2018 = __commonJS({
         WritableStreamDefaultControllerClearAlgorithms(controller);
         uponPromise(sinkClosePromise, () => {
           WritableStreamFinishInFlightClose(stream);
+          return null;
         }, (reason) => {
           WritableStreamFinishInFlightCloseWithError(stream, reason);
+          return null;
         });
       }
       function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
@@ -2094,11 +2323,13 @@ var require_ponyfill_es2018 = __commonJS({
             WritableStreamUpdateBackpressure(stream, backpressure);
           }
           WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+          return null;
         }, (reason) => {
           if (stream._state === "writable") {
             WritableStreamDefaultControllerClearAlgorithms(controller);
           }
           WritableStreamFinishInFlightWriteWithError(stream, reason);
+          return null;
         });
       }
       function WritableStreamDefaultControllerGetBackpressure(controller) {
@@ -2199,19 +2430,36 @@ var require_ponyfill_es2018 = __commonJS({
         writer._readyPromise_reject = void 0;
         writer._readyPromiseState = "fulfilled";
       }
-      const NativeDOMException = typeof DOMException !== "undefined" ? DOMException : void 0;
+      function getGlobals() {
+        if (typeof globalThis !== "undefined") {
+          return globalThis;
+        } else if (typeof self !== "undefined") {
+          return self;
+        } else if (typeof global !== "undefined") {
+          return global;
+        }
+        return void 0;
+      }
+      const globals = getGlobals();
       function isDOMExceptionConstructor(ctor) {
         if (!(typeof ctor === "function" || typeof ctor === "object")) {
           return false;
         }
+        if (ctor.name !== "DOMException") {
+          return false;
+        }
         try {
           new ctor();
           return true;
-        } catch (_a4) {
+        } catch (_a) {
           return false;
         }
       }
-      function createDOMExceptionPolyfill() {
+      function getFromGlobal() {
+        const ctor = globals === null || globals === void 0 ? void 0 : globals.DOMException;
+        return isDOMExceptionConstructor(ctor) ? ctor : void 0;
+      }
+      function createPolyfill() {
         const ctor = function DOMException3(message, name) {
           this.message = message || "";
           this.name = name || "Error";
@@ -2219,11 +2467,12 @@ var require_ponyfill_es2018 = __commonJS({
             Error.captureStackTrace(this, this.constructor);
           }
         };
+        setFunctionName(ctor, "DOMException");
         ctor.prototype = Object.create(Error.prototype);
         Object.defineProperty(ctor.prototype, "constructor", { value: ctor, writable: true, configurable: true });
         return ctor;
       }
-      const DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill();
+      const DOMException2 = getFromGlobal() || createPolyfill();
       function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
         const reader = AcquireReadableStreamDefaultReader(source);
         const writer = AcquireWritableStreamDefaultWriter(dest);
@@ -2234,7 +2483,7 @@ var require_ponyfill_es2018 = __commonJS({
           let abortAlgorithm;
           if (signal !== void 0) {
             abortAlgorithm = () => {
-              const error = new DOMException$1("Aborted", "AbortError");
+              const error = signal.reason !== void 0 ? signal.reason : new DOMException2("Aborted", "AbortError");
               const actions = [];
               if (!preventAbort) {
                 actions.push(() => {
@@ -2295,6 +2544,7 @@ var require_ponyfill_es2018 = __commonJS({
             } else {
               shutdown(true, storedError);
             }
+            return null;
           });
           isOrBecomesErrored(dest, writer._closedPromise, (storedError) => {
             if (!preventCancel) {
@@ -2302,6 +2552,7 @@ var require_ponyfill_es2018 = __commonJS({
             } else {
               shutdown(true, storedError);
             }
+            return null;
           });
           isOrBecomesClosed(source, reader._closedPromise, () => {
             if (!preventClose) {
@@ -2309,6 +2560,7 @@ var require_ponyfill_es2018 = __commonJS({
             } else {
               shutdown();
             }
+            return null;
           });
           if (WritableStreamCloseQueuedOrInFlight(dest) || dest._state === "closed") {
             const destClosed = new TypeError("the destination writable stream closed before all data could be piped to it");
@@ -2349,6 +2601,7 @@ var require_ponyfill_es2018 = __commonJS({
             }
             function doTheRest() {
               uponPromise(action(), () => finalize(originalIsError, originalError), (newError) => finalize(true, newError));
+              return null;
             }
           }
           function shutdown(isError, error) {
@@ -2373,6 +2626,7 @@ var require_ponyfill_es2018 = __commonJS({
             } else {
               resolve(void 0);
             }
+            return null;
           }
         });
       }
@@ -2432,6 +2686,8 @@ var require_ponyfill_es2018 = __commonJS({
             ReadableStreamDefaultControllerCallPullIfNeeded(this);
           }
         }
+        [ReleaseSteps]() {
+        }
       }
       Object.defineProperties(ReadableStreamDefaultController.prototype, {
         close: { enumerable: true },
@@ -2439,6 +2695,9 @@ var require_ponyfill_es2018 = __commonJS({
         error: { enumerable: true },
         desiredSize: { enumerable: true }
       });
+      setFunctionName(ReadableStreamDefaultController.prototype.close, "close");
+      setFunctionName(ReadableStreamDefaultController.prototype.enqueue, "enqueue");
+      setFunctionName(ReadableStreamDefaultController.prototype.error, "error");
       if (typeof SymbolPolyfill.toStringTag === "symbol") {
         Object.defineProperty(ReadableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
           value: "ReadableStreamDefaultController",
@@ -2471,8 +2730,10 @@ var require_ponyfill_es2018 = __commonJS({
             controller._pullAgain = false;
             ReadableStreamDefaultControllerCallPullIfNeeded(controller);
           }
+          return null;
         }, (e2) => {
           ReadableStreamDefaultControllerError(controller, e2);
+          return null;
         });
       }
       function ReadableStreamDefaultControllerShouldCallPull(controller) {
@@ -2582,23 +2843,31 @@ var require_ponyfill_es2018 = __commonJS({
         uponPromise(promiseResolvedWith(startResult), () => {
           controller._started = true;
           ReadableStreamDefaultControllerCallPullIfNeeded(controller);
+          return null;
         }, (r2) => {
           ReadableStreamDefaultControllerError(controller, r2);
+          return null;
         });
       }
       function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) {
         const controller = Object.create(ReadableStreamDefaultController.prototype);
-        let startAlgorithm = () => void 0;
-        let pullAlgorithm = () => promiseResolvedWith(void 0);
-        let cancelAlgorithm = () => promiseResolvedWith(void 0);
+        let startAlgorithm;
+        let pullAlgorithm;
+        let cancelAlgorithm;
         if (underlyingSource.start !== void 0) {
           startAlgorithm = () => underlyingSource.start(controller);
+        } else {
+          startAlgorithm = () => void 0;
         }
         if (underlyingSource.pull !== void 0) {
           pullAlgorithm = () => underlyingSource.pull(controller);
+        } else {
+          pullAlgorithm = () => promiseResolvedWith(void 0);
         }
         if (underlyingSource.cancel !== void 0) {
           cancelAlgorithm = (reason) => underlyingSource.cancel(reason);
+        } else {
+          cancelAlgorithm = () => promiseResolvedWith(void 0);
         }
         SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
       }
@@ -2633,7 +2902,7 @@ var require_ponyfill_es2018 = __commonJS({
           reading = true;
           const readRequest = {
             _chunkSteps: (chunk) => {
-              queueMicrotask(() => {
+              _queueMicrotask(() => {
                 readAgain = false;
                 const chunk1 = chunk;
                 const chunk2 = chunk;
@@ -2698,6 +2967,7 @@ var require_ponyfill_es2018 = __commonJS({
           if (!canceled1 || !canceled2) {
             resolveCancelPromise(void 0);
           }
+          return null;
         });
         return [branch1, branch2];
       }
@@ -2719,13 +2989,14 @@ var require_ponyfill_es2018 = __commonJS({
         function forwardReaderError(thisReader) {
           uponRejection(thisReader._closedPromise, (r2) => {
             if (thisReader !== reader) {
-              return;
+              return null;
             }
             ReadableByteStreamControllerError(branch1._readableStreamController, r2);
             ReadableByteStreamControllerError(branch2._readableStreamController, r2);
             if (!canceled1 || !canceled2) {
               resolveCancelPromise(void 0);
             }
+            return null;
           });
         }
         function pullWithDefaultReader() {
@@ -2736,7 +3007,7 @@ var require_ponyfill_es2018 = __commonJS({
           }
           const readRequest = {
             _chunkSteps: (chunk) => {
-              queueMicrotask(() => {
+              _queueMicrotask(() => {
                 readAgainForBranch1 = false;
                 readAgainForBranch2 = false;
                 const chunk1 = chunk;
@@ -2799,7 +3070,7 @@ var require_ponyfill_es2018 = __commonJS({
           const otherBranch = forBranch2 ? branch1 : branch2;
           const readIntoRequest = {
             _chunkSteps: (chunk) => {
-              queueMicrotask(() => {
+              _queueMicrotask(() => {
                 readAgainForBranch1 = false;
                 readAgainForBranch2 = false;
                 const byobCanceled = forBranch2 ? canceled2 : canceled1;
@@ -2855,7 +3126,7 @@ var require_ponyfill_es2018 = __commonJS({
               reading = false;
             }
           };
-          ReadableStreamBYOBReaderRead(reader, view, readIntoRequest);
+          ReadableStreamBYOBReaderRead(reader, view, 1, readIntoRequest);
         }
         function pull1Algorithm() {
           if (reading) {
@@ -2913,6 +3184,100 @@ var require_ponyfill_es2018 = __commonJS({
         forwardReaderError(reader);
         return [branch1, branch2];
       }
+      function isReadableStreamLike(stream) {
+        return typeIsObject(stream) && typeof stream.getReader !== "undefined";
+      }
+      function ReadableStreamFrom(source) {
+        if (isReadableStreamLike(source)) {
+          return ReadableStreamFromDefaultReader(source.getReader());
+        }
+        return ReadableStreamFromIterable(source);
+      }
+      function ReadableStreamFromIterable(asyncIterable) {
+        let stream;
+        const iteratorRecord = GetIterator(asyncIterable, "async");
+        const startAlgorithm = noop2;
+        function pullAlgorithm() {
+          let nextResult;
+          try {
+            nextResult = IteratorNext(iteratorRecord);
+          } catch (e2) {
+            return promiseRejectedWith(e2);
+          }
+          const nextPromise = promiseResolvedWith(nextResult);
+          return transformPromiseWith(nextPromise, (iterResult) => {
+            if (!typeIsObject(iterResult)) {
+              throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");
+            }
+            const done = IteratorComplete(iterResult);
+            if (done) {
+              ReadableStreamDefaultControllerClose(stream._readableStreamController);
+            } else {
+              const value = IteratorValue(iterResult);
+              ReadableStreamDefaultControllerEnqueue(stream._readableStreamController, value);
+            }
+          });
+        }
+        function cancelAlgorithm(reason) {
+          const iterator = iteratorRecord.iterator;
+          let returnMethod;
+          try {
+            returnMethod = GetMethod(iterator, "return");
+          } catch (e2) {
+            return promiseRejectedWith(e2);
+          }
+          if (returnMethod === void 0) {
+            return promiseResolvedWith(void 0);
+          }
+          let returnResult;
+          try {
+            returnResult = reflectCall(returnMethod, iterator, [reason]);
+          } catch (e2) {
+            return promiseRejectedWith(e2);
+          }
+          const returnPromise = promiseResolvedWith(returnResult);
+          return transformPromiseWith(returnPromise, (iterResult) => {
+            if (!typeIsObject(iterResult)) {
+              throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object");
+            }
+            return void 0;
+          });
+        }
+        stream = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0);
+        return stream;
+      }
+      function ReadableStreamFromDefaultReader(reader) {
+        let stream;
+        const startAlgorithm = noop2;
+        function pullAlgorithm() {
+          let readPromise;
+          try {
+            readPromise = reader.read();
+          } catch (e2) {
+            return promiseRejectedWith(e2);
+          }
+          return transformPromiseWith(readPromise, (readResult) => {
+            if (!typeIsObject(readResult)) {
+              throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");
+            }
+            if (readResult.done) {
+              ReadableStreamDefaultControllerClose(stream._readableStreamController);
+            } else {
+              const value = readResult.value;
+              ReadableStreamDefaultControllerEnqueue(stream._readableStreamController, value);
+            }
+          });
+        }
+        function cancelAlgorithm(reason) {
+          try {
+            return promiseResolvedWith(reader.cancel(reason));
+          } catch (e2) {
+            return promiseRejectedWith(e2);
+          }
+        }
+        stream = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0);
+        return stream;
+      }
       function convertUnderlyingDefaultOrByteSource(source, context) {
         assertDictionary(source, context);
         const original = source;
@@ -2948,20 +3313,6 @@ var require_ponyfill_es2018 = __commonJS({
         }
         return type;
       }
-      function convertReaderOptions(options, context) {
-        assertDictionary(options, context);
-        const mode = options === null || options === void 0 ? void 0 : options.mode;
-        return {
-          mode: mode === void 0 ? void 0 : convertReadableStreamReaderMode(mode, `${context} has member 'mode' that`)
-        };
-      }
-      function convertReadableStreamReaderMode(mode, context) {
-        mode = `${mode}`;
-        if (mode !== "byob") {
-          throw new TypeError(`${context} '${mode}' is not a valid enumeration value for ReadableStreamReaderMode`);
-        }
-        return mode;
-      }
       function convertIteratorOptions(options, context) {
         assertDictionary(options, context);
         const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;
@@ -3100,7 +3451,13 @@ var require_ponyfill_es2018 = __commonJS({
           const options = convertIteratorOptions(rawOptions, "First parameter");
           return AcquireReadableStreamAsyncIterator(this, options.preventCancel);
         }
+        static from(asyncIterable) {
+          return ReadableStreamFrom(asyncIterable);
+        }
       }
+      Object.defineProperties(ReadableStream2, {
+        from: { enumerable: true }
+      });
       Object.defineProperties(ReadableStream2.prototype, {
         cancel: { enumerable: true },
         getReader: { enumerable: true },
@@ -3110,6 +3467,13 @@ var require_ponyfill_es2018 = __commonJS({
         values: { enumerable: true },
         locked: { enumerable: true }
       });
+      setFunctionName(ReadableStream2.from, "from");
+      setFunctionName(ReadableStream2.prototype.cancel, "cancel");
+      setFunctionName(ReadableStream2.prototype.getReader, "getReader");
+      setFunctionName(ReadableStream2.prototype.pipeThrough, "pipeThrough");
+      setFunctionName(ReadableStream2.prototype.pipeTo, "pipeTo");
+      setFunctionName(ReadableStream2.prototype.tee, "tee");
+      setFunctionName(ReadableStream2.prototype.values, "values");
       if (typeof SymbolPolyfill.toStringTag === "symbol") {
         Object.defineProperty(ReadableStream2.prototype, SymbolPolyfill.toStringTag, {
           value: "ReadableStream",
@@ -3169,10 +3533,11 @@ var require_ponyfill_es2018 = __commonJS({
         ReadableStreamClose(stream);
         const reader = stream._reader;
         if (reader !== void 0 && IsReadableStreamBYOBReader(reader)) {
-          reader._readIntoRequests.forEach((readIntoRequest) => {
+          const readIntoRequests = reader._readIntoRequests;
+          reader._readIntoRequests = new SimpleQueue();
+          readIntoRequests.forEach((readIntoRequest) => {
             readIntoRequest._closeSteps(void 0);
           });
-          reader._readIntoRequests = new SimpleQueue();
         }
         const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
         return transformPromiseWith(sourceCancelPromise, noop2);
@@ -3185,10 +3550,11 @@ var require_ponyfill_es2018 = __commonJS({
         }
         defaultReaderClosedPromiseResolve(reader);
         if (IsReadableStreamDefaultReader(reader)) {
-          reader._readRequests.forEach((readRequest) => {
+          const readRequests = reader._readRequests;
+          reader._readRequests = new SimpleQueue();
+          readRequests.forEach((readRequest) => {
             readRequest._closeSteps();
           });
-          reader._readRequests = new SimpleQueue();
         }
       }
       function ReadableStreamError(stream, e2) {
@@ -3200,15 +3566,9 @@ var require_ponyfill_es2018 = __commonJS({
         }
         defaultReaderClosedPromiseReject(reader, e2);
         if (IsReadableStreamDefaultReader(reader)) {
-          reader._readRequests.forEach((readRequest) => {
-            readRequest._errorSteps(e2);
-          });
-          reader._readRequests = new SimpleQueue();
+          ReadableStreamDefaultReaderErrorReadRequests(reader, e2);
         } else {
-          reader._readIntoRequests.forEach((readIntoRequest) => {
-            readIntoRequest._errorSteps(e2);
-          });
-          reader._readIntoRequests = new SimpleQueue();
+          ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e2);
         }
       }
       function streamBrandCheckException$1(name) {
@@ -3225,13 +3585,7 @@ var require_ponyfill_es2018 = __commonJS({
       const byteLengthSizeFunction = (chunk) => {
         return chunk.byteLength;
       };
-      try {
-        Object.defineProperty(byteLengthSizeFunction, "name", {
-          value: "size",
-          configurable: true
-        });
-      } catch (_a4) {
-      }
+      setFunctionName(byteLengthSizeFunction, "size");
       class ByteLengthQueuingStrategy {
         constructor(options) {
           assertRequiredArgument(options, 1, "ByteLengthQueuingStrategy");
@@ -3276,13 +3630,7 @@ var require_ponyfill_es2018 = __commonJS({
       const countSizeFunction = () => {
         return 1;
       };
-      try {
-        Object.defineProperty(countSizeFunction, "name", {
-          value: "size",
-          configurable: true
-        });
-      } catch (_a4) {
-      }
+      setFunctionName(countSizeFunction, "size");
       class CountQueuingStrategy {
         constructor(options) {
           assertRequiredArgument(options, 1, "CountQueuingStrategy");
@@ -3326,12 +3674,14 @@ var require_ponyfill_es2018 = __commonJS({
       }
       function convertTransformer(original, context) {
         assertDictionary(original, context);
+        const cancel = original === null || original === void 0 ? void 0 : original.cancel;
         const flush = original === null || original === void 0 ? void 0 : original.flush;
         const readableType = original === null || original === void 0 ? void 0 : original.readableType;
         const start = original === null || original === void 0 ? void 0 : original.start;
         const transform = original === null || original === void 0 ? void 0 : original.transform;
         const writableType = original === null || original === void 0 ? void 0 : original.writableType;
         return {
+          cancel: cancel === void 0 ? void 0 : convertTransformerCancelCallback(cancel, original, `${context} has member 'cancel' that`),
           flush: flush === void 0 ? void 0 : convertTransformerFlushCallback(flush, original, `${context} has member 'flush' that`),
           readableType,
           start: start === void 0 ? void 0 : convertTransformerStartCallback(start, original, `${context} has member 'start' that`),
@@ -3351,6 +3701,10 @@ var require_ponyfill_es2018 = __commonJS({
         assertFunction(fn, context);
         return (chunk, controller) => promiseCall(fn, original, [chunk, controller]);
       }
+      function convertTransformerCancelCallback(fn, original, context) {
+        assertFunction(fn, context);
+        return (reason) => promiseCall(fn, original, [reason]);
+      }
       class TransformStream {
         constructor(rawTransformer = {}, rawWritableStrategy = {}, rawReadableStrategy = {}) {
           if (rawTransformer === void 0) {
@@ -3422,8 +3776,7 @@ var require_ponyfill_es2018 = __commonJS({
           return TransformStreamDefaultSourcePullAlgorithm(stream);
         }
         function cancelAlgorithm(reason) {
-          TransformStreamErrorWritableAndUnblockWrite(stream, reason);
-          return promiseResolvedWith(void 0);
+          return TransformStreamDefaultSourceCancelAlgorithm(stream, reason);
         }
         stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
         stream._backpressure = void 0;
@@ -3448,6 +3801,9 @@ var require_ponyfill_es2018 = __commonJS({
       function TransformStreamErrorWritableAndUnblockWrite(stream, e2) {
         TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);
         WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e2);
+        TransformStreamUnblockWrite(stream);
+      }
+      function TransformStreamUnblockWrite(stream) {
         if (stream._backpressure) {
           TransformStreamSetBackpressure(stream, false);
         }
@@ -3497,6 +3853,9 @@ var require_ponyfill_es2018 = __commonJS({
         terminate: { enumerable: true },
         desiredSize: { enumerable: true }
       });
+      setFunctionName(TransformStreamDefaultController.prototype.enqueue, "enqueue");
+      setFunctionName(TransformStreamDefaultController.prototype.error, "error");
+      setFunctionName(TransformStreamDefaultController.prototype.terminate, "terminate");
       if (typeof SymbolPolyfill.toStringTag === "symbol") {
         Object.defineProperty(TransformStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
           value: "TransformStreamDefaultController",
@@ -3512,34 +3871,49 @@ var require_ponyfill_es2018 = __commonJS({
         }
         return x2 instanceof TransformStreamDefaultController;
       }
-      function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) {
+      function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm) {
         controller._controlledTransformStream = stream;
         stream._transformStreamController = controller;
         controller._transformAlgorithm = transformAlgorithm;
         controller._flushAlgorithm = flushAlgorithm;
+        controller._cancelAlgorithm = cancelAlgorithm;
+        controller._finishPromise = void 0;
+        controller._finishPromise_resolve = void 0;
+        controller._finishPromise_reject = void 0;
       }
       function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) {
         const controller = Object.create(TransformStreamDefaultController.prototype);
-        let transformAlgorithm = (chunk) => {
-          try {
-            TransformStreamDefaultControllerEnqueue(controller, chunk);
-            return promiseResolvedWith(void 0);
-          } catch (transformResultE) {
-            return promiseRejectedWith(transformResultE);
-          }
-        };
-        let flushAlgorithm = () => promiseResolvedWith(void 0);
+        let transformAlgorithm;
+        let flushAlgorithm;
+        let cancelAlgorithm;
         if (transformer.transform !== void 0) {
           transformAlgorithm = (chunk) => transformer.transform(chunk, controller);
+        } else {
+          transformAlgorithm = (chunk) => {
+            try {
+              TransformStreamDefaultControllerEnqueue(controller, chunk);
+              return promiseResolvedWith(void 0);
+            } catch (transformResultE) {
+              return promiseRejectedWith(transformResultE);
+            }
+          };
         }
         if (transformer.flush !== void 0) {
           flushAlgorithm = () => transformer.flush(controller);
+        } else {
+          flushAlgorithm = () => promiseResolvedWith(void 0);
+        }
+        if (transformer.cancel !== void 0) {
+          cancelAlgorithm = (reason) => transformer.cancel(reason);
+        } else {
+          cancelAlgorithm = () => promiseResolvedWith(void 0);
         }
-        SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm);
+        SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm);
       }
       function TransformStreamDefaultControllerClearAlgorithms(controller) {
         controller._transformAlgorithm = void 0;
         controller._flushAlgorithm = void 0;
+        controller._cancelAlgorithm = void 0;
       }
       function TransformStreamDefaultControllerEnqueue(controller, chunk) {
         const stream = controller._controlledTransformStream;
@@ -3591,31 +3965,112 @@ var require_ponyfill_es2018 = __commonJS({
         return TransformStreamDefaultControllerPerformTransform(controller, chunk);
       }
       function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) {
-        TransformStreamError(stream, reason);
-        return promiseResolvedWith(void 0);
+        const controller = stream._transformStreamController;
+        if (controller._finishPromise !== void 0) {
+          return controller._finishPromise;
+        }
+        const readable = stream._readable;
+        controller._finishPromise = newPromise((resolve, reject) => {
+          controller._finishPromise_resolve = resolve;
+          controller._finishPromise_reject = reject;
+        });
+        const cancelPromise = controller._cancelAlgorithm(reason);
+        TransformStreamDefaultControllerClearAlgorithms(controller);
+        uponPromise(cancelPromise, () => {
+          if (readable._state === "errored") {
+            defaultControllerFinishPromiseReject(controller, readable._storedError);
+          } else {
+            ReadableStreamDefaultControllerError(readable._readableStreamController, reason);
+            defaultControllerFinishPromiseResolve(controller);
+          }
+          return null;
+        }, (r2) => {
+          ReadableStreamDefaultControllerError(readable._readableStreamController, r2);
+          defaultControllerFinishPromiseReject(controller, r2);
+          return null;
+        });
+        return controller._finishPromise;
       }
       function TransformStreamDefaultSinkCloseAlgorithm(stream) {
-        const readable = stream._readable;
         const controller = stream._transformStreamController;
+        if (controller._finishPromise !== void 0) {
+          return controller._finishPromise;
+        }
+        const readable = stream._readable;
+        controller._finishPromise = newPromise((resolve, reject) => {
+          controller._finishPromise_resolve = resolve;
+          controller._finishPromise_reject = reject;
+        });
         const flushPromise = controller._flushAlgorithm();
         TransformStreamDefaultControllerClearAlgorithms(controller);
-        return transformPromiseWith(flushPromise, () => {
+        uponPromise(flushPromise, () => {
           if (readable._state === "errored") {
-            throw readable._storedError;
+            defaultControllerFinishPromiseReject(controller, readable._storedError);
+          } else {
+            ReadableStreamDefaultControllerClose(readable._readableStreamController);
+            defaultControllerFinishPromiseResolve(controller);
           }
-          ReadableStreamDefaultControllerClose(readable._readableStreamController);
+          return null;
         }, (r2) => {
-          TransformStreamError(stream, r2);
-          throw readable._storedError;
+          ReadableStreamDefaultControllerError(readable._readableStreamController, r2);
+          defaultControllerFinishPromiseReject(controller, r2);
+          return null;
         });
+        return controller._finishPromise;
       }
       function TransformStreamDefaultSourcePullAlgorithm(stream) {
         TransformStreamSetBackpressure(stream, false);
         return stream._backpressureChangePromise;
       }
+      function TransformStreamDefaultSourceCancelAlgorithm(stream, reason) {
+        const controller = stream._transformStreamController;
+        if (controller._finishPromise !== void 0) {
+          return controller._finishPromise;
+        }
+        const writable = stream._writable;
+        controller._finishPromise = newPromise((resolve, reject) => {
+          controller._finishPromise_resolve = resolve;
+          controller._finishPromise_reject = reject;
+        });
+        const cancelPromise = controller._cancelAlgorithm(reason);
+        TransformStreamDefaultControllerClearAlgorithms(controller);
+        uponPromise(cancelPromise, () => {
+          if (writable._state === "errored") {
+            defaultControllerFinishPromiseReject(controller, writable._storedError);
+          } else {
+            WritableStreamDefaultControllerErrorIfNeeded(writable._writableStreamController, reason);
+            TransformStreamUnblockWrite(stream);
+            defaultControllerFinishPromiseResolve(controller);
+          }
+          return null;
+        }, (r2) => {
+          WritableStreamDefaultControllerErrorIfNeeded(writable._writableStreamController, r2);
+          TransformStreamUnblockWrite(stream);
+          defaultControllerFinishPromiseReject(controller, r2);
+          return null;
+        });
+        return controller._finishPromise;
+      }
       function defaultControllerBrandCheckException(name) {
         return new TypeError(`TransformStreamDefaultController.prototype.${name} can only be used on a TransformStreamDefaultController`);
       }
+      function defaultControllerFinishPromiseResolve(controller) {
+        if (controller._finishPromise_resolve === void 0) {
+          return;
+        }
+        controller._finishPromise_resolve();
+        controller._finishPromise_resolve = void 0;
+        controller._finishPromise_reject = void 0;
+      }
+      function defaultControllerFinishPromiseReject(controller, reason) {
+        if (controller._finishPromise_reject === void 0) {
+          return;
+        }
+        setPromiseIsHandledToTrue(controller._finishPromise);
+        controller._finishPromise_reject(reason);
+        controller._finishPromise_resolve = void 0;
+        controller._finishPromise_reject = void 0;
+      }
       function streamBrandCheckException(name) {
         return new TypeError(`TransformStream.prototype.${name} can only be used on a TransformStream`);
       }
@@ -3632,23 +4087,22 @@ var require_ponyfill_es2018 = __commonJS({
       exports2.WritableStream = WritableStream;
       exports2.WritableStreamDefaultController = WritableStreamDefaultController;
       exports2.WritableStreamDefaultWriter = WritableStreamDefaultWriter;
-      Object.defineProperty(exports2, "__esModule", { value: true });
     });
   }
 });
 
-// ../../node_modules/fetch-blob/streams.cjs
+// ../../../node_modules/fetch-blob/streams.cjs
 var require_streams = __commonJS({
-  "../../node_modules/fetch-blob/streams.cjs"() {
+  "../../../node_modules/fetch-blob/streams.cjs"() {
     var POOL_SIZE2 = 65536;
     if (!globalThis.ReadableStream) {
       try {
-        const process2 = require("process");
+        const process2 = require("node:process");
         const { emitWarning } = process2;
         try {
           process2.emitWarning = () => {
           };
-          Object.assign(globalThis, require("stream/web"));
+          Object.assign(globalThis, require("node:stream/web"));
           process2.emitWarning = emitWarning;
         } catch (error) {
           process2.emitWarning = emitWarning;
@@ -3659,9 +4113,9 @@ var require_streams = __commonJS({
       }
     }
     try {
-      const { Blob: Blob2 } = require("buffer");
-      if (Blob2 && !Blob2.prototype.stream) {
-        Blob2.prototype.stream = function name(params) {
+      const { Blob: Blob3 } = require("buffer");
+      if (Blob3 && !Blob3.prototype.stream) {
+        Blob3.prototype.stream = function name(params) {
           let position = 0;
           const blob = this;
           return new ReadableStream({
@@ -3683,7 +4137,7 @@ var require_streams = __commonJS({
   }
 });
 
-// ../../node_modules/fetch-blob/index.js
+// ../../../node_modules/fetch-blob/index.js
 async function* toIterator(parts, clone2 = true) {
   for (const part of parts) {
     if ("stream" in part) {
@@ -3712,17 +4166,17 @@ async function* toIterator(parts, clone2 = true) {
     }
   }
 }
-var import_streams, POOL_SIZE, _parts, _type, _size, _endings, _a, _Blob, Blob, fetch_blob_default;
+var import_streams, POOL_SIZE, _Blob, Blob2, fetch_blob_default;
 var init_fetch_blob = __esm({
-  "../../node_modules/fetch-blob/index.js"() {
+  "../../../node_modules/fetch-blob/index.js"() {
     import_streams = __toESM(require_streams(), 1);
     POOL_SIZE = 65536;
-    _Blob = (_a = class {
+    _Blob = class Blob {
+      #parts = [];
+      #type = "";
+      #size = 0;
+      #endings = "transparent";
       constructor(blobParts = [], options = {}) {
-        __privateAdd(this, _parts, []);
-        __privateAdd(this, _type, "");
-        __privateAdd(this, _size, 0);
-        __privateAdd(this, _endings, "transparent");
         if (typeof blobParts !== "object" || blobParts === null) {
           throw new TypeError("Failed to construct 'Blob': The provided value cannot be converted to a sequence.");
         }
@@ -3741,28 +4195,28 @@ var init_fetch_blob = __esm({
             part = new Uint8Array(element.buffer.slice(element.byteOffset, element.byteOffset + element.byteLength));
           } else if (element instanceof ArrayBuffer) {
             part = new Uint8Array(element.slice(0));
-          } else if (element instanceof _a) {
+          } else if (element instanceof Blob) {
             part = element;
           } else {
             part = encoder.encode(`${element}`);
           }
-          __privateSet(this, _size, __privateGet(this, _size) + (ArrayBuffer.isView(part) ? part.byteLength : part.size));
-          __privateGet(this, _parts).push(part);
+          this.#size += ArrayBuffer.isView(part) ? part.byteLength : part.size;
+          this.#parts.push(part);
         }
-        __privateSet(this, _endings, `${options.endings === void 0 ? "transparent" : options.endings}`);
+        this.#endings = `${options.endings === void 0 ? "transparent" : options.endings}`;
         const type = options.type === void 0 ? "" : String(options.type);
-        __privateSet(this, _type, /^[\x20-\x7E]*$/.test(type) ? type : "");
+        this.#type = /^[\x20-\x7E]*$/.test(type) ? type : "";
       }
       get size() {
-        return __privateGet(this, _size);
+        return this.#size;
       }
       get type() {
-        return __privateGet(this, _type);
+        return this.#type;
       }
       async text() {
         const decoder = new TextDecoder();
         let str = "";
-        for await (const part of toIterator(__privateGet(this, _parts), false)) {
+        for await (const part of toIterator(this.#parts, false)) {
           str += decoder.decode(part, { stream: true });
         }
         str += decoder.decode();
@@ -3771,14 +4225,14 @@ var init_fetch_blob = __esm({
       async arrayBuffer() {
         const data = new Uint8Array(this.size);
         let offset = 0;
-        for await (const chunk of toIterator(__privateGet(this, _parts), false)) {
+        for await (const chunk of toIterator(this.#parts, false)) {
           data.set(chunk, offset);
           offset += chunk.length;
         }
         return data.buffer;
       }
       stream() {
-        const it = toIterator(__privateGet(this, _parts), true);
+        const it = toIterator(this.#parts, true);
         return new globalThis.ReadableStream({
           type: "bytes",
           async pull(ctrl) {
@@ -3795,7 +4249,7 @@ var init_fetch_blob = __esm({
         let relativeStart = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
         let relativeEnd = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
         const span = Math.max(relativeEnd - relativeStart, 0);
-        const parts = __privateGet(this, _parts);
+        const parts = this.#parts;
         const blobParts = [];
         let added = 0;
         for (const part of parts) {
@@ -3820,9 +4274,9 @@ var init_fetch_blob = __esm({
             relativeStart = 0;
           }
         }
-        const blob = new _a([], { type: String(type).toLowerCase() });
-        __privateSet(blob, _size, span);
-        __privateSet(blob, _parts, blobParts);
+        const blob = new Blob([], { type: String(type).toLowerCase() });
+        blob.#size = span;
+        blob.#parts = blobParts;
         return blob;
       }
       get [Symbol.toStringTag]() {
@@ -3831,43 +4285,43 @@ var init_fetch_blob = __esm({
       static [Symbol.hasInstance](object) {
         return object && typeof object === "object" && typeof object.constructor === "function" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]);
       }
-    }, _parts = new WeakMap(), _type = new WeakMap(), _size = new WeakMap(), _endings = new WeakMap(), _a);
+    };
     Object.defineProperties(_Blob.prototype, {
       size: { enumerable: true },
       type: { enumerable: true },
       slice: { enumerable: true }
     });
-    Blob = _Blob;
-    fetch_blob_default = Blob;
+    Blob2 = _Blob;
+    fetch_blob_default = Blob2;
   }
 });
 
-// ../../node_modules/fetch-blob/file.js
-var _lastModified, _name, _a2, _File, File, file_default;
+// ../../../node_modules/fetch-blob/file.js
+var _File, File2, file_default;
 var init_file = __esm({
-  "../../node_modules/fetch-blob/file.js"() {
+  "../../../node_modules/fetch-blob/file.js"() {
     init_fetch_blob();
-    _File = (_a2 = class extends fetch_blob_default {
+    _File = class File extends fetch_blob_default {
+      #lastModified = 0;
+      #name = "";
       constructor(fileBits, fileName, options = {}) {
         if (arguments.length < 2) {
           throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`);
         }
         super(fileBits, options);
-        __privateAdd(this, _lastModified, 0);
-        __privateAdd(this, _name, "");
         if (options === null)
           options = {};
         const lastModified = options.lastModified === void 0 ? Date.now() : Number(options.lastModified);
         if (!Number.isNaN(lastModified)) {
-          __privateSet(this, _lastModified, lastModified);
+          this.#lastModified = lastModified;
         }
-        __privateSet(this, _name, String(fileName));
+        this.#name = String(fileName);
       }
       get name() {
-        return __privateGet(this, _name);
+        return this.#name;
       }
       get lastModified() {
-        return __privateGet(this, _lastModified);
+        return this.#lastModified;
       }
       get [Symbol.toStringTag]() {
         return "File";
@@ -3875,13 +4329,13 @@ var init_file = __esm({
       static [Symbol.hasInstance](object) {
         return !!object && object instanceof fetch_blob_default && /^(File)$/.test(object[Symbol.toStringTag]);
       }
-    }, _lastModified = new WeakMap(), _name = new WeakMap(), _a2);
-    File = _File;
-    file_default = File;
+    };
+    File2 = _File;
+    file_default = File2;
   }
 });
 
-// ../../node_modules/formdata-polyfill/esm.min.js
+// ../../../node_modules/formdata-polyfill/esm.min.js
 function formDataToBlob(F2, B = fetch_blob_default) {
   var b = `${r()}${r()}`.replace(/\./g, "").slice(-28).padStart(32, "-"), c = [], p = `--${b}\r
 Content-Disposition: form-data; name="`;
@@ -3895,9 +4349,9 @@ Content-Type: ${v.type || "application/octet-stream"}\r
   c.push(`--${b}--`);
   return new B(c, { type: "multipart/form-data; boundary=" + b });
 }
-var t, i, h, r, m, f, e, x, _d, _a3, FormData;
+var t, i, h, r, m, f, e, x, FormData;
 var init_esm_min = __esm({
-  "../../node_modules/formdata-polyfill/esm.min.js"() {
+  "../../../node_modules/formdata-polyfill/esm.min.js"() {
     init_fetch_blob();
     init_file();
     ({ toStringTag: t, iterator: i, hasInstance: h } = Symbol);
@@ -3910,9 +4364,9 @@ var init_esm_min = __esm({
         throw new TypeError(`Failed to execute '${n}' on 'FormData': ${e2} arguments required, but only ${a.length} present.`);
       }
     };
-    FormData = (_a3 = class {
+    FormData = class FormData2 {
+      #d = [];
       constructor(...a) {
-        __privateAdd(this, _d, []);
         if (a.length)
           throw new TypeError(`Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.`);
       }
@@ -3927,17 +4381,17 @@ var init_esm_min = __esm({
       }
       append(...a) {
         x("append", arguments, 2);
-        __privateGet(this, _d).push(f(...a));
+        this.#d.push(f(...a));
       }
       delete(a) {
         x("delete", arguments, 1);
         a += "";
-        __privateSet(this, _d, __privateGet(this, _d).filter(([b]) => b !== a));
+        this.#d = this.#d.filter(([b]) => b !== a);
       }
       get(a) {
         x("get", arguments, 1);
         a += "";
-        for (var b = __privateGet(this, _d), l = b.length, c = 0; c < l; c++)
+        for (var b = this.#d, l = b.length, c = 0; c < l; c++)
           if (b[c][0] === a)
             return b[c][1];
         return null;
@@ -3946,13 +4400,13 @@ var init_esm_min = __esm({
         x("getAll", arguments, 1);
         b = [];
         a += "";
-        __privateGet(this, _d).forEach((c) => c[0] === a && b.push(c[1]));
+        this.#d.forEach((c) => c[0] === a && b.push(c[1]));
         return b;
       }
       has(a) {
         x("has", arguments, 1);
         a += "";
-        return __privateGet(this, _d).some((b) => b[0] === a);
+        return this.#d.some((b) => b[0] === a);
       }
       forEach(a, b) {
         x("forEach", arguments, 1);
@@ -3963,14 +4417,14 @@ var init_esm_min = __esm({
         x("set", arguments, 2);
         var b = [], c = true;
         a = f(...a);
-        __privateGet(this, _d).forEach((d) => {
+        this.#d.forEach((d) => {
           d[0] === a[0] ? c && (c = !b.push(a)) : b.push(d);
         });
         c && b.push(a);
-        __privateSet(this, _d, b);
+        this.#d = b;
       }
       *entries() {
-        yield* __privateGet(this, _d);
+        yield* this.#d;
       }
       *keys() {
         for (var [a] of this)
@@ -3980,13 +4434,13 @@ var init_esm_min = __esm({
         for (var [, a] of this)
           yield a;
       }
-    }, _d = new WeakMap(), _a3);
+    };
   }
 });
 
-// ../../node_modules/node-domexception/index.js
+// ../../../node_modules/node-domexception/index.js
 var require_node_domexception = __commonJS({
-  "../../node_modules/node-domexception/index.js"(exports, module2) {
+  "../../../node_modules/node-domexception/index.js"(exports, module2) {
     if (!globalThis.DOMException) {
       try {
         const { MessageChannel } = require("worker_threads"), port = new MessageChannel().port1, ab = new ArrayBuffer();
@@ -3999,49 +4453,46 @@ var require_node_domexception = __commonJS({
   }
 });
 
-// ../../node_modules/fetch-blob/from.js
-var import_node_fs, import_node_domexception, stat, _path, _start, _BlobDataItem, BlobDataItem;
+// ../../../node_modules/fetch-blob/from.js
+var import_node_fs, import_node_domexception, stat, BlobDataItem;
 var init_from = __esm({
-  "../../node_modules/fetch-blob/from.js"() {
-    import_node_fs = require("fs");
+  "../../../node_modules/fetch-blob/from.js"() {
+    import_node_fs = require("node:fs");
     import_node_domexception = __toESM(require_node_domexception(), 1);
     init_file();
     init_fetch_blob();
     ({ stat } = import_node_fs.promises);
-    _BlobDataItem = class {
+    BlobDataItem = class {
+      #path;
+      #start;
       constructor(options) {
-        __privateAdd(this, _path, void 0);
-        __privateAdd(this, _start, void 0);
-        __privateSet(this, _path, options.path);
-        __privateSet(this, _start, options.start);
+        this.#path = options.path;
+        this.#start = options.start;
         this.size = options.size;
         this.lastModified = options.lastModified;
       }
       slice(start, end) {
-        return new _BlobDataItem({
-          path: __privateGet(this, _path),
+        return new BlobDataItem({
+          path: this.#path,
           lastModified: this.lastModified,
           size: end - start,
-          start: __privateGet(this, _start) + start
+          start: this.#start + start
         });
       }
       async *stream() {
-        const { mtimeMs } = await stat(__privateGet(this, _path));
+        const { mtimeMs } = await stat(this.#path);
         if (mtimeMs > this.lastModified) {
           throw new import_node_domexception.default("The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.", "NotReadableError");
         }
-        yield* (0, import_node_fs.createReadStream)(__privateGet(this, _path), {
-          start: __privateGet(this, _start),
-          end: __privateGet(this, _start) + this.size - 1
+        yield* (0, import_node_fs.createReadStream)(this.#path, {
+          start: this.#start,
+          end: this.#start + this.size - 1
         });
       }
       get [Symbol.toStringTag]() {
         return "Blob";
       }
     };
-    BlobDataItem = _BlobDataItem;
-    _path = new WeakMap();
-    _start = new WeakMap();
   }
 });
 
@@ -4412,24 +4863,21 @@ function fetchWithoutToken(client, url, init = {}) {
   } else if (!headers.has("content-type")) {
     headers.append("content-type", "application/json");
   }
-  return client.fetch(url, {
-    ...init,
+  return client.fetch(url, __spreadProps(__spreadValues({}, init), {
     headers
-  });
+  }));
 }
 function fetchWithToken(client, url, init = {}) {
   return client.getAuthorizationHeader().then((header) => {
     if (!init.headers) {
       init.headers = {};
     }
-    const headers = {
-      ...init.headers,
+    const headers = __spreadProps(__spreadValues({}, init.headers), {
       authorization: header
-    };
-    return fetchWithoutToken(client, url, {
-      ...init,
-      headers
     });
+    return fetchWithoutToken(client, url, __spreadProps(__spreadValues({}, init), {
+      headers
+    }));
   });
 }
 
@@ -4438,8 +4886,7 @@ function getJsonResponse(res) {
   const json = res.json();
   if (!res.ok) {
     return json.then((err) => {
-      var _a4;
-      throw new Error((_a4 = err == null ? void 0 : err.message) != null ? _a4 : res.statusText);
+      throw new Error((err == null ? void 0 : err.message) ?? res.statusText);
     });
   }
   return json;
@@ -4476,20 +4923,20 @@ var FeedServiceApiClient = class {
     return fetchWithToken(this.http, this.getUrl(path), init).then(getJsonResponse);
   }
   doGet(path, init = {}) {
-    return this.doAny(path, { ...init, method: "GET" });
+    return this.doAny(path, __spreadProps(__spreadValues({}, init), { method: "GET" }));
   }
   doPost(path, content, init = {}) {
-    const { FormData: FormData2 } = this.http;
-    const body = content instanceof FormData2 ? content : JSON.stringify(content);
-    return this.doAny(path, { ...init, method: "POST", body });
+    const { FormData: FormData3 } = this.http;
+    const body = content instanceof FormData3 ? content : JSON.stringify(content);
+    return this.doAny(path, __spreadProps(__spreadValues({}, init), { method: "POST", body }));
   }
   doPut(path, content, init = {}) {
-    const { FormData: FormData2 } = this.http;
-    const body = content instanceof FormData2 ? content : JSON.stringify(content);
-    return this.doAny(path, { ...init, method: "PUT", body });
+    const { FormData: FormData3 } = this.http;
+    const body = content instanceof FormData3 ? content : JSON.stringify(content);
+    return this.doAny(path, __spreadProps(__spreadValues({}, init), { method: "PUT", body }));
   }
   doDelete(path, init = {}) {
-    return this.doAny(path, { ...init, method: "DELETE" });
+    return this.doAny(path, __spreadProps(__spreadValues({}, init), { method: "DELETE" }));
   }
   getPilets(ac = mac()) {
     return this.doQueryCurrentPilets("cloud", ac);
@@ -4507,8 +4954,8 @@ var FeedServiceApiClient = class {
     return this.doPut(`feed/${feed}/page/${version}?tag=${tag}`, content, mri(ac));
   }
   doPublishPage(feed, content, ac = mac()) {
-    const { FormData: FormData2 } = this.http;
-    const form = new FormData2();
+    const { FormData: FormData3 } = this.http;
+    const form = new FormData3();
     form.append("version", content.version);
     form.append("type", content.type);
     form.append("embed", content.embed);
@@ -4534,8 +4981,8 @@ var FeedServiceApiClient = class {
     return this.doGet(`feed/${feed}/pilets/${name}/versions?${queryString}`, mri(ac));
   }
   doPublishPilet(feed, tag, file, ac = mac()) {
-    const { FormData: FormData2 } = this.http;
-    const form = new FormData2();
+    const { FormData: FormData3 } = this.http;
+    const form = new FormData3();
     form.append("file", file);
     form.append("tag", tag);
     return this.doPost(`pilet/${feed}`, form, mri(ac));
@@ -4866,13 +5313,13 @@ var FeedServiceApiClient = class {
 };
 
 // node_modules/node-fetch/src/index.js
-var import_node_http2 = __toESM(require("http"), 1);
-var import_node_https = __toESM(require("https"), 1);
-var import_node_zlib = __toESM(require("zlib"), 1);
-var import_node_stream2 = __toESM(require("stream"), 1);
-var import_node_buffer2 = require("buffer");
+var import_node_http2 = __toESM(require("node:http"), 1);
+var import_node_https = __toESM(require("node:https"), 1);
+var import_node_zlib = __toESM(require("node:zlib"), 1);
+var import_node_stream2 = __toESM(require("node:stream"), 1);
+var import_node_buffer2 = require("node:buffer");
 
-// ../../node_modules/data-uri-to-buffer/dist/index.js
+// ../../../node_modules/data-uri-to-buffer/dist/index.js
 function dataUriToBuffer(uri) {
   if (!/^data:/i.test(uri)) {
     throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
@@ -4890,7 +5337,7 @@ function dataUriToBuffer(uri) {
   for (let i2 = 1; i2 < meta.length; i2++) {
     if (meta[i2] === "base64") {
       base64 = true;
-    } else {
+    } else if (meta[i2]) {
       typeFull += `;${meta[i2]}`;
       if (meta[i2].indexOf("charset=") === 0) {
         charset = meta[i2].substring(8);
@@ -4912,9 +5359,9 @@ function dataUriToBuffer(uri) {
 var dist_default = dataUriToBuffer;
 
 // node_modules/node-fetch/src/body.js
-var import_node_stream = __toESM(require("stream"), 1);
-var import_node_util = require("util");
-var import_node_buffer = require("buffer");
+var import_node_stream = __toESM(require("node:stream"), 1);
+var import_node_util = require("node:util");
+var import_node_buffer = require("node:buffer");
 init_fetch_blob();
 init_esm_min();
 
@@ -5062,12 +5509,8 @@ Object.defineProperties(Body.prototype, {
   blob: { enumerable: true },
   json: { enumerable: true },
   text: { enumerable: true },
-  data: { get: (0, import_node_util.deprecate)(
-    () => {
-    },
-    "data doesn't exist, use json(), text(), arrayBuffer(), or body instead",
-    "https://github.com/node-fetch/node-fetch/issues/1000 (response)"
-  ) }
+  data: { get: (0, import_node_util.deprecate)(() => {
+  }, "data doesn't exist, use json(), text(), arrayBuffer(), or body instead", "https://github.com/node-fetch/node-fetch/issues/1000 (response)") }
 });
 async function consumeBody(data) {
   if (data[INTERNALS].disturbed) {
@@ -5130,11 +5573,7 @@ var clone = (instance, highWaterMark) => {
   }
   return body;
 };
-var getNonSpecFormDataBoundary = (0, import_node_util.deprecate)(
-  (body) => body.getBoundary(),
-  "form-data doesn't follow the spec and requires special treatment. Use alternative package",
-  "https://github.com/node-fetch/node-fetch/issues/1167"
-);
+var getNonSpecFormDataBoundary = (0, import_node_util.deprecate)((body) => body.getBoundary(), "form-data doesn't follow the spec and requires special treatment. Use alternative package", "https://github.com/node-fetch/node-fetch/issues/1167");
 var extractContentType = (body, request) => {
   if (body === null) {
     return null;
@@ -5187,8 +5626,8 @@ var writeToStream = async (dest, { body }) => {
 };
 
 // node_modules/node-fetch/src/headers.js
-var import_node_util2 = require("util");
-var import_node_http = __toESM(require("http"), 1);
+var import_node_util2 = require("node:util");
+var import_node_http = __toESM(require("node:http"), 1);
 var validateHeaderName = typeof import_node_http.default.validateHeaderName === "function" ? import_node_http.default.validateHeaderName : (name) => {
   if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(name)) {
     const error = new TypeError(`Header name must be a valid HTTP token [${name}]`);
@@ -5249,21 +5688,14 @@ var Headers = class extends URLSearchParams {
             return (name, value) => {
               validateHeaderName(name);
               validateHeaderValue(name, String(value));
-              return URLSearchParams.prototype[p].call(
-                target,
-                String(name).toLowerCase(),
-                String(value)
-              );
+              return URLSearchParams.prototype[p].call(target, String(name).toLowerCase(), String(value));
             };
           case "delete":
           case "has":
           case "getAll":
             return (name) => {
               validateHeaderName(name);
-              return URLSearchParams.prototype[p].call(
-                target,
-                String(name).toLowerCase()
-              );
+              return URLSearchParams.prototype[p].call(target, String(name).toLowerCase());
             };
           case "keys":
             return () => {
@@ -5329,30 +5761,25 @@ var Headers = class extends URLSearchParams {
     }, {});
   }
 };
-Object.defineProperties(
-  Headers.prototype,
-  ["get", "entries", "forEach", "values"].reduce((result, property) => {
-    result[property] = { enumerable: true };
-    return result;
-  }, {})
-);
+Object.defineProperties(Headers.prototype, ["get", "entries", "forEach", "values"].reduce((result, property) => {
+  result[property] = { enumerable: true };
+  return result;
+}, {}));
 function fromRawHeaders(headers = []) {
-  return new Headers(
-    headers.reduce((result, value, index, array) => {
-      if (index % 2 === 0) {
-        result.push(array.slice(index, index + 2));
-      }
-      return result;
-    }, []).filter(([name, value]) => {
-      try {
-        validateHeaderName(name);
-        validateHeaderValue(name, String(value));
-        return true;
-      } catch {
-        return false;
-      }
-    })
-  );
+  return new Headers(headers.reduce((result, value, index, array) => {
+    if (index % 2 === 0) {
+      result.push(array.slice(index, index + 2));
+    }
+    return result;
+  }, []).filter(([name, value]) => {
+    try {
+      validateHeaderName(name);
+      validateHeaderValue(name, String(value));
+      return true;
+    } catch {
+      return false;
+    }
+  }));
 }
 
 // node_modules/node-fetch/src/utils/is-redirect.js
@@ -5446,10 +5873,9 @@ var Response = class extends Body {
     if (!headers.has("content-type")) {
       headers.set("content-type", "application/json");
     }
-    return new Response(body, {
-      ...init,
+    return new Response(body, __spreadProps(__spreadValues({}, init), {
       headers
-    });
+    }));
   }
   get [Symbol.toStringTag]() {
     return "Response";
@@ -5467,8 +5893,8 @@ Object.defineProperties(Response.prototype, {
 });
 
 // node_modules/node-fetch/src/request.js
-var import_node_url = require("url");
-var import_node_util3 = require("util");
+var import_node_url = require("node:url");
+var import_node_util3 = require("node:util");
 
 // node_modules/node-fetch/src/utils/get-search.js
 var getSearch = (parsedURL) => {
@@ -5481,7 +5907,7 @@ var getSearch = (parsedURL) => {
 };
 
 // node_modules/node-fetch/src/utils/referrer.js
-var import_node_net = require("net");
+var import_node_net = require("node:net");
 function stripURLForUseAsAReferrer(url, originOnly = false) {
   if (url == null) {
     return "no-referrer";
@@ -5625,12 +6051,8 @@ var INTERNALS3 = Symbol("Request internals");
 var isRequest = (object) => {
   return typeof object === "object" && typeof object[INTERNALS3] === "object";
 };
-var doBadDataWarn = (0, import_node_util3.deprecate)(
-  () => {
-  },
-  ".data is not a valid RequestInit property, use .body instead",
-  "https://github.com/node-fetch/node-fetch/issues/1000 (request)"
-);
+var doBadDataWarn = (0, import_node_util3.deprecate)(() => {
+}, ".data is not a valid RequestInit property, use .body instead", "https://github.com/node-fetch/node-fetch/issues/1000 (request)");
 var Request = class extends Body {
   constructor(input, init = {}) {
     let parsedURL;
@@ -5786,9 +6208,6 @@ var getNodeRequestOptions = (request) => {
   if (typeof agent === "function") {
     agent = agent(parsedURL);
   }
-  if (!headers.has("Connection") && !agent) {
-    headers.set("Connection", "close");
-  }
   const search = getSearch(parsedURL);
   const options = {
     path: parsedURL.pathname + search,
@@ -6137,3 +6556,10 @@ function createServiceClient(options) {
 /*! fetch-blob. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
 /*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
 /*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+/**
+ * @license
+ * web-streams-polyfill v3.3.2
+ * Copyright 2024 Mattias Buelens, Diwank Singh Tomer and other contributors.
+ * This code is released under the MIT license.
+ * SPDX-License-Identifier: MIT
+ */