@spacecorexdev/core 0.0.2 → 0.0.4

package/public/polyfills/polyfills.js

@@ -0,0 +1,802 @@
+/* =========================================================
+ * Safari / 旧 WebView 运行时能力兜底
+ * 目标执行上下文：主窗口(window) / Web Worker(self) / Service Worker(self)
+ * 用法：
+ *   1) 主窗口 <script src="/polyfills/polyfills.js"></script>（放在最前）
+ *   2) Worker: self.importScripts('/polyfills/polyfills.js');（放在业务脚本最前）
+ * 不引入第三方库，完全手工最小实现；只在缺失时赋值，避免与 React dispatcher 冲突。
+ * ========================================================= */
+(function installPolyfills(global) {
+  if (!global) return;
+
+  /* -------------------------------------------------------
+   * 辅助：仅在缺失时挂载
+   * ----------------------------------------------------- */
+  function setIfMissing(target, key, value) {
+    try {
+      if (typeof target[key] === 'undefined') {
+        // 优先 defineProperty：可写/可配置但不参与枚举，与原生一致
+        Object.defineProperty(target, key, {
+          configurable: true,
+          enumerable: false,
+          writable: true,
+          value: value,
+        });
+        // 部分老 Safari 对内置构造器/全局 defineProperty 不抛错但不生效（静默失败），
+        // 因此赋值后立即比对，必要时退化为直接赋值兜底。
+        if (target[key] !== value) {
+          try { target[key] = value; } catch (_e2) { /* skip */ }
+        }
+        return;
+      }
+    } catch (_err) {
+      // 严格冻结对象：尝试直接赋值兜底；再失败则静默忽略
+      try { target[key] = value; return; } catch (_e) { /* skip */ }
+    }
+    // 最后一道：再次验证 defineProperty 未报错但实际未写入的场景
+    try {
+      if (typeof target[key] === 'undefined' && target[key] !== value) target[key] = value;
+    } catch (_e) { /* skip */ }
+  }
+
+  /* =======================================================
+   * 1) Promise.allSettled
+   * ===================================================== */
+  (function polyfillPromiseAllSettled() {
+    var PromiseCtor = global.Promise;
+    if (!PromiseCtor) return;
+    if (typeof PromiseCtor.allSettled === 'function') return;
+
+    var allSettledImpl = function allSettled(values) {
+      var items = Array.isArray(values) ? values : (values && typeof values[Symbol.iterator] === 'function' ? Array.from(values) : []);
+      if (items.length === 0) return PromiseCtor.resolve([]);
+      return new PromiseCtor(function (resolve) {
+        var total = items.length;
+        var remaining = total;
+        var results = new Array(total);
+        function settleOne(index, status, payload) {
+          if (status === 'fulfilled') {
+            results[index] = { status: 'fulfilled', value: payload };
+          } else {
+            results[index] = { status: 'rejected', reason: payload };
+          }
+          remaining -= 1;
+          if (remaining === 0) resolve(results);
+        }
+        for (var i = 0; i < total; i++) {
+          (function (idx) {
+            try {
+              var item = items[idx];
+              PromiseCtor.resolve(item).then(
+                function (v) { settleOne(idx, 'fulfilled', v); },
+                function (r) { settleOne(idx, 'rejected', r); }
+              );
+            } catch (err) {
+              settleOne(idx, 'rejected', err);
+            }
+          })(i);
+        }
+      });
+    };
+
+    setIfMissing(PromiseCtor, 'allSettled', allSettledImpl);
+  })();
+
+  /* =======================================================
+   * 2) QueuingStrategy
+   * ===================================================== */
+  var ByteLengthQS = (function () {
+    function ByteLengthQueuingStrategy(opts) {
+      this.highWaterMark = opts && opts.highWaterMark != null ? opts.highWaterMark : 0;
+    }
+    ByteLengthQueuingStrategy.prototype.size = function (chunk) {
+      return chunk && typeof chunk.byteLength === 'number' ? chunk.byteLength : 0;
+    };
+    return ByteLengthQueuingStrategy;
+  })();
+
+  var CountQS = (function () {
+    function CountQueuingStrategy(opts) {
+      this.highWaterMark = opts && opts.highWaterMark != null ? opts.highWaterMark : 0;
+    }
+    CountQueuingStrategy.prototype.size = function () { return 1; };
+    return CountQueuingStrategy;
+  })();
+
+  setIfMissing(global, 'ByteLengthQueuingStrategy', ByteLengthQS);
+  setIfMissing(global, 'CountQueuingStrategy', CountQS);
+
+  /* =======================================================
+   * 3) ReadableStream (+ Default/BYOB Reader + Default/BYOB Controller)
+   * ===================================================== */
+  var PolyfillReadable = (function () {
+
+    function installOnReadableStreamInstance(stream) {
+      stream._chunks = [];
+      stream._waiting = null;
+      stream._byobWaiting = null;
+      stream._reader = null;
+      stream._byobReader = null;
+      stream._state = { closed: false, errored: false, error: undefined };
+      stream._pulling = false;
+      stream._pullScheduled = false;
+    }
+
+    function toUint8(chunk) {
+      if (chunk instanceof Uint8Array) return chunk;
+      if (chunk && typeof chunk === 'object' && typeof chunk.buffer === 'object' && typeof chunk.byteOffset === 'number' && typeof chunk.byteLength === 'number') {
+        return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+      }
+      if (chunk instanceof ArrayBuffer) return new Uint8Array(chunk);
+      if (typeof chunk === 'string') {
+        var enc = new TextEncoder();
+        return enc.encode(chunk);
+      }
+      if (Array.isArray(chunk)) return new Uint8Array(chunk);
+      return new Uint8Array(0);
+    }
+
+    function DefaultController(stream) { this._s = stream; }
+    DefaultController.prototype.enqueue = function (chunk) { this._s._push(chunk); };
+    DefaultController.prototype.close = function () { this._s._close(); };
+    DefaultController.prototype.error = function (e) { this._s._error(e != null ? e : new Error('ReadableStream errored')); };
+    Object.defineProperty(DefaultController.prototype, 'desiredSize', {
+      configurable: true, get: function () { return this._s._chunks ? 1 : 0; }
+    });
+    Object.defineProperty(DefaultController.prototype, 'byobRequest', {
+      configurable: true, get: function () { return null; }
+    });
+
+    function ByteController(stream) { this._s = stream; }
+    ByteController.prototype.enqueue = function (chunk) {
+      var u8 = toUint8(chunk);
+      this._s._push(u8);
+    };
+    ByteController.prototype.close = function () { this._s._close(); };
+    ByteController.prototype.error = function (e) { this._s._error(e != null ? e : new Error('ReadableByteStream errored')); };
+    Object.defineProperty(ByteController.prototype, 'desiredSize', {
+      configurable: true, get: function () { return this._s._chunks ? 1 : 0; }
+    });
+    Object.defineProperty(ByteController.prototype, 'byobRequest', {
+      configurable: true, get: function () { return null; }
+    });
+
+    function DefaultReader(stream) {
+      var self = this;
+      this._s = stream;
+      stream._reader = this;
+      this.closed = new Promise(function (res) { self._res = res; });
+    }
+    DefaultReader.prototype.read = function () { return this._s._read(); };
+    DefaultReader.prototype.releaseLock = function () {
+      if (this._s._reader === this) this._s._reader = null;
+    };
+    DefaultReader.prototype.cancel = function (reason) { return this._s.cancel(reason); };
+
+    function BYOBReader(stream) {
+      var self = this;
+      this._s = stream;
+      stream._byobReader = this;
+      this.closed = new Promise(function (res) { self._res = res; });
+    }
+    BYOBReader.prototype.read = function (view) { return this._s._readInto(view); };
+    BYOBReader.prototype.releaseLock = function () {
+      if (this._s._byobReader === this) this._s._byobReader = null;
+    };
+    BYOBReader.prototype.cancel = function (reason) { return this._s.cancel(reason); };
+
+    function ReadableStream(underlyingSource, _strategy) {
+      var self = this;
+      installOnReadableStreamInstance(self);
+      self.locked = false;
+      var src = underlyingSource || null;
+      self._source = src;
+      self._cancelCallback = src && typeof src.cancel === 'function' ? src.cancel : null;
+      if (src && src.type === 'bytes') {
+        self._type = 'bytes';
+        self._autoAllocateChunkSize = src.autoAllocateChunkSize;
+        self._controller = new ByteController(self);
+      } else {
+        self._type = undefined;
+        self._controller = new DefaultController(self);
+      }
+      var start = src && typeof src.start === 'function' ? src.start : null;
+      if (start) {
+        Promise.resolve(start.call(src, self._controller))['catch'](function (e) { self._error(e); });
+      }
+    }
+
+    ReadableStream.prototype.getReader = function (opts) {
+      if (opts && opts.mode === 'byob') {
+        if (this._byobReader) throw new TypeError('ReadableStream is locked');
+        return new BYOBReader(this);
+      }
+      if (this._reader) throw new TypeError('ReadableStream is locked');
+      return new DefaultReader(this);
+    };
+
+    ReadableStream.prototype._schedulePullIfNeeded = function () {
+      var self = this;
+      if (self._pullScheduled) return;
+      var src = self._source;
+      var pull = src && typeof src.pull === 'function' ? src.pull : null;
+      if (!pull) return;
+      if (self._state.closed || self._state.errored) return;
+      if (self._chunks.length > 0 || self._waiting || self._byobWaiting) return;
+      self._pullScheduled = true;
+      var fn = (typeof queueMicrotask === 'function') ? queueMicrotask : function (cb) { Promise.resolve().then(cb); };
+      fn(function () {
+        self._pullScheduled = false;
+        if (self._pulling) return;
+        if (self._state.closed || self._state.errored) return;
+        self._pulling = true;
+        Promise.resolve(pull.call(self._source, self._controller))
+          ['catch'](function (e) { self._error(e); })
+          .then(function () { self._pulling = false; }, function () { self._pulling = false; });
+      });
+    };
+
+    ReadableStream.prototype._push = function (chunk) {
+      if (this._state.closed || this._state.errored) return;
+      if (this._waiting) {
+        var resolve = this._waiting; this._waiting = null;
+        resolve({ done: false, value: chunk });
+        this._schedulePullIfNeeded();
+        return;
+      }
+      if (this._byobWaiting) {
+        var resolveByob = this._byobWaiting; this._byobWaiting = null;
+        var src = toUint8(chunk);
+        var out = new Uint8Array(src.length); out.set(src);
+        resolveByob({ done: false, value: out });
+        this._schedulePullIfNeeded();
+        return;
+      }
+      this._chunks.push({ type: 'chunk', value: chunk });
+      this._schedulePullIfNeeded();
+    };
+
+    ReadableStream.prototype._close = function () {
+      if (this._state.closed || this._state.errored) return;
+      this._state.closed = true;
+      this._chunks.push({ type: 'close' });
+      if (this._waiting) {
+        var resolve = this._waiting; this._waiting = null;
+        resolve({ done: true, value: undefined });
+      }
+      this._finalize();
+    };
+
+    ReadableStream.prototype._error = function (error) {
+      if (this._state.closed || this._state.errored) return;
+      this._state.errored = true;
+      this._state.error = error;
+      this._chunks.push({ type: 'error', error: error });
+      if (this._waiting) {
+        var resolve = this._waiting; this._waiting = null;
+        resolve(Promise.reject(error));
+      }
+      this._finalize();
+    };
+
+    ReadableStream.prototype._finalize = function () {
+      if (this._reader && this._reader._res) this._reader._res(undefined);
+      if (this._byobReader && this._byobReader._res) this._byobReader._res(undefined);
+    };
+
+    ReadableStream.prototype._read = function () {
+      var self = this;
+      if (self._state.errored) return Promise.reject(self._state.error);
+      if (self._state.closed) return Promise.resolve({ done: true, value: undefined });
+      while (self._chunks.length) {
+        var item = self._chunks.shift();
+        if (item.type === 'chunk') {
+          self._schedulePullIfNeeded();
+          return Promise.resolve({ done: false, value: item.value });
+        }
+        if (item.type === 'close') return Promise.resolve({ done: true, value: undefined });
+        if (item.type === 'error') return Promise.reject(item.error);
+      }
+      return new Promise(function (resolve, reject) {
+        self._waiting = function (valOrPromise) {
+          if (valOrPromise && typeof valOrPromise.then === 'function') {
+            valOrPromise.then(function (v) { return resolve(v); }, function (e) { return reject(e); });
+            return;
+          }
+          if (self._state.errored) reject(self._state.error);
+          else resolve(valOrPromise);
+        };
+        self._schedulePullIfNeeded();
+      });
+    };
+
+    ReadableStream.prototype._readInto = function (view) {
+      var self = this;
+      if (self._state.errored) return Promise.reject(self._state.error);
+      if (self._state.closed) return Promise.resolve({ done: true, value: view });
+      var written = 0;
+      var target = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+      while (self._chunks.length && written < target.byteLength) {
+        var item = self._chunks[0];
+        if (item.type === 'chunk') {
+          var src = toUint8(item.value);
+          var toCopy = Math.min(src.length, target.byteLength - written);
+          target.set(src.subarray(0, toCopy), written);
+          written += toCopy;
+          if (toCopy < src.length) item.value = src.subarray(toCopy);
+          else self._chunks.shift();
+        } else if (item.type === 'close') {
+          self._chunks.shift();
+          var out = written === 0 ? view : new DataView(view.buffer, view.byteOffset, written);
+          return Promise.resolve({ done: true, value: written ? out : view });
+        } else if (item.type === 'error') {
+          self._chunks.shift();
+          return Promise.reject(item.error);
+        }
+      }
+      if (written > 0) {
+        var newView = new DataView(view.buffer, view.byteOffset, written);
+        self._schedulePullIfNeeded();
+        return Promise.resolve({ done: false, value: newView });
+      }
+      return new Promise(function (resolve, reject) {
+        self._byobWaiting = function (res) {
+          if (self._state.errored) reject(self._state.error);
+          else resolve(res);
+        };
+        self._schedulePullIfNeeded();
+      });
+    };
+
+    ReadableStream.prototype.cancel = function (reason) {
+      var self = this;
+      if (self._state.closed || self._state.errored) return Promise.resolve();
+      self._state.closed = true;
+      var done = function () { self._finalize(); };
+      if (self._cancelCallback) {
+        try {
+          var r = self._cancelCallback(reason);
+          if (r && typeof r.then === 'function') {
+            return Promise.resolve(r).then(function () { done(); return undefined; }, function () { done(); return undefined; });
+          }
+        } catch (e) { /* continue to finalize */ }
+      }
+      done();
+      return Promise.resolve();
+    };
+
+    ReadableStream.prototype.tee = function () {
+      var left = branch(this);
+      var right = branch(this);
+      return [left, right];
+    };
+
+    function branch(src) {
+      var rs = new ReadableStream({
+        start: function (controller) {
+          var reader = src.getReader();
+          function pump() {
+            return reader.read().then(function (res) {
+              if (res.done) return controller.close();
+              controller.enqueue(res.value);
+              return pump();
+            })['catch'](function (e) {
+              controller.error(e);
+            }).then(function () {
+              try { reader.releaseLock(); } catch (_e) { /* skip */ }
+            }, function () {
+              try { reader.releaseLock(); } catch (_e) { /* skip */ }
+            });
+          }
+          return pump();
+        }
+      });
+      return rs;
+    }
+
+    ReadableStream.prototype.pipeTo = function (dest, options) {
+      var preventClose = !!(options && options.preventClose);
+      var preventAbort = !!(options && options.preventAbort);
+      var preventCancel = !!(options && options.preventCancel);
+      var writer = dest && typeof dest.getWriter === 'function' ? dest.getWriter() : null;
+      var self = this;
+      return new Promise(function (resolve, reject) {
+        var reader = self.getReader();
+        function releaseAll() {
+          try { reader.releaseLock(); } catch (_e) { /* skip */ }
+          if (writer && typeof writer.releaseLock === 'function') {
+            try { writer.releaseLock(); } catch (_e) { /* skip */ }
+          }
+        }
+        function closeDest() {
+          if (preventClose) return resolve();
+          if (writer && typeof writer.close === 'function') {
+            Promise.resolve(writer.close()).then(function () { resolve(); }, function (e) { reject(e); });
+          } else if (dest && typeof dest.close === 'function') {
+            try { dest.close(); } catch (_e) { /* skip */ }
+            resolve();
+          } else {
+            resolve();
+          }
+        }
+        function abortDest(err) {
+          if (preventAbort) return;
+          try {
+            if (writer && typeof writer.abort === 'function') {
+              var pr = writer.abort(err);
+              if (pr && typeof pr.then === 'function') pr.then(null, function () { /* already aborting */ });
+            } else if (dest && typeof dest.abort === 'function') {
+              dest.abort(err);
+            }
+          } catch (_e) { /* skip */ }
+        }
+        function cancelSelf(err) {
+          if (preventCancel) return;
+          try {
+            var pr = self.cancel(err);
+            if (pr && typeof pr.then === 'function') pr.then(null, function () { /* already canceling */ });
+          } catch (_e) { /* skip */ }
+        }
+        function pump() {
+          return reader.read().then(function (res) {
+            if (res.done) {
+              closeDest();
+              return undefined;
+            }
+            var writePromise;
+            if (writer) {
+              if (writer.ready && typeof writer.ready.then === 'function') {
+                writePromise = writer.ready.then(function () { return writer.write(res.value); });
+              } else {
+                writePromise = writer.write(res.value);
+              }
+            } else if (dest && typeof dest.write === 'function') {
+              writePromise = Promise.resolve(dest.write(res.value));
+            } else {
+              writePromise = Promise.resolve();
+            }
+            return Promise.resolve(writePromise).then(pump, function (writeErr) {
+              abortDest(writeErr); cancelSelf(writeErr);
+              throw writeErr;
+            });
+          })['catch'](function (err) {
+            releaseAll();
+            abortDest(err); cancelSelf(err);
+            reject(err);
+          });
+        }
+        Promise.resolve()
+          .then(pump)
+          .then(function () { releaseAll(); }, function () { releaseAll(); });
+      });
+    };
+
+    ReadableStream.prototype.pipeThrough = function (transform, options) {
+      this.pipeTo(transform.writable, options);
+      return transform.readable;
+    };
+
+    return {
+      ReadableStream: ReadableStream,
+      DefaultController: DefaultController,
+      ByteController: ByteController,
+      DefaultReader: DefaultReader,
+      BYOBReader: BYOBReader,
+    };
+  })();
+
+  setIfMissing(global, 'ReadableStream', PolyfillReadable.ReadableStream);
+  setIfMissing(global, 'ReadableByteStreamController', PolyfillReadable.ByteController);
+  setIfMissing(global, 'ReadableStreamDefaultController', PolyfillReadable.DefaultController);
+  setIfMissing(global, 'ReadableStreamDefaultReader', PolyfillReadable.DefaultReader);
+  setIfMissing(global, 'ReadableStreamBYOBReader', PolyfillReadable.BYOBReader);
+
+  /* =======================================================
+   * 4) WritableStream + DefaultWriter
+   * ===================================================== */
+  var PolyfillWritable = (function () {
+    function DefaultWriter(stream) {
+      var self = this;
+      this._stream = stream;
+      stream._writer = this;
+      this.closed = new Promise(function (res) { self._resClosed = res; });
+      this.ready = Promise.resolve(undefined);
+      this.desiredSize = 1;
+    }
+    DefaultWriter.prototype.abort = function (reason) { return this._stream.abort(reason); };
+    DefaultWriter.prototype.close = function () { return this._stream.close(); };
+    DefaultWriter.prototype.releaseLock = function () {
+      if (this._stream._writer === this) this._stream._writer = null;
+    };
+    DefaultWriter.prototype.write = function (chunk) { return this._stream.write(chunk); };
+
+    function makeController(store) {
+      return {
+        get signal() { return store.signal; },
+        error: function (e) { store.onError(e != null ? e : new Error('WritableStream errored')); }
+      };
+    }
+
+    function WritableStream(sink, _strategy) {
+      var self = this;
+      self._writer = null;
+      self.locked = false;
+      self._state = { closed: false, errored: false, error: undefined };
+      self._sink = sink || {};
+      self._signal = { aborted: false, reason: undefined };
+      var ctrlStore = {
+        signal: self._signal,
+        onError: function (err) { self._error(err); }
+      };
+      self._controller = makeController(ctrlStore);
+      var start = self._sink && typeof self._sink.start === 'function' ? self._sink.start : null;
+      if (start) {
+        Promise.resolve(start.call(self._sink, self._controller))['catch'](function (e) { self._error(e); });
+      }
+    }
+
+    WritableStream.prototype.getWriter = function () {
+      if (this._writer) throw new TypeError('WritableStream is locked');
+      return new DefaultWriter(this);
+    };
+
+    WritableStream.prototype.write = function (chunk) {
+      if (this._state.errored) return Promise.reject(this._state.error);
+      if (this._state.closed) return Promise.reject(new TypeError('WritableStream is closed'));
+      var fn = this._sink && typeof this._sink.write === 'function' ? this._sink.write : null;
+      if (!fn) return Promise.resolve();
+      try {
+        var r = fn.call(this._sink, chunk, this._controller);
+        return Promise.resolve(r);
+      } catch (e) { return Promise.reject(e); }
+    };
+
+    WritableStream.prototype.close = function () {
+      var self = this;
+      if (self._state.closed || self._state.errored) return Promise.resolve();
+      self._state.closed = true;
+      var fn = self._sink && typeof self._sink.close === 'function' ? self._sink.close : null;
+      var after = function () { self._finalize(); };
+      if (!fn) { after(); return Promise.resolve(); }
+      try {
+        var r = fn.call(self._sink);
+        return Promise.resolve(r).then(function () { after(); }, function (e) { after(); return Promise.reject(e); });
+      } catch (e) { after(); return Promise.reject(e); }
+    };
+
+    WritableStream.prototype.abort = function (reason) {
+      var self = this;
+      if (self._state.closed || self._state.errored) return Promise.resolve();
+      self._signal.aborted = true;
+      self._signal.reason = reason;
+      self._state.errored = true;
+      self._state.error = reason;
+      var fn = self._sink && typeof self._sink.abort === 'function' ? self._sink.abort : null;
+      var after = function () { self._finalize(); };
+      if (!fn) { after(); return Promise.resolve(); }
+      try {
+        var r = fn.call(self._sink, reason);
+        return Promise.resolve(r).then(function () { after(); }, function (e) { after(); return Promise.reject(e); });
+      } catch (e) { after(); return Promise.reject(e); }
+    };
+
+    WritableStream.prototype._error = function (err) {
+      if (this._state.closed || this._state.errored) return;
+      this._state.errored = true;
+      this._state.error = err;
+      this._finalize();
+    };
+
+    WritableStream.prototype._finalize = function () {
+      if (this._writer && this._writer._resClosed) this._writer._resClosed(undefined);
+    };
+
+    return { WritableStream: WritableStream, DefaultWriter: DefaultWriter };
+  })();
+
+  setIfMissing(global, 'WritableStream', PolyfillWritable.WritableStream);
+  setIfMissing(global, 'WritableStreamDefaultWriter', PolyfillWritable.DefaultWriter);
+
+  /* =======================================================
+   * 5) TransformStream
+   * ===================================================== */
+  var PolyfillTransform = (function () {
+    function TransformStream(transformer, _writableStrategy, _readableStrategy) {
+      var readableController;
+      var readable = new global.ReadableStream({
+        start: function (controller) {
+          readableController = controller;
+          var startFn = transformer && typeof transformer.start === 'function' ? transformer.start : null;
+          if (startFn) {
+            Promise.resolve(startFn.call(transformer, readableController))['catch'](function (e) {
+              try { readableController.error(e); } catch (_e) { /* skip */ }
+            });
+          }
+        }
+      });
+      var writable = new global.WritableStream({
+        write: function (chunk, controller) {
+          var fn = transformer && typeof transformer.transform === 'function' ? transformer.transform : null;
+          if (fn) {
+            return Promise.resolve(fn.call(transformer, chunk, readableController));
+          }
+          readableController.enqueue(chunk);
+          return Promise.resolve();
+        },
+        close: function () {
+          var flush = transformer && typeof transformer.flush === 'function' ? transformer.flush : null;
+          var p = flush ? Promise.resolve(flush.call(transformer, readableController)) : Promise.resolve();
+          return p.then(function () { try { readableController.close(); } catch (_e) { /* skip */ } });
+        },
+        abort: function (reason) {
+          try { readableController.error(reason); } catch (_e) { /* skip */ }
+          var abortFn = transformer && typeof transformer.abort === 'function' ? transformer.abort : null;
+          return abortFn ? Promise.resolve(abortFn.call(transformer, reason)) : Promise.resolve();
+        }
+      });
+      this.readable = readable;
+      this.writable = writable;
+    }
+    return TransformStream;
+  })();
+
+  setIfMissing(global, 'TransformStream', PolyfillTransform);
+
+  /* =======================================================
+   * 6) TextDecoderStream / TextEncoderStream
+   * ===================================================== */
+  if (typeof global.TextDecoderStream === 'undefined' && typeof global.TextDecoder === 'function') {
+    var TextDecoderStream = (function () {
+      function PolyfillTDS(label, options) {
+        var decoder = new global.TextDecoder(label, options);
+        this.encoding = decoder.encoding;
+        this.fatal = decoder.fatal;
+        this.ignoreBOM = decoder.ignoreBOM;
+        var ts = new PolyfillTransform({
+          transform: function (chunk, controller) {
+            controller.enqueue(decoder.decode(chunk, { stream: true }));
+          },
+          flush: function (controller) {
+            var tail = decoder.decode();
+            if (tail) controller.enqueue(tail);
+          }
+        });
+        this.readable = ts.readable;
+        this.writable = ts.writable;
+      }
+      return PolyfillTDS;
+    })();
+    global.TextDecoderStream = TextDecoderStream;
+  }
+
+  if (typeof global.TextEncoderStream === 'undefined' && typeof global.TextEncoder === 'function') {
+    var TextEncoderStream = (function () {
+      function PolyfillTES() {
+        var encoder = new global.TextEncoder();
+        this.encoding = 'utf-8';
+        var ts = new PolyfillTransform({
+          transform: function (chunk, controller) { controller.enqueue(encoder.encode(chunk)); }
+        });
+        this.readable = ts.readable;
+        this.writable = ts.writable;
+      }
+      return PolyfillTES;
+    })();
+    global.TextEncoderStream = TextEncoderStream;
+  }
+
+  // Safari 半残实现的第二道防线（所有 Polyfill* 都已声明后再执行）：
+  // 老版本 Safari 中，ReadableStream 已作为函数存在，但 BYOB 控制器缺失，
+  // 或 new ReadableStream({type:'bytes'}) 会抛 "ReadableByteStreamController is not implemented"
+  // （React 18 renderToReadableStream → createInternalReadableStreamFromUnderlyingSource 路径）。
+  // 命中任一迹象就强制整体替换，保证 React SSR 路径拿到一致实现。
+  (function detectBrokenStreamsAndOverride() {
+    try {
+      var RS = global.ReadableStream;
+      var RBC = global.ReadableByteStreamController;
+      var WS = global.WritableStream;
+      var TS = global.TransformStream;
+      if (typeof RS !== 'function') return; // 下一节 setIfMissing 或上方安装已覆盖
+
+      var broken = false;
+      if (typeof RBC !== 'function') broken = true;
+
+      if (!broken) {
+        try {
+          var src = {
+            type: 'bytes',
+            start: function (c) { try { c.close(); } catch (_) {} },
+          };
+          var tmp = new RS(src);
+          try {
+            var byob = tmp.getReader({ mode: 'byob' });
+            if (!byob) broken = true;
+            else try { byob.releaseLock(); } catch (_) {}
+          } catch (bErr) {
+            var bMsg = String(bErr && bErr.message || '');
+            if (/not implemented|ReadableByteStreamController|byob|not supported|invalid mode/i.test(bMsg)) broken = true;
+          }
+          try { tmp.cancel && tmp.cancel(); } catch (_) {}
+        } catch (e) {
+          var msg = String(e && e.message || '');
+          if (/ReadableByteStreamController is not implemented|is not implemented|not supported|type bytes|invalid type/i.test(msg)) broken = true;
+        }
+      }
+
+      if (!broken) {
+        var proto = RS.prototype;
+        if (!proto || typeof proto.pipeTo !== 'function' || typeof proto.pipeThrough !== 'function' || typeof proto.tee !== 'function') {
+          if (typeof WS !== 'function') broken = true;
+        }
+      }
+      if (!broken && typeof TS !== 'undefined' && typeof TS !== 'function') broken = true;
+
+      if (!broken) return;
+
+      var PolyRS = PolyfillReadable && PolyfillReadable.ReadableStream;
+      var PolyWS = PolyfillWritable && PolyfillWritable.WritableStream;
+      var PolyTS = PolyfillTransform;
+
+      function forceSet(key, value) {
+        try {
+          Object.defineProperty(global, key, {
+            configurable: true, writable: true, enumerable: false, value: value,
+          });
+        } catch (_) {
+          try { global[key] = value; } catch (__) {}
+        }
+        try { if (global[key] !== value) global[key] = value; } catch (_) {}
+      }
+
+      if (PolyRS) forceSet('ReadableStream', PolyRS);
+      if (PolyfillReadable) {
+        forceSet('ReadableByteStreamController', PolyfillReadable.ByteController);
+        forceSet('ReadableStreamDefaultController', PolyfillReadable.DefaultController);
+        forceSet('ReadableStreamDefaultReader', PolyfillReadable.DefaultReader);
+        forceSet('ReadableStreamBYOBReader', PolyfillReadable.BYOBReader);
+      }
+      if (PolyWS) {
+        forceSet('WritableStream', PolyWS);
+        forceSet('WritableStreamDefaultWriter', PolyfillWritable.DefaultWriter);
+      }
+      if (PolyTS) forceSet('TransformStream', PolyTS);
+    } catch (_e) { /* skip */ }
+  })();
+
+  /* =======================================================
+   * 7) 针对部分原生 ReadableStream 但缺少 pipeTo 的老版本 Safari 原型补齐
+   * ===================================================== */
+  (function patchNativeReadableStreamPrototype() {
+    var RS = global.ReadableStream;
+    if (!RS || typeof RS !== 'function') return;
+    try {
+      var proto = RS.prototype;
+      if (!proto) return;
+      var PolyRS = PolyfillReadable.ReadableStream.prototype;
+      if (typeof proto.pipeTo !== 'function') {
+        Object.defineProperty(proto, 'pipeTo', {
+          configurable: true, writable: true, value: PolyRS.pipeTo,
+        });
+      }
+      if (typeof proto.pipeThrough !== 'function') {
+        Object.defineProperty(proto, 'pipeThrough', {
+          configurable: true, writable: true, value: PolyRS.pipeThrough,
+        });
+      }
+      if (typeof proto.tee !== 'function') {
+        Object.defineProperty(proto, 'tee', {
+          configurable: true, writable: true, value: PolyRS.tee,
+        });
+      }
+    } catch (_err) { /* skip */ }
+  })();
+
+  /* =======================================================
+   * 8) queueMicrotask (少数老 WebView 缺失)
+   * ===================================================== */
+  if (typeof global.queueMicrotask !== 'function') {
+    global.queueMicrotask = function (cb) {
+      Promise.resolve().then(function () { try { cb(); } catch (e) { throw e; } });
+    };
+  }
+})(typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : typeof globalThis !== 'undefined' ? globalThis : this);