request-iframe 0.2.0 → 0.2.2

package/esm/stream/file-stream.js

@@ -1,20 +1,21 @@
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 import "core-js/modules/es.array.iterator.js";
 import "core-js/modules/es.symbol.description.js";
 import "core-js/modules/es.array.from.js";
 import "core-js/modules/es.array.reduce.js";
-import "core-js/modules/es.array.slice.js";
 import "core-js/modules/es.array.filter.js";
-import "core-js/modules/es.object.get-own-property-descriptors.js";
+import "core-js/modules/es.array.slice.js";
 import "core-js/modules/es.regexp.exec.js";
 import "core-js/modules/es.regexp.to-string.js";
+import "core-js/modules/es.string.match.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
 import "core-js/modules/es.typed-array.uint8-array.js";
 import "core-js/modules/es.typed-array.fill.js";
 import "core-js/modules/es.typed-array.iterator.js";
@@ -26,6 +27,8 @@ import "core-js/modules/web.dom-collections.iterator.js";
 import { IframeWritableStream } from './writable-stream';
 import { IframeReadableStream } from './readable-stream';
 import { StreamType as StreamTypeConstant } from '../constants';
+import { blobToArrayBuffer } from '../utils/blob';
+var DEFAULT_FILE_CHUNK_SIZE = 256 * 1024; // 256KB
 
 /**
  * Convert Uint8Array to Base64 string
@@ -45,22 +48,208 @@ function uint8ArrayToBase64(uint8Array) {
 }
 
 /**
- * Convert Base64 string to Uint8Array
+ * Convert string to UTF-8 bytes.
+ *
+ * Notes:
+ * - We prefer TextEncoder when available.
+ * - Fallback uses `unescape(encodeURIComponent(...))` for broad browser compatibility.
  */
-function base64ToUint8Array(base64) {
-  var binary = atob(base64);
-  var uint8Array = new Uint8Array(binary.length);
-  for (var i = 0; i < binary.length; i++) {
-    uint8Array[i] = binary.charCodeAt(i);
+function stringToUtf8Uint8Array(value) {
+  try {
+    if (typeof TextEncoder !== 'undefined') {
+      return new TextEncoder().encode(value);
+    }
+  } catch (_unused) {
+    /** ignore */
+  }
+  var latin1 = unescape(encodeURIComponent(value));
+  var arr = new Uint8Array(latin1.length);
+  for (var i = 0; i < latin1.length; i++) {
+    arr[i] = latin1.charCodeAt(i);
   }
-  return uint8Array;
+  return arr;
+}
+
+/**
+ * Convert UTF-8 bytes to string.
+ *
+ * Notes:
+ * - We prefer TextDecoder when available.
+ * - Fallback uses `escape/decodeURIComponent` for broad browser compatibility.
+ */
+function utf8Uint8ArrayToString(bytes) {
+  try {
+    if (typeof TextDecoder !== 'undefined') {
+      return new TextDecoder('utf-8').decode(bytes);
+    }
+  } catch (_unused2) {
+    /** ignore */
+  }
+  /**
+   * Fallback:
+   * - Build a latin1 string from bytes, then decode as UTF-8.
+   * - We chunk to avoid call stack / argument limits.
+   */
+  var chunkSize = 0x8000;
+  var parts = [];
+  for (var i = 0; i < bytes.length; i += chunkSize) {
+    var chunk = bytes.subarray(i, i + chunkSize);
+    parts.push(String.fromCharCode.apply(null, chunk));
+  }
+  return decodeURIComponent(escape(parts.join('')));
 }
 
 /**
  * IframeFileWritableStream - Server-side file writable stream
- * Automatically handles Base64 encoding of file content
+ *
+ * Notes:
+ * - This stream supports binary chunks (ArrayBuffer / Uint8Array), which can be transferred
+ *   via postMessage transfer list for better performance.
  */
 export class IframeFileWritableStream extends IframeWritableStream {
+  /**
+   * Create a file writable stream from string/Blob/File.
+   *
+   * This is a stream-layer utility:
+   * - It does NOT depend on headers.
+   * - It produces binary chunks (ArrayBuffer) for better performance.
+   */
+  static from(params) {
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var _params$chunked, _params$autoResolve;
+      var mimeType, fileName, size, t, blob, streamFileName, chunked, chunkSize, offset, stream;
+      return _regeneratorRuntime.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            mimeType = params.mimeType || params.defaultMimeType || 'application/octet-stream';
+            fileName = params.fileName;
+            try {
+              if (typeof File !== 'undefined' && params.content instanceof File) {
+                mimeType = params.content.type || mimeType;
+                fileName = fileName || params.content.name;
+                size = params.content.size;
+              }
+            } catch (_unused3) {
+              /** ignore */
+            }
+            try {
+              if (!fileName && typeof Blob !== 'undefined' && params.content instanceof Blob) {
+                t = params.content.type;
+                if (t) mimeType = t;
+                size = params.content.size;
+              }
+            } catch (_unused4) {
+              /** ignore */
+            }
+            blob = typeof params.content === 'string' ? new Blob([params.content], {
+              type: mimeType
+            }) : params.content;
+            size = size !== null && size !== void 0 ? size : blob === null || blob === void 0 ? void 0 : blob.size;
+            streamFileName = fileName || params.defaultFileName || 'file';
+            chunked = (_params$chunked = params.chunked) !== null && _params$chunked !== void 0 ? _params$chunked : false;
+            chunkSize = typeof params.chunkSize === 'number' && Number.isFinite(params.chunkSize) && params.chunkSize > 0 ? Math.floor(params.chunkSize) : DEFAULT_FILE_CHUNK_SIZE;
+            offset = 0;
+            stream = new IframeFileWritableStream({
+              filename: streamFileName,
+              mimeType,
+              size,
+              chunked,
+              autoResolve: (_params$autoResolve = params.autoResolve) !== null && _params$autoResolve !== void 0 ? _params$autoResolve : true,
+              next: function () {
+                var _next = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+                  var _size;
+                  var all, total, end, slice, buf;
+                  return _regeneratorRuntime.wrap(function (_context) {
+                    while (1) switch (_context.prev = _context.next) {
+                      case 0:
+                        if (chunked) {
+                          _context.next = 2;
+                          break;
+                        }
+                        _context.next = 1;
+                        return blobToArrayBuffer(blob);
+                      case 1:
+                        all = _context.sent;
+                        return _context.abrupt("return", {
+                          data: all,
+                          done: true
+                        });
+                      case 2:
+                        total = (_size = blob.size) !== null && _size !== void 0 ? _size : 0;
+                        if (!(offset >= total)) {
+                          _context.next = 3;
+                          break;
+                        }
+                        return _context.abrupt("return", {
+                          data: new ArrayBuffer(0),
+                          done: true
+                        });
+                      case 3:
+                        end = Math.min(total, offset + chunkSize);
+                        slice = blob.slice(offset, end);
+                        _context.next = 4;
+                        return blobToArrayBuffer(slice);
+                      case 4:
+                        buf = _context.sent;
+                        offset = end;
+                        return _context.abrupt("return", {
+                          data: buf,
+                          done: offset >= total
+                        });
+                      case 5:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }, _callee);
+                }));
+                function next() {
+                  return _next.apply(this, arguments);
+                }
+                return next;
+              }()
+            });
+            return _context2.abrupt("return", stream);
+          case 1:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }))();
+  }
+
+  /**
+   * Create a UTF-8 text file stream.
+   *
+   * This is a convenience wrapper around from({ content: string, ... }):
+   * - Makes "string -> UTF-8 bytes -> file stream" intent explicit.
+   * - Sets a more appropriate default mimeType for text files.
+   */
+  static fromText(params) {
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var _params$mimeType, _params$defaultFileNa;
+      return _regeneratorRuntime.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 1;
+            return IframeFileWritableStream.from({
+              content: params.text,
+              fileName: params.fileName,
+              mimeType: (_params$mimeType = params.mimeType) !== null && _params$mimeType !== void 0 ? _params$mimeType : 'text/plain; charset=utf-8',
+              chunked: params.chunked,
+              chunkSize: params.chunkSize,
+              autoResolve: params.autoResolve,
+              defaultFileName: (_params$defaultFileNa = params.defaultFileName) !== null && _params$defaultFileNa !== void 0 ? _params$defaultFileNa : 'file.txt',
+              defaultMimeType: 'text/plain; charset=utf-8'
+            });
+          case 1:
+            return _context3.abrupt("return", _context3.sent);
+          case 2:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }))();
+  }
   constructor(options) {
     super(_objectSpread(_objectSpread({}, options), {}, {
       type: StreamTypeConstant.FILE,
@@ -76,27 +265,32 @@ export class IframeFileWritableStream extends IframeWritableStream {
   }
 
   /**
-   * Override encode method to convert Uint8Array to Base64
+   * Encode outbound chunk.
+   *
+   * - ArrayBuffer / TypedArray: keep as-is (binary chunks)
+   * - string: encoded as UTF-8 bytes
    */
   encodeData(data) {
-    if (data instanceof Uint8Array) {
-      return uint8ArrayToBase64(data);
-    }
-    if (data instanceof ArrayBuffer) {
-      return uint8ArrayToBase64(new Uint8Array(data));
+    try {
+      if (typeof ArrayBuffer !== 'undefined' && data instanceof ArrayBuffer) {
+        return data;
+      }
+      if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView && ArrayBuffer.isView(data)) {
+        return data;
+      }
+    } catch (_unused5) {
+      /** ignore */
     }
     if (typeof data === 'string') {
-      // Already a base64 string
-      return data;
+      return stringToUtf8Uint8Array(data);
     }
-    // Try to convert other types
-    return String(data);
+    return stringToUtf8Uint8Array(String(data));
   }
 }
 
 /**
  * IframeFileReadableStream - Client-side file readable stream
- * Automatically handles Base64 decoding of file content
+ * Automatically normalizes inbound chunks to Uint8Array.
  */
 export class IframeFileReadableStream extends IframeReadableStream {
   constructor(streamId, requestId, messageHandler, options = {}) {
@@ -110,11 +304,11 @@ export class IframeFileReadableStream extends IframeReadableStream {
   }
 
   /**
-   * Override decode method to convert Base64 to Uint8Array
+   * Override decode method to normalize chunk to Uint8Array.
    */
   decodeData(data) {
     if (typeof data === 'string') {
-      return base64ToUint8Array(data);
+      return stringToUtf8Uint8Array(data);
     }
     if (data instanceof Uint8Array) {
       return data;
@@ -125,6 +319,24 @@ export class IframeFileReadableStream extends IframeReadableStream {
     return new Uint8Array();
   }
 
+  /**
+   * Parse filename from Content-Disposition header value.
+   */
+  static parseFilenameFromContentDisposition(value) {
+    if (!value) return undefined;
+    var disposition = typeof value === 'string' ? value : value[0];
+    if (!disposition) return undefined;
+    var match = disposition.match(/filename="?([^"]+)"?/i);
+    return match ? match[1] : undefined;
+  }
+
+  /**
+   * Resolve this file stream to File or Blob, depending on whether fileName is provided.
+   */
+  readAsFileOrBlob(fileName) {
+    return fileName ? this.readAsFile(fileName) : this.readAsBlob();
+  }
+
   /**
    * Override merge method to merge all Uint8Array chunks
    */
@@ -165,19 +377,19 @@ export class IframeFileReadableStream extends IframeReadableStream {
   read() {
     var _superprop_getRead = () => super.read,
       _this = this;
-    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      return _regeneratorRuntime.wrap(function (_context) {
-        while (1) switch (_context.prev = _context.next) {
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+      return _regeneratorRuntime.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
           case 0:
-            _context.next = 1;
+            _context4.next = 1;
             return _superprop_getRead().call(_this);
           case 1:
-            return _context.abrupt("return", _context.sent);
+            return _context4.abrupt("return", _context4.sent);
           case 2:
           case "end":
-            return _context.stop();
+            return _context4.stop();
         }
-      }, _callee);
+      }, _callee4);
     }))();
   }
 
@@ -186,25 +398,52 @@ export class IframeFileReadableStream extends IframeReadableStream {
    */
   readAsBlob() {
     var _this2 = this;
-    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
       var data, buffer;
-      return _regeneratorRuntime.wrap(function (_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
+      return _regeneratorRuntime.wrap(function (_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
           case 0:
-            _context2.next = 1;
+            _context5.next = 1;
             return _this2.read();
           case 1:
-            data = _context2.sent;
+            data = _context5.sent;
             // Use slice to create a pure ArrayBuffer copy to avoid type issues
             buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-            return _context2.abrupt("return", new Blob([buffer], {
+            return _context5.abrupt("return", new Blob([buffer], {
               type: _this2.mimeType || 'application/octet-stream'
             }));
           case 2:
           case "end":
-            return _context2.stop();
+            return _context5.stop();
         }
-      }, _callee2);
+      }, _callee5);
+    }))();
+  }
+
+  /**
+   * Read as UTF-8 text.
+   *
+   * Notes:
+   * - This is intended for "text file" use cases where file stream chunks represent UTF-8 bytes.
+   * - For non-UTF-8 binary files, use readAsBlob()/readAsArrayBuffer().
+   */
+  readAsText() {
+    var _this3 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+      var data;
+      return _regeneratorRuntime.wrap(function (_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            _context6.next = 1;
+            return _this3.read();
+          case 1:
+            data = _context6.sent;
+            return _context6.abrupt("return", utf8Uint8ArrayToString(data));
+          case 2:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6);
     }))();
   }
 
@@ -213,27 +452,27 @@ export class IframeFileReadableStream extends IframeReadableStream {
    * @param fileName Optional file name (if not provided, uses stream's filename)
    */
   readAsFile(fileName) {
-    var _this3 = this;
-    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    var _this4 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
       var data, buffer, name;
-      return _regeneratorRuntime.wrap(function (_context3) {
-        while (1) switch (_context3.prev = _context3.next) {
+      return _regeneratorRuntime.wrap(function (_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
           case 0:
-            _context3.next = 1;
-            return _this3.read();
+            _context7.next = 1;
+            return _this4.read();
           case 1:
-            data = _context3.sent;
+            data = _context7.sent;
             // Use slice to create a pure ArrayBuffer copy to avoid type issues
             buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-            name = fileName || _this3.filename || 'file';
-            return _context3.abrupt("return", new File([buffer], name, {
-              type: _this3.mimeType || 'application/octet-stream'
+            name = fileName || _this4.filename || 'file';
+            return _context7.abrupt("return", new File([buffer], name, {
+              type: _this4.mimeType || 'application/octet-stream'
             }));
           case 2:
           case "end":
-            return _context3.stop();
+            return _context7.stop();
         }
-      }, _callee3);
+      }, _callee7);
     }))();
   }
 
@@ -241,25 +480,25 @@ export class IframeFileReadableStream extends IframeReadableStream {
    * Read as ArrayBuffer
    */
   readAsArrayBuffer() {
-    var _this4 = this;
-    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _this5 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
       var data, buffer;
-      return _regeneratorRuntime.wrap(function (_context4) {
-        while (1) switch (_context4.prev = _context4.next) {
+      return _regeneratorRuntime.wrap(function (_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
           case 0:
-            _context4.next = 1;
-            return _this4.read();
+            _context8.next = 1;
+            return _this5.read();
           case 1:
-            data = _context4.sent;
+            data = _context8.sent;
             // Create a new ArrayBuffer copy
             buffer = new ArrayBuffer(data.byteLength);
             new Uint8Array(buffer).set(data);
-            return _context4.abrupt("return", buffer);
+            return _context8.abrupt("return", buffer);
           case 2:
           case "end":
-            return _context4.stop();
+            return _context8.stop();
         }
-      }, _callee4);
+      }, _callee8);
     }))();
   }
 
@@ -267,23 +506,23 @@ export class IframeFileReadableStream extends IframeReadableStream {
    * Read as Data URL
    */
   readAsDataURL() {
-    var _this5 = this;
-    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+    var _this6 = this;
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
       var data, base64;
-      return _regeneratorRuntime.wrap(function (_context5) {
-        while (1) switch (_context5.prev = _context5.next) {
+      return _regeneratorRuntime.wrap(function (_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
           case 0:
-            _context5.next = 1;
-            return _this5.read();
+            _context9.next = 1;
+            return _this6.read();
           case 1:
-            data = _context5.sent;
+            data = _context9.sent;
             base64 = uint8ArrayToBase64(data);
-            return _context5.abrupt("return", `data:${_this5.mimeType || 'application/octet-stream'};base64,${base64}`);
+            return _context9.abrupt("return", `data:${_this6.mimeType || 'application/octet-stream'};base64,${base64}`);
           case 2:
           case "end":
-            return _context5.stop();
+            return _context9.stop();
         }
-      }, _callee5);
+      }, _callee9);
     }))();
   }
 }

package/esm/stream/writable-stream.js

@@ -301,7 +301,24 @@ export class IframeWritableStream extends IframeStreamCore {
       creatorId,
       targetId: this.context.targetId
     });
-    var ok = this.context.channel.send(this.context.targetWindow, message, this.context.targetOrigin);
+
+    /**
+     * Transferable optimization:
+     * - If payload contains ArrayBuffer/TypedArray, transfer its underlying buffer to avoid copy.
+     * - This helps large chunks (e.g. file streams) significantly.
+     */
+    var payloadData = data === null || data === void 0 ? void 0 : data.data;
+    var transfer;
+    try {
+      if (typeof ArrayBuffer !== 'undefined' && payloadData instanceof ArrayBuffer) {
+        transfer = [payloadData];
+      } else if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && payloadData && ArrayBuffer.isView(payloadData) && payloadData.buffer instanceof ArrayBuffer) {
+        transfer = [payloadData.buffer];
+      }
+    } catch (_unused6) {
+      /** ignore */
+    }
+    var ok = this.context.channel.send(this.context.targetWindow, message, this.context.targetOrigin, transfer);
     if (!ok) {
       this._state = StreamStateConstant.CANCELLED;
       this.clearExpireTimer();
@@ -346,7 +363,7 @@ export class IframeWritableStream extends IframeStreamCore {
       if (isFunction(ch.removeReceiver)) {
         try {
           ch.removeReceiver(this.ackReceiver);
-        } catch (_unused6) {
+        } catch (_unused7) {
           /** ignore */
         }
       }
@@ -381,7 +398,7 @@ export class IframeWritableStream extends IframeStreamCore {
           timeout: expireTimeout
         });
         this.error(formatMessage(Messages.STREAM_EXPIRED, expireTimeout));
-      } catch (_unused7) {
+      } catch (_unused8) {
         /** ignore timer-triggered send failures */
       }
     }, expireTimeout);
@@ -896,7 +913,7 @@ export class IframeWritableStream extends IframeStreamCore {
         this.sendMessage(MessageType.STREAM_CANCEL, {
           reason
         });
-      } catch (_unused8) {
+      } catch (_unused9) {
         // ignore send failures on cancel
       }
     }

package/esm/utils/blob.js

@@ -13,4 +13,21 @@ export function blobToBase64(blob) {
     reader.onerror = reject;
     reader.readAsDataURL(blob);
   });
+}
+
+/**
+ * Convert Blob to ArrayBuffer.
+ *
+ * Notes:
+ * - Use FileReader for legacy browser support (e.g. Chrome 49).
+ */
+export function blobToArrayBuffer(blob) {
+  return new Promise((resolve, reject) => {
+    var reader = new FileReader();
+    reader.onloadend = () => {
+      resolve(reader.result);
+    };
+    reader.onerror = reject;
+    reader.readAsArrayBuffer(blob);
+  });
 }

package/esm/utils/debug-lazy.js

@@ -0,0 +1,76 @@
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/es.weak-map.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+/**
+ * Lazy-load debug helpers (dynamic import) with shared caching.
+ *
+ * Why:
+ * - Avoid eagerly bundling debug wiring into the main bundle.
+ * - Keep one shared Promise so multiple entry points don't trigger multiple imports.
+ */
+
+var debugModulePromise = null;
+export function loadDebugModule() {
+  if (!debugModulePromise) {
+    debugModulePromise = import('./debug');
+  }
+  return debugModulePromise;
+}
+var CLIENT_DEBUG_STATE = new WeakMap();
+var CLIENT_DEBUG_WRAPPED = Symbol.for('__requestIframeClientDebugWrapped__');
+
+/**
+ * Ensure debug interceptors/listeners are attached to a client instance.
+ *
+ * Notes:
+ * - This returns a Promise that never rejects (best-effort).
+ * - It is safe to call multiple times; only attaches once per client instance.
+ */
+export function ensureClientDebugInterceptors(client) {
+  var key = client;
+  var state = CLIENT_DEBUG_STATE.get(key);
+  if (!state) {
+    state = {
+      promise: null,
+      attached: false
+    };
+    CLIENT_DEBUG_STATE.set(key, state);
+  }
+  if (state.attached) return Promise.resolve();
+  if (!state.promise) {
+    state.promise = loadDebugModule().then(m => {
+      if (state.attached) return;
+      m.setupClientDebugInterceptors(client);
+      state.attached = true;
+    }).catch(() => {
+      /** ignore */
+    });
+  }
+  return state.promise;
+}
+
+/**
+ * Wrap client send methods so the first request in trace mode won't miss debug hooks.
+ *
+ * Why:
+ * - debug module is lazy-loaded via dynamic import, so it may not be ready immediately.
+ * - In trace mode, it's acceptable to delay the first send by a microtask or module-load time.
+ */
+export function wrapClientMethodsForDebug(client) {
+  var c = client;
+  if (c[CLIENT_DEBUG_WRAPPED]) return;
+  c[CLIENT_DEBUG_WRAPPED] = true;
+  var wrapAsyncMethod = name => {
+    var original = c[name];
+    if (typeof original !== 'function') return;
+    var bound = original.bind(c);
+    c[name] = (...args) => {
+      return ensureClientDebugInterceptors(client).then(() => bound(...args));
+    };
+  };
+  wrapAsyncMethod('send');
+  wrapAsyncMethod('sendFile');
+  wrapAsyncMethod('sendStream');
+  wrapAsyncMethod('isConnect');
+}