@rg-dev/stdlib 1.0.42 → 1.0.43

package/lib/node-download.cjs

@@ -1,9 +1,30 @@
 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 __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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;
 };
@@ -31,6 +52,54 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __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), value);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x2 = generator[k](v), isAwait = (v = x2.value) instanceof __await, done = x2.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e2) => resume("throw", e2, yes, no));
+    } catch (e2) {
+      no(e2);
+    }
+  }, method = (k) => it[k] = (x2) => new Promise((yes, no) => resume(k, x2, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x2) => obj[k](x2);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x2 = obj[k](v);
+          if (!(x2 instanceof Object)) __typeError("Object expected");
+          resolve(x2);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x2) => {
+    throw x2;
+  }, "return" in obj && method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
 
 // node_modules/data-uri-to-buffer/dist/index.js
 function dataUriToBuffer(uri) {
@@ -520,7 +589,9 @@ var require_ponyfill_es2018 = __commonJS({
       function defaultReaderBrandCheckException(name) {
         return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
       }
-      const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {
+      const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(function() {
+        return __asyncGenerator(this, null, function* () {
+        });
       }).prototype);
       class ReadableStreamAsyncIteratorImpl {
         constructor(reader, preventCancel) {
@@ -624,7 +695,7 @@ var require_ponyfill_es2018 = __commonJS({
         }
         try {
           return x2._asyncIteratorImpl instanceof ReadableStreamAsyncIteratorImpl;
-        } catch (_a) {
+        } catch (_a4) {
           return false;
         }
       }
@@ -1517,7 +1588,7 @@ var require_ponyfill_es2018 = __commonJS({
         }
         try {
           return typeof value.aborted === "boolean";
-        } catch (_a) {
+        } catch (_a4) {
           return false;
         }
       }
@@ -1658,12 +1729,12 @@ var require_ponyfill_es2018 = __commonJS({
         return true;
       }
       function WritableStreamAbort(stream, reason) {
-        var _a;
+        var _a4;
         if (stream._state === "closed" || stream._state === "errored") {
           return promiseResolvedWith(void 0);
         }
         stream._writableStreamController._abortReason = reason;
-        (_a = stream._writableStreamController._abortController) === null || _a === void 0 ? void 0 : _a.abort();
+        (_a4 = stream._writableStreamController._abortController) === null || _a4 === void 0 ? void 0 : _a4.abort();
         const state = stream._state;
         if (state === "closed" || state === "errored") {
           return promiseResolvedWith(void 0);
@@ -2393,7 +2464,7 @@ var require_ponyfill_es2018 = __commonJS({
         try {
           new ctor();
           return true;
-        } catch (_a) {
+        } catch (_a4) {
           return false;
         }
       }
@@ -3449,7 +3520,7 @@ var require_ponyfill_es2018 = __commonJS({
           value: "size",
           configurable: true
         });
-      } catch (_a) {
+      } catch (_a4) {
       }
       class ByteLengthQueuingStrategy {
         constructor(options) {
@@ -3506,7 +3577,7 @@ var require_ponyfill_es2018 = __commonJS({
           value: "size",
           configurable: true
         });
-      } catch (_a) {
+      } catch (_a4) {
       }
       class CountQueuingStrategy {
         constructor(options) {
@@ -3908,9 +3979,9 @@ var require_streams = __commonJS({
       }
     }
     try {
-      const { Blob: Blob3 } = require("buffer");
-      if (Blob3 && !Blob3.prototype.stream) {
-        Blob3.prototype.stream = function name(params) {
+      const { Blob: Blob2 } = require("buffer");
+      if (Blob2 && !Blob2.prototype.stream) {
+        Blob2.prototype.stream = function name(params) {
           let position = 0;
           const blob = this;
           return new ReadableStream({
@@ -3933,51 +4004,48 @@ var require_streams = __commonJS({
 });
 
 // node_modules/fetch-blob/index.js
-async function* toIterator(parts, clone2 = true) {
-  for (const part of parts) {
-    if ("stream" in part) {
-      yield* (
-        /** @type {AsyncIterableIterator<Uint8Array>} */
-        part.stream()
-      );
-    } else if (ArrayBuffer.isView(part)) {
-      if (clone2) {
-        let position = part.byteOffset;
-        const end = part.byteOffset + part.byteLength;
-        while (position !== end) {
-          const size = Math.min(end - position, POOL_SIZE);
-          const chunk = part.buffer.slice(position, position + size);
-          position += chunk.byteLength;
-          yield new Uint8Array(chunk);
+function toIterator(parts, clone2 = true) {
+  return __asyncGenerator(this, null, function* () {
+    for (const part of parts) {
+      if ("stream" in part) {
+        yield* __yieldStar(
+          /** @type {AsyncIterableIterator<Uint8Array>} */
+          part.stream()
+        );
+      } else if (ArrayBuffer.isView(part)) {
+        if (clone2) {
+          let position = part.byteOffset;
+          const end = part.byteOffset + part.byteLength;
+          while (position !== end) {
+            const size = Math.min(end - position, POOL_SIZE);
+            const chunk = part.buffer.slice(position, position + size);
+            position += chunk.byteLength;
+            yield new Uint8Array(chunk);
+          }
+        } else {
+          yield part;
         }
       } else {
-        yield part;
-      }
-    } else {
-      let position = 0, b = (
-        /** @type {Blob} */
-        part
-      );
-      while (position !== b.size) {
-        const chunk = b.slice(position, Math.min(b.size, position + POOL_SIZE));
-        const buffer = await chunk.arrayBuffer();
-        position += buffer.byteLength;
-        yield new Uint8Array(buffer);
+        let position = 0, b = (
+          /** @type {Blob} */
+          part
+        );
+        while (position !== b.size) {
+          const chunk = b.slice(position, Math.min(b.size, position + POOL_SIZE));
+          const buffer = yield new __await(chunk.arrayBuffer());
+          position += buffer.byteLength;
+          yield new Uint8Array(buffer);
+        }
       }
     }
-  }
+  });
 }
-var import_streams, POOL_SIZE, _Blob, Blob2, fetch_blob_default;
+var import_streams, POOL_SIZE, _parts, _type, _size, _endings, _a, _Blob, Blob, fetch_blob_default;
 var init_fetch_blob = __esm({
   "node_modules/fetch-blob/index.js"() {
     import_streams = __toESM(require_streams(), 1);
     POOL_SIZE = 65536;
-    _Blob = class Blob {
-      /** @type {Array.<(Blob|Uint8Array)>} */
-      #parts = [];
-      #type = "";
-      #size = 0;
-      #endings = "transparent";
+    _Blob = (_a = class {
       /**
        * The Blob() constructor returns a new Blob object. The content
        * of the blob consists of the concatenation of the values given
@@ -3987,6 +4055,11 @@ var init_fetch_blob = __esm({
        * @param {{ type?: string, endings?: string }} [options]
        */
       constructor(blobParts = [], options = {}) {
+        /** @type {Array.<(Blob|Uint8Array)>} */
+        __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.");
         }
@@ -4004,30 +4077,30 @@ 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 Blob) {
+          } else if (element instanceof _a) {
             part = element;
           } else {
             part = encoder.encode(`${element}`);
           }
-          this.#size += ArrayBuffer.isView(part) ? part.byteLength : part.size;
-          this.#parts.push(part);
+          __privateSet(this, _size, __privateGet(this, _size) + (ArrayBuffer.isView(part) ? part.byteLength : part.size));
+          __privateGet(this, _parts).push(part);
         }
-        this.#endings = `${options.endings === void 0 ? "transparent" : options.endings}`;
+        __privateSet(this, _endings, `${options.endings === void 0 ? "transparent" : options.endings}`);
         const type = options.type === void 0 ? "" : String(options.type);
-        this.#type = /^[\x20-\x7E]*$/.test(type) ? type : "";
+        __privateSet(this, _type, /^[\x20-\x7E]*$/.test(type) ? type : "");
       }
       /**
        * The Blob interface's size property returns the
        * size of the Blob in bytes.
        */
       get size() {
-        return this.#size;
+        return __privateGet(this, _size);
       }
       /**
        * The type property of a Blob object returns the MIME type of the file.
        */
       get type() {
-        return this.#type;
+        return __privateGet(this, _type);
       }
       /**
        * The text() method in the Blob interface returns a Promise
@@ -4039,8 +4112,20 @@ var init_fetch_blob = __esm({
       async text() {
         const decoder = new TextDecoder();
         let str = "";
-        for await (const part of toIterator(this.#parts, false)) {
-          str += decoder.decode(part, { stream: true });
+        try {
+          for (var iter = __forAwait(toIterator(__privateGet(this, _parts), false)), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+            const part = temp.value;
+            str += decoder.decode(part, { stream: true });
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && await temp.call(iter);
+          } finally {
+            if (error)
+              throw error[0];
+          }
         }
         str += decoder.decode();
         return str;
@@ -4055,14 +4140,26 @@ var init_fetch_blob = __esm({
       async arrayBuffer() {
         const data = new Uint8Array(this.size);
         let offset = 0;
-        for await (const chunk of toIterator(this.#parts, false)) {
-          data.set(chunk, offset);
-          offset += chunk.length;
+        try {
+          for (var iter = __forAwait(toIterator(__privateGet(this, _parts), false)), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+            const chunk = temp.value;
+            data.set(chunk, offset);
+            offset += chunk.length;
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && await temp.call(iter);
+          } finally {
+            if (error)
+              throw error[0];
+          }
         }
         return data.buffer;
       }
       stream() {
-        const it = toIterator(this.#parts, true);
+        const it = toIterator(__privateGet(this, _parts), true);
         return new globalThis.ReadableStream({
           // @ts-ignore
           type: "bytes",
@@ -4089,7 +4186,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 = this.#parts;
+        const parts = __privateGet(this, _parts);
         const blobParts = [];
         let added = 0;
         for (const part of parts) {
@@ -4114,9 +4211,9 @@ var init_fetch_blob = __esm({
             relativeStart = 0;
           }
         }
-        const blob = new Blob([], { type: String(type).toLowerCase() });
-        blob.#size = span;
-        blob.#parts = blobParts;
+        const blob = new _a([], { type: String(type).toLowerCase() });
+        __privateSet(blob, _size, span);
+        __privateSet(blob, _parts, blobParts);
         return blob;
       }
       get [Symbol.toStringTag]() {
@@ -4125,25 +4222,23 @@ 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 }
     });
-    Blob2 = _Blob;
-    fetch_blob_default = Blob2;
+    Blob = _Blob;
+    fetch_blob_default = Blob;
   }
 });
 
 // node_modules/fetch-blob/file.js
-var _File, File2, file_default;
+var _lastModified, _name, _a2, _File, File, file_default;
 var init_file = __esm({
   "node_modules/fetch-blob/file.js"() {
     init_fetch_blob();
-    _File = class File extends fetch_blob_default {
-      #lastModified = 0;
-      #name = "";
+    _File = (_a2 = class extends fetch_blob_default {
       /**
        * @param {*[]} fileBits
        * @param {string} fileName
@@ -4155,18 +4250,20 @@ var init_file = __esm({
           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)) {
-          this.#lastModified = lastModified;
+          __privateSet(this, _lastModified, lastModified);
         }
-        this.#name = String(fileName);
+        __privateSet(this, _name, String(fileName));
       }
       get name() {
-        return this.#name;
+        return __privateGet(this, _name);
       }
       get lastModified() {
-        return this.#lastModified;
+        return __privateGet(this, _lastModified);
       }
       get [Symbol.toStringTag]() {
         return "File";
@@ -4174,9 +4271,9 @@ var init_file = __esm({
       static [Symbol.hasInstance](object) {
         return !!object && object instanceof fetch_blob_default && /^(File)$/.test(object[Symbol.toStringTag]);
       }
-    };
-    File2 = _File;
-    file_default = File2;
+    }, _lastModified = new WeakMap(), _name = new WeakMap(), _a2);
+    File = _File;
+    file_default = File;
   }
 });
 
@@ -4186,7 +4283,7 @@ function formDataToBlob(F2, B = fetch_blob_default) {
 Content-Disposition: form-data; name="`;
   F2.forEach((v, n) => typeof v == "string" ? c.push(p + e(n) + `"\r
 \r
-${v.replace(/\r(?!\n)|(?<!\r)\n/g, "\r\n")}\r
+${v.replace(new RegExp("\\r(?!\\n)|(?<!\\r)\\n", "g"), "\r\n")}\r
 `) : c.push(p + e(n) + `"; filename="${e(v.name, 1)}"\r
 Content-Type: ${v.type || "application/octet-stream"}\r
 \r
@@ -4194,7 +4291,7 @@ 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, FormData;
+var t, i, h, r, m, f, e, x, _d, _a3, FormData;
 var init_esm_min = __esm({
   "node_modules/formdata-polyfill/esm.min.js"() {
     init_fetch_blob();
@@ -4209,9 +4306,9 @@ var init_esm_min = __esm({
         throw new TypeError(`Failed to execute '${n}' on 'FormData': ${e2} arguments required, but only ${a.length} present.`);
       }
     };
-    FormData = class FormData2 {
-      #d = [];
+    FormData = (_a3 = class {
       constructor(...a) {
+        __privateAdd(this, _d, []);
         if (a.length) throw new TypeError(`Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.`);
       }
       get [t]() {
@@ -4225,30 +4322,30 @@ var init_esm_min = __esm({
       }
       append(...a) {
         x("append", arguments, 2);
-        this.#d.push(f(...a));
+        __privateGet(this, _d).push(f(...a));
       }
       delete(a) {
         x("delete", arguments, 1);
         a += "";
-        this.#d = this.#d.filter(([b]) => b !== a);
+        __privateSet(this, _d, __privateGet(this, _d).filter(([b]) => b !== a));
       }
       get(a) {
         x("get", arguments, 1);
         a += "";
-        for (var b = this.#d, l = b.length, c = 0; c < l; c++) if (b[c][0] === a) return b[c][1];
+        for (var b = __privateGet(this, _d), l = b.length, c = 0; c < l; c++) if (b[c][0] === a) return b[c][1];
         return null;
       }
       getAll(a, b) {
         x("getAll", arguments, 1);
         b = [];
         a += "";
-        this.#d.forEach((c) => c[0] === a && b.push(c[1]));
+        __privateGet(this, _d).forEach((c) => c[0] === a && b.push(c[1]));
         return b;
       }
       has(a) {
         x("has", arguments, 1);
         a += "";
-        return this.#d.some((b) => b[0] === a);
+        return __privateGet(this, _d).some((b) => b[0] === a);
       }
       forEach(a, b) {
         x("forEach", arguments, 1);
@@ -4258,14 +4355,14 @@ var init_esm_min = __esm({
         x("set", arguments, 2);
         var b = [], c = true;
         a = f(...a);
-        this.#d.forEach((d) => {
+        __privateGet(this, _d).forEach((d) => {
           d[0] === a[0] ? c && (c = !b.push(a)) : b.push(d);
         });
         c && b.push(a);
-        this.#d = b;
+        __privateSet(this, _d, b);
       }
       *entries() {
-        yield* this.#d;
+        yield* __yieldStar(__privateGet(this, _d));
       }
       *keys() {
         for (var [a] of this) yield a;
@@ -4273,7 +4370,7 @@ var init_esm_min = __esm({
       *values() {
         for (var [, a] of this) yield a;
       }
-    };
+    }, _d = new WeakMap(), _a3);
   }
 });
 
@@ -4362,7 +4459,7 @@ var require_node_domexception = __commonJS({
 });
 
 // node_modules/fetch-blob/from.js
-var import_node_fs, import_node_path, import_node_domexception, stat, blobFromSync, blobFrom, fileFrom, fileFromSync, fromBlob, fromFile, BlobDataItem;
+var import_node_fs, import_node_path, import_node_domexception, stat, blobFromSync, blobFrom, fileFrom, fileFromSync, fromBlob, fromFile, _path, _start, _BlobDataItem, BlobDataItem;
 var init_from = __esm({
   "node_modules/fetch-blob/from.js"() {
     import_node_fs = require("fs");
@@ -4387,12 +4484,12 @@ var init_from = __esm({
       lastModified: stat2.mtimeMs,
       start: 0
     })], (0, import_node_path.basename)(path), { type, lastModified: stat2.mtimeMs });
-    BlobDataItem = class _BlobDataItem {
-      #path;
-      #start;
+    _BlobDataItem = class _BlobDataItem {
       constructor(options) {
-        this.#path = options.path;
-        this.#start = options.start;
+        __privateAdd(this, _path);
+        __privateAdd(this, _start);
+        __privateSet(this, _path, options.path);
+        __privateSet(this, _start, options.start);
         this.size = options.size;
         this.lastModified = options.lastModified;
       }
@@ -4402,26 +4499,31 @@ var init_from = __esm({
        */
       slice(start, end) {
         return new _BlobDataItem({
-          path: this.#path,
+          path: __privateGet(this, _path),
           lastModified: this.lastModified,
           size: end - start,
-          start: this.#start + start
+          start: __privateGet(this, _start) + start
         });
       }
-      async *stream() {
-        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)(this.#path, {
-          start: this.#start,
-          end: this.#start + this.size - 1
+      stream() {
+        return __asyncGenerator(this, null, function* () {
+          const { mtimeMs } = yield new __await(stat(__privateGet(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* __yieldStar((0, import_node_fs.createReadStream)(__privateGet(this, _path), {
+            start: __privateGet(this, _start),
+            end: __privateGet(this, _start) + this.size - 1
+          }));
         });
       }
       get [Symbol.toStringTag]() {
         return "Blob";
       }
     };
+    _path = new WeakMap();
+    _start = new WeakMap();
+    BlobDataItem = _BlobDataItem;
   }
 });
 
@@ -4511,8 +4613,20 @@ async function toFormData(Body2, ct) {
     headerValue = "";
     headerField = "";
   };
-  for await (const chunk of Body2) {
-    parser.write(chunk);
+  try {
+    for (var iter = __forAwait(Body2), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+      const chunk = temp.value;
+      parser.write(chunk);
+    }
+  } catch (temp) {
+    error = [temp];
+  } finally {
+    try {
+      more && (temp = iter.return) && await temp.call(iter);
+    } finally {
+      if (error)
+        throw error[0];
+    }
   }
   parser.end();
   return formData;
@@ -4806,17 +4920,29 @@ async function consumeBody(data) {
   const accum = [];
   let accumBytes = 0;
   try {
-    for await (const chunk of body) {
-      if (data.size > 0 && accumBytes + chunk.length > data.size) {
-        const error = new FetchError(`content size at ${data.url} over limit: ${data.size}`, "max-size");
-        body.destroy(error);
-        throw error;
+    try {
+      for (var iter = __forAwait(body), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+        const chunk = temp.value;
+        if (data.size > 0 && accumBytes + chunk.length > data.size) {
+          const error2 = new FetchError(`content size at ${data.url} over limit: ${data.size}`, "max-size");
+          body.destroy(error2);
+          throw error2;
+        }
+        accumBytes += chunk.length;
+        accum.push(chunk);
+      }
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && await temp.call(iter);
+      } finally {
+        if (error)
+          throw error[0];
       }
-      accumBytes += chunk.length;
-      accum.push(chunk);
     }
-  } catch (error) {
-    const error_ = error instanceof FetchBaseError ? error : new FetchError(`Invalid response body while trying to fetch ${data.url}: ${error.message}`, "system", error);
+  } catch (error2) {
+    const error_ = error2 instanceof FetchBaseError ? error2 : new FetchError(`Invalid response body while trying to fetch ${data.url}: ${error2.message}`, "system", error2);
     throw error_;
   }
   if (body.readableEnded === true || body._readableState.ended === true) {
@@ -4825,8 +4951,8 @@ async function consumeBody(data) {
         return import_node_buffer.Buffer.from(accum.join(""));
       }
       return import_node_buffer.Buffer.concat(accum, accumBytes);
-    } catch (error) {
-      throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${error.message}`, "system", error);
+    } catch (error2) {
+      throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${error2.message}`, "system", error2);
     }
   } else {
     throw new FetchError(`Premature close of server response while trying to fetch ${data.url}`);
@@ -5058,7 +5184,7 @@ function fromRawHeaders(headers = []) {
         validateHeaderName(name);
         validateHeaderValue(name, String(value));
         return true;
-      } catch {
+      } catch (e2) {
         return false;
       }
     })
@@ -5351,10 +5477,9 @@ var init_response = __esm({
         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";
@@ -5846,7 +5971,7 @@ async function fetch2(url, options_) {
         let locationURL = null;
         try {
           locationURL = location === null ? null : new URL(location, request.url);
-        } catch {
+        } catch (e2) {
           if (request.redirect !== "manual") {
             reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, "invalid-redirect"));
             finalize();
@@ -6084,7 +6209,7 @@ function downloadFile(url, destination, headers) {
     async (resolve, reject) => {
       try {
         const fetcher = await getFetch();
-        const response = await fetcher(url, { headers: { ...headers || {} } });
+        const response = await fetcher(url, { headers: __spreadValues({}, headers || {}) });
         if (!response.ok) {
           const { result: error } = await catchInline(response.text());
           throw new Error(`Error throwed while downloading file: ${error || "status code: " + response.status}`);
@@ -6097,10 +6222,13 @@ function downloadFile(url, destination, headers) {
           import_stream.Readable.fromWeb(body).pipe(dest);
         }
         dest.on("finish", () => resolve(destination));
-        dest.on("error", (e2) => {
-          console.error("error downloading", url);
-          reject(e2);
-        });
+        dest.on(
+          "error",
+          (e2) => {
+            console.error("error downloading", url);
+            reject(e2);
+          }
+        );
       } catch (e2) {
         console.error("error downloading", url);
         reject(e2);