text: /**
   * @licstart The following is the entire license notice for the
   * JavaScript code in this page
   *
   * Copyright 2022 Mozilla Foundation
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *
   * @licend The above is the entire license notice for the
   * JavaScript code in this page
   */
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.StreamsSequenceStream = exports.DecodeStream = void 0;
  
  var _base_stream = require("./base_stream.js");
  
  var _stream = require("./stream.js");
  
  const emptyBuffer = new Uint8Array(0);
  
  class DecodeStream extends _base_stream.BaseStream {
    constructor(maybeMinBufferLength) {
      super();
      this._rawMinBufferLength = maybeMinBufferLength || 0;
      this.pos = 0;
      this.bufferLength = 0;
      this.eof = false;
      this.buffer = emptyBuffer;
      this.minBufferLength = 512;
  
      if (maybeMinBufferLength) {
        while (this.minBufferLength < maybeMinBufferLength) {
          this.minBufferLength *= 2;
        }
      }
    }
  
    get isEmpty() {
      while (!this.eof && this.bufferLength === 0) {
        this.readBlock();
      }
  
      return this.bufferLength === 0;
    }
  
    ensureBuffer(requested) {
      const buffer = this.buffer;
  
      if (requested <= buffer.byteLength) {
        return buffer;
      }
  
      let size = this.minBufferLength;
  
      while (size < requested) {
        size *= 2;
      }
  
      const buffer2 = new Uint8Array(size);
      buffer2.set(buffer);
      return this.buffer = buffer2;
    }
  
    getByte() {
      const pos = this.pos;
  
      while (this.bufferLength <= pos) {
        if (this.eof) {
          return -1;
        }
  
        this.readBlock();
      }
  
      return this.buffer[this.pos++];
    }
  
    getBytes(length) {
      const pos = this.pos;
      let end;
  
      if (length) {
        this.ensureBuffer(pos + length);
        end = pos + length;
  
        while (!this.eof && this.bufferLength < end) {
          this.readBlock();
        }
  
        const bufEnd = this.bufferLength;
  
        if (end > bufEnd) {
          end = bufEnd;
        }
      } else {
        while (!this.eof) {
          this.readBlock();
        }
  
        end = this.bufferLength;
      }
  
      this.pos = end;
      return this.buffer.subarray(pos, end);
    }
  
    reset() {
      this.pos = 0;
    }
  
    makeSubStream(start, length, dict = null) {
      if (length === undefined) {
        while (!this.eof) {
          this.readBlock();
        }
      } else {
        const end = start + length;
  
        while (this.bufferLength <= end && !this.eof) {
          this.readBlock();
        }
      }
  
      return new _stream.Stream(this.buffer, start, length, dict);
    }
  
    getBaseStreams() {
      return this.str ? this.str.getBaseStreams() : null;
    }
  
  }
  
  exports.DecodeStream = DecodeStream;
  
  class StreamsSequenceStream extends DecodeStream {
    constructor(streams, onError = null) {
      let maybeLength = 0;
  
      for (const stream of streams) {
        maybeLength += stream instanceof DecodeStream ? stream._rawMinBufferLength : stream.length;
      }
  
      super(maybeLength);
      this.streams = streams;
      this._onError = onError;
    }
  
    readBlock() {
      const streams = this.streams;
  
      if (streams.length === 0) {
        this.eof = true;
        return;
      }
  
      const stream = streams.shift();
      let chunk;
  
      try {
        chunk = stream.getBytes();
      } catch (reason) {
        if (this._onError) {
          this._onError(reason, stream.dict && stream.dict.objId);
  
          return;
        }
  
        throw reason;
      }
  
      const bufferLength = this.bufferLength;
      const newLength = bufferLength + chunk.length;
      const buffer = this.ensureBuffer(newLength);
      buffer.set(chunk, bufferLength);
      this.bufferLength = newLength;
    }
  
    getBaseStreams() {
      const baseStreamsBuf = [];
  
      for (const stream of this.streams) {
        const baseStreams = stream.getBaseStreams();
  
        if (baseStreams) {
          baseStreamsBuf.push(...baseStreams);
        }
      }
  
      return baseStreamsBuf.length > 0 ? baseStreamsBuf : null;
    }
  
  }
  
  exports.StreamsSequenceStream = StreamsSequenceStream;