Function installReadableStreamObserverHooks

inject.js:501–665

()

  }

  function installReadableStreamObserverHooks() {
    const proto = window.ReadableStream?.prototype;
    if (!proto || proto.__STREAM_PANEL_OBSERVER_HOOKED__) return;

    const originalGetReader = proto.getReader;
    const originalPipeThrough = proto.pipeThrough;
    const originalPipeTo = proto.pipeTo;
    const originalTee = proto.tee;
    const originalValues = proto.values;
    const originalAsyncIterator = typeof Symbol !== 'undefined' && Symbol.asyncIterator
      ? proto[Symbol.asyncIterator]
      : null;

    Object.defineProperty(proto, '__STREAM_PANEL_OBSERVER_HOOKED__', {
      value: true,
      configurable: false
    });

    if (typeof originalGetReader === 'function') {
      proto.getReader = function(...readerArgs) {
        const reader = originalGetReader.apply(this, readerArgs);
        const observer = streamObserverMap.get(this);
        if (!observer || streamsCreatingAsyncIterator.has(this) || wrappedStreamReaders.has(reader)) {
          return reader;
        }

        wrappedStreamReaders.add(reader);
        const stream = this;
        const originalRead = reader.read.bind(reader);
        const originalCancel = reader.cancel?.bind(reader);

        reader.read = async function(...readArgs) {
          try {
            const result = await originalRead(...readArgs);
            if (result.done) {
              observer.closeConnection(stream);
            } else {
              observer.processChunk(result.value, stream);
            }
            return result;
          } catch (error) {
            observer.reportError(error);
            throw error;
          }
        };

        if (originalCancel) {
          reader.cancel = function(...cancelArgs) {
            observer.closeConnection(stream);
            return originalCancel(...cancelArgs);
          };
        }

        return reader;
      };
    }

    const wrapAsyncIterator = (stream, iterator, observer) => {