request-iframe 0.0.1

package/library/message/dispatcher.js

@@ -0,0 +1,249 @@
+"use strict";
+
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MessageDispatcher = void 0;
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.array.sort.js");
+require("core-js/modules/es.array.splice.js");
+require("core-js/modules/es.regexp.constructor.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.to-string.js");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _utils = require("../utils");
+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; }
+/**
+ * Message handler function type
+ */
+
+/**
+ * Message type matcher
+ * - string: exact match message type
+ * - RegExp: regex match message type
+ * - function: custom match function
+ */
+
+/**
+ * Protocol version validator function
+ * @param version protocol version in message
+ * @returns true if version is compatible, false otherwise
+ */
+
+/**
+ * Message handler registration options
+ */
+
+/**
+ * Message handler entry
+ */
+
+/**
+ * MessageDispatcher - Message dispatcher for client/server interaction
+ * 
+ * Responsibilities:
+ * - Using MessageChannel for receiving and sending messages
+ * - Dispatching received messages to registered handlers
+ * - Managing handler registration/unregistration
+ * - Protocol version validation
+ * 
+ * This is the high-level interface used by client and server implementations.
+ * It works with transport-agnostic MessageContext instead of transport-specific MessageEvent.
+ */
+class MessageDispatcher {
+  constructor(channel) {
+    /** Secret key for message isolation */
+    /** Channel type */
+    /** Underlying message channel */
+    /** Message handler list */
+    (0, _defineProperty2.default)(this, "handlers", []);
+    /** Reference count (for determining if can be destroyed when cached) */
+    (0, _defineProperty2.default)(this, "refCount", 0);
+    this.channel = channel;
+    this.secretKey = channel.secretKey;
+    this.type = channel.type;
+
+    // Create bound receiver callback
+    this.boundReceiver = (data, context) => {
+      this.dispatchMessage(data, context);
+    };
+
+    // Add receiver callback to handle incoming messages
+    this.channel.addReceiver(this.boundReceiver);
+  }
+
+  // ==================== Reference Counting ====================
+
+  /**
+   * Increment reference count
+   */
+  addRef() {
+    this.refCount++;
+  }
+
+  /**
+   * Decrement reference count
+   * @returns current reference count
+   */
+  release() {
+    return --this.refCount;
+  }
+
+  /**
+   * Get reference count
+   */
+  getRefCount() {
+    return this.refCount;
+  }
+
+  // ==================== Message Handling ====================
+
+  /**
+   * Register message handler
+   * @param matcher message type matcher
+   * @param handler handler function
+   * @param options registration options (priority, version validation, etc.)
+   * @returns function to unregister
+   */
+  registerHandler(matcher, handler, options) {
+    var _opts$priority;
+    var opts = typeof options === 'number' ? {
+      priority: options
+    } : options || {};
+    var entry = {
+      matcher,
+      handler,
+      priority: (_opts$priority = opts.priority) !== null && _opts$priority !== void 0 ? _opts$priority : 0,
+      versionValidator: opts.versionValidator,
+      onVersionError: opts.onVersionError
+    };
+    this.handlers.push(entry);
+    // Sort by priority in descending order
+    this.handlers.sort((a, b) => b.priority - a.priority);
+    return () => {
+      var index = this.handlers.indexOf(entry);
+      if (index >= 0) {
+        this.handlers.splice(index, 1);
+      }
+    };
+  }
+
+  /**
+   * Unregister message handler
+   */
+  unregisterHandler(handler) {
+    var index = this.handlers.findIndex(entry => entry.handler === handler);
+    if (index >= 0) {
+      this.handlers.splice(index, 1);
+    }
+  }
+
+  /**
+   * Dispatch message to matching handlers
+   */
+  dispatchMessage(data, context) {
+    var type = data.type;
+    var version = (0, _utils.getProtocolVersion)(data);
+    var _iterator = _createForOfIteratorHelper(this.handlers),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var entry = _step.value;
+        if (this.matchType(type, entry.matcher)) {
+          // If handler specified version validation
+          if (entry.versionValidator && version !== undefined) {
+            if (!entry.versionValidator(version)) {
+              var _entry$onVersionError;
+              // Version incompatible, call error handler (if any)
+              (_entry$onVersionError = entry.onVersionError) === null || _entry$onVersionError === void 0 || _entry$onVersionError.call(entry, data, context, version);
+              continue; // Skip this handler, try other handlers
+            }
+          }
+          try {
+            entry.handler(data, context);
+          } catch (e) {
+            // Ignore handler exception, continue executing other handlers
+            console.error('[request-iframe] Handler error:', e);
+          }
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  /**
+   * Check if message type matches
+   */
+  matchType(type, matcher) {
+    if (typeof matcher === 'string') {
+      return type === matcher;
+    }
+    if (matcher instanceof RegExp) {
+      return matcher.test(type);
+    }
+    if (typeof matcher === 'function') {
+      return matcher(type);
+    }
+    return false;
+  }
+
+  // ==================== Sending (Delegated to Channel) ====================
+
+  /**
+   * Send raw message to target window
+   * @param target target window
+   * @param message message data (already formatted as PostMessageData)
+   * @param targetOrigin target origin (defaults to '*')
+   */
+  send(target, message, targetOrigin = '*') {
+    this.channel.send(target, message, targetOrigin);
+  }
+
+  /**
+   * Send typed message to target window (creates PostMessageData automatically)
+   * @param target target window
+   * @param targetOrigin target origin
+   * @param type message type
+   * @param requestId request ID
+   * @param data additional data
+   */
+  sendMessage(target, targetOrigin, type, requestId, data) {
+    this.channel.sendMessage(target, targetOrigin, type, requestId, data);
+  }
+
+  // ==================== Utilities ====================
+
+  /**
+   * Add path prefix
+   */
+  prefixPath(path) {
+    return this.channel.prefixPath(path);
+  }
+
+  /**
+   * Get the underlying message channel
+   */
+  getChannel() {
+    return this.channel;
+  }
+
+  /**
+   * Destroy dispatcher (clear handlers, but don't destroy channel as it may be shared)
+   */
+  destroy() {
+    this.handlers.length = 0;
+    this.channel.removeReceiver(this.boundReceiver);
+  }
+}
+exports.MessageDispatcher = MessageDispatcher;

package/library/message/index.d.ts

@@ -0,0 +1,5 @@
+export { MessageChannel, ChannelType } from './channel';
+export type { MessageContext, MessageReceiver } from './channel';
+export { MessageDispatcher } from './dispatcher';
+export type { MessageHandlerFn, MessageTypeMatcher, VersionValidator, HandlerOptions } from './dispatcher';
+//# sourceMappingURL=index.d.ts.map

package/library/message/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/message/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxD,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,YAAY,EACV,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,cAAc,EACf,MAAM,cAAc,CAAC"}

package/library/message/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ChannelType", {
+  enumerable: true,
+  get: function get() {
+    return _channel.ChannelType;
+  }
+});
+Object.defineProperty(exports, "MessageChannel", {
+  enumerable: true,
+  get: function get() {
+    return _channel.MessageChannel;
+  }
+});
+Object.defineProperty(exports, "MessageDispatcher", {
+  enumerable: true,
+  get: function get() {
+    return _dispatcher.MessageDispatcher;
+  }
+});
+var _channel = require("./channel");
+var _dispatcher = require("./dispatcher");

package/library/stream/file-stream.d.ts

@@ -0,0 +1,48 @@
+import { IframeWritableStream } from './writable-stream';
+import { IframeReadableStream, StreamMessageHandler } from './readable-stream';
+import { FileWritableStreamOptions, FileReadableStreamOptions, IIframeFileReadableStream } from './types';
+/**
+ * IframeFileWritableStream - Server-side file writable stream
+ * Automatically handles Base64 encoding of file content
+ */
+export declare class IframeFileWritableStream extends IframeWritableStream {
+    readonly filename: string;
+    readonly mimeType: string;
+    readonly size?: number;
+    constructor(options: FileWritableStreamOptions);
+    /**
+     * Override encode method to convert Uint8Array to Base64
+     */
+    protected encodeData(data: any): string;
+}
+/**
+ * IframeFileReadableStream - Client-side file readable stream
+ * Automatically handles Base64 decoding of file content
+ */
+export declare class IframeFileReadableStream extends IframeReadableStream<Uint8Array> implements IIframeFileReadableStream {
+    readonly filename?: string;
+    readonly mimeType?: string;
+    readonly size?: number;
+    constructor(streamId: string, requestId: string, messageHandler: StreamMessageHandler, options?: FileReadableStreamOptions);
+    /**
+     * Override decode method to convert Base64 to Uint8Array
+     */
+    protected decodeData(data: any): Uint8Array;
+    /**
+     * Override merge method to merge all Uint8Array chunks
+     */
+    protected mergeChunks(): Uint8Array;
+    /**
+     * Read as Blob
+     */
+    readAsBlob(): Promise<Blob>;
+    /**
+     * Read as ArrayBuffer
+     */
+    readAsArrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Read as Data URL
+     */
+    readAsDataURL(): Promise<string>;
+}
+//# sourceMappingURL=file-stream.d.ts.map

package/library/stream/file-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-stream.d.ts","sourceRoot":"","sources":["../../src/stream/file-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EAC1B,MAAM,SAAS,CAAC;AA0BjB;;;GAGG;AACH,qBAAa,wBAAyB,SAAQ,oBAAoB;IAChE,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,IAAI,CAAC,EAAE,MAAM,CAAC;gBAEX,OAAO,EAAE,yBAAyB;IAiBrD;;OAEG;IACH,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,GAAG,MAAM;CAcxC;AAED;;;GAGG;AACH,qBAAa,wBACX,SAAQ,oBAAoB,CAAC,UAAU,CACvC,YAAW,yBAAyB;IAEpC,SAAgB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClC,SAAgB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClC,SAAgB,IAAI,CAAC,EAAE,MAAM,CAAC;gBAG5B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,oBAAoB,EACpC,OAAO,GAAE,yBAA8B;IAYzC;;OAEG;IACH,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,GAAG,UAAU;IAa3C;;OAEG;IACH,SAAS,CAAC,WAAW,IAAI,UAAU;IAuBnC;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAOxC;;OAEG;IACU,iBAAiB,IAAI,OAAO,CAAC,WAAW,CAAC;IAQtD;;OAEG;IACU,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC;CAK9C"}

package/library/stream/file-stream.js

@@ -0,0 +1,240 @@
+"use strict";
+
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IframeFileWritableStream = exports.IframeFileReadableStream = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.reduce.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.typed-array.uint8-array.js");
+require("core-js/modules/es.typed-array.fill.js");
+require("core-js/modules/es.typed-array.iterator.js");
+require("core-js/modules/es.typed-array.set.js");
+require("core-js/modules/es.typed-array.sort.js");
+require("core-js/modules/es.typed-array.to-string.js");
+var _writableStream = require("./writable-stream");
+var _readableStream = require("./readable-stream");
+var _constants = require("../constants");
+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) { (0, _defineProperty2.default)(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; }
+/**
+ * Convert Uint8Array to Base64 string
+ */
+function uint8ArrayToBase64(uint8Array) {
+  var binary = '';
+  for (var i = 0; i < uint8Array.length; i++) {
+    binary += String.fromCharCode(uint8Array[i]);
+  }
+  return btoa(binary);
+}
+
+/**
+ * Convert Base64 string to Uint8Array
+ */
+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);
+  }
+  return uint8Array;
+}
+
+/**
+ * IframeFileWritableStream - Server-side file writable stream
+ * Automatically handles Base64 encoding of file content
+ */
+class IframeFileWritableStream extends _writableStream.IframeWritableStream {
+  constructor(options) {
+    super(_objectSpread(_objectSpread({}, options), {}, {
+      type: _constants.StreamType.FILE,
+      metadata: _objectSpread(_objectSpread({}, options.metadata), {}, {
+        filename: options.filename,
+        mimeType: options.mimeType || 'application/octet-stream',
+        size: options.size
+      })
+    }));
+    this.filename = options.filename;
+    this.mimeType = options.mimeType || 'application/octet-stream';
+    this.size = options.size;
+  }
+
+  /**
+   * Override encode method to convert Uint8Array to Base64
+   */
+  encodeData(data) {
+    if (data instanceof Uint8Array) {
+      return uint8ArrayToBase64(data);
+    }
+    if (data instanceof ArrayBuffer) {
+      return uint8ArrayToBase64(new Uint8Array(data));
+    }
+    if (typeof data === 'string') {
+      // Already a base64 string
+      return data;
+    }
+    // Try to convert other types
+    return String(data);
+  }
+}
+
+/**
+ * IframeFileReadableStream - Client-side file readable stream
+ * Automatically handles Base64 decoding of file content
+ */
+exports.IframeFileWritableStream = IframeFileWritableStream;
+class IframeFileReadableStream extends _readableStream.IframeReadableStream {
+  constructor(streamId, requestId, messageHandler, options = {}) {
+    var _options$metadata, _options$metadata2, _options$metadata3;
+    super(streamId, requestId, messageHandler, _objectSpread(_objectSpread({}, options), {}, {
+      type: _constants.StreamType.FILE
+    }));
+    this.filename = options.filename || ((_options$metadata = options.metadata) === null || _options$metadata === void 0 ? void 0 : _options$metadata.filename);
+    this.mimeType = options.mimeType || ((_options$metadata2 = options.metadata) === null || _options$metadata2 === void 0 ? void 0 : _options$metadata2.mimeType);
+    this.size = options.size || ((_options$metadata3 = options.metadata) === null || _options$metadata3 === void 0 ? void 0 : _options$metadata3.size);
+  }
+
+  /**
+   * Override decode method to convert Base64 to Uint8Array
+   */
+  decodeData(data) {
+    if (typeof data === 'string') {
+      return base64ToUint8Array(data);
+    }
+    if (data instanceof Uint8Array) {
+      return data;
+    }
+    if (data instanceof ArrayBuffer) {
+      return new Uint8Array(data);
+    }
+    return new Uint8Array();
+  }
+
+  /**
+   * Override merge method to merge all Uint8Array chunks
+   */
+  mergeChunks() {
+    var chunks = this.chunks;
+    if (chunks.length === 0) {
+      return new Uint8Array();
+    }
+    if (chunks.length === 1) {
+      return chunks[0];
+    }
+
+    // Calculate total length
+    var totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    var result = new Uint8Array(totalLength);
+
+    // Merge all chunks
+    var offset = 0;
+    var _iterator = _createForOfIteratorHelper(chunks),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var chunk = _step.value;
+        result.set(chunk, offset);
+        offset += chunk.length;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return result;
+  }
+
+  /**
+   * Read as Blob
+   */
+  readAsBlob() {
+    var _this = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
+      var data, buffer;
+      return _regenerator.default.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 1;
+            return _this.read();
+          case 1:
+            data = _context.sent;
+            // Use slice to create a pure ArrayBuffer copy to avoid type issues
+            buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+            return _context.abrupt("return", new Blob([buffer], {
+              type: _this.mimeType || 'application/octet-stream'
+            }));
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))();
+  }
+
+  /**
+   * Read as ArrayBuffer
+   */
+  readAsArrayBuffer() {
+    var _this2 = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      var data, buffer;
+      return _regenerator.default.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 1;
+            return _this2.read();
+          case 1:
+            data = _context2.sent;
+            // Create a new ArrayBuffer copy
+            buffer = new ArrayBuffer(data.byteLength);
+            new Uint8Array(buffer).set(data);
+            return _context2.abrupt("return", buffer);
+          case 2:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }))();
+  }
+
+  /**
+   * Read as Data URL
+   */
+  readAsDataURL() {
+    var _this3 = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
+      var data, base64;
+      return _regenerator.default.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 1;
+            return _this3.read();
+          case 1:
+            data = _context3.sent;
+            base64 = uint8ArrayToBase64(data);
+            return _context3.abrupt("return", `data:${_this3.mimeType || 'application/octet-stream'};base64,${base64}`);
+          case 2:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }))();
+  }
+}
+exports.IframeFileReadableStream = IframeFileReadableStream;

package/library/stream/index.d.ts

@@ -0,0 +1,15 @@
+export * from './types';
+export { IframeWritableStream } from './writable-stream';
+export { IframeFileWritableStream } from './file-stream';
+export { IframeReadableStream, StreamMessageHandler } from './readable-stream';
+export { IframeFileReadableStream } from './file-stream';
+import { IIframeReadableStream, IIframeFileReadableStream } from './types';
+/**
+ * Check if value is an IframeReadableStream
+ */
+export declare function isIframeReadableStream(value: any): value is IIframeReadableStream;
+/**
+ * Check if value is an IframeFileReadableStream (file stream)
+ */
+export declare function isIframeFileStream(value: any): value is IIframeFileReadableStream;
+//# sourceMappingURL=index.d.ts.map

package/library/stream/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/stream/index.ts"],"names":[],"mappings":"AACA,cAAc,SAAS,CAAC;AAGxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAGzD,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAKzD,OAAO,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAE3E;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,qBAAqB,CAEjF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,yBAAyB,CAEjF"}

package/library/stream/index.js

@@ -0,0 +1,83 @@
+"use strict";
+
+require("core-js/modules/web.dom-collections.for-each.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  isIframeReadableStream: true,
+  isIframeFileStream: true,
+  IframeWritableStream: true,
+  IframeFileWritableStream: true,
+  IframeFileReadableStream: true,
+  IframeReadableStream: true,
+  StreamMessageHandler: true
+};
+Object.defineProperty(exports, "IframeFileReadableStream", {
+  enumerable: true,
+  get: function get() {
+    return _fileStream.IframeFileReadableStream;
+  }
+});
+Object.defineProperty(exports, "IframeFileWritableStream", {
+  enumerable: true,
+  get: function get() {
+    return _fileStream.IframeFileWritableStream;
+  }
+});
+Object.defineProperty(exports, "IframeReadableStream", {
+  enumerable: true,
+  get: function get() {
+    return _readableStream.IframeReadableStream;
+  }
+});
+Object.defineProperty(exports, "IframeWritableStream", {
+  enumerable: true,
+  get: function get() {
+    return _writableStream.IframeWritableStream;
+  }
+});
+Object.defineProperty(exports, "StreamMessageHandler", {
+  enumerable: true,
+  get: function get() {
+    return _readableStream.StreamMessageHandler;
+  }
+});
+exports.isIframeFileStream = isIframeFileStream;
+exports.isIframeReadableStream = isIframeReadableStream;
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _types[key];
+    }
+  });
+});
+var _writableStream = require("./writable-stream");
+var _fileStream = require("./file-stream");
+var _readableStream = require("./readable-stream");
+// Type exports
+
+// Writable stream (server-side)
+
+// Readable stream (client-side)
+
+// Type checking utility functions
+
+/**
+ * Check if value is an IframeReadableStream
+ */
+function isIframeReadableStream(value) {
+  return value instanceof _readableStream.IframeReadableStream;
+}
+
+/**
+ * Check if value is an IframeFileReadableStream (file stream)
+ */
+function isIframeFileStream(value) {
+  return value instanceof _fileStream.IframeFileReadableStream;
+}