Convert src/core/decode_stream.js to use standard classes

src/core/decode_stream.js

@@ -16,16 +16,15 @@
 import { Stream } from "./stream.js";
 import { unreachable } from "../shared/util.js";
 
-// super class for the decoding streams
-const DecodeStream = (function DecodeStreamClosure() {
 // Lots of DecodeStreams are created whose buffers are never used.  For these
 // we share a single empty buffer. This is (a) space-efficient and (b) avoids
 // having special cases that would be required if we used |null| for an empty
 // buffer.
 const emptyBuffer = new Uint8Array(0);
 
-  // eslint-disable-next-line no-shadow
+// Super class for the decoding streams.
-  function DecodeStream(maybeMinBufferLength) {
+class DecodeStream {
+  constructor(maybeMinBufferLength) {
     this._rawMinBufferLength = maybeMinBufferLength || 0;
 
     this.pos = 0;
@@ -41,19 +40,19 @@ const DecodeStream = (function DecodeStreamClosure() {
     }
   }
 
-  DecodeStream.prototype = {
   // eslint-disable-next-line getter-return
   get length() {
     unreachable("Should not access DecodeStream.length");
-    },
+  }
 
   get isEmpty() {
     while (!this.eof && this.bufferLength === 0) {
       this.readBlock();
     }
     return this.bufferLength === 0;
-    },
+  }
-    ensureBuffer: function DecodeStream_ensureBuffer(requested) {
+
+  ensureBuffer(requested) {
     const buffer = this.buffer;
     if (requested <= buffer.byteLength) {
       return buffer;
@@ -65,8 +64,9 @@ const DecodeStream = (function DecodeStreamClosure() {
     const buffer2 = new Uint8Array(size);
     buffer2.set(buffer);
     return (this.buffer = buffer2);
-    },
+  }
-    getByte: function DecodeStream_getByte() {
+
+  getByte() {
     const pos = this.pos;
     while (this.bufferLength <= pos) {
       if (this.eof) {
@@ -75,22 +75,25 @@ const DecodeStream = (function DecodeStreamClosure() {
       this.readBlock();
     }
     return this.buffer[this.pos++];
-    },
+  }
-    getUint16: function DecodeStream_getUint16() {
+
+  getUint16() {
     const b0 = this.getByte();
     const b1 = this.getByte();
     if (b0 === -1 || b1 === -1) {
       return -1;
     }
     return (b0 << 8) + b1;
-    },
+  }
-    getInt32: function DecodeStream_getInt32() {
+
+  getInt32() {
     const b0 = this.getByte();
     const b1 = this.getByte();
     const b2 = this.getByte();
     const b3 = this.getByte();
     return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
-    },
+  }
+
   getBytes(length, forceClamped = false) {
     const pos = this.pos;
     let end;
@@ -119,20 +122,23 @@ const DecodeStream = (function DecodeStreamClosure() {
     return forceClamped && !(subarray instanceof Uint8ClampedArray)
       ? new Uint8ClampedArray(subarray)
       : subarray;
-    },
+  }
-    peekByte: function DecodeStream_peekByte() {
+
+  peekByte() {
     const peekedByte = this.getByte();
     if (peekedByte !== -1) {
       this.pos--;
     }
     return peekedByte;
-    },
+  }
+
   peekBytes(length, forceClamped = false) {
     const bytes = this.getBytes(length, forceClamped);
     this.pos -= bytes.length;
     return bytes;
-    },
+  }
-    makeSubStream: function DecodeStream_makeSubStream(start, length, dict) {
+
+  makeSubStream(start, length, dict = null) {
     if (length === undefined) {
       while (!this.eof) {
         this.readBlock();
@@ -144,52 +150,46 @@ const DecodeStream = (function DecodeStreamClosure() {
       }
     }
     return new Stream(this.buffer, start, length, dict);
-    },
+  }
 
   getByteRange(begin, end) {
     unreachable("Should not call DecodeStream.getByteRange");
-    },
+  }
 
-    skip: function DecodeStream_skip(n) {
+  skip(n) {
     if (!n) {
       n = 1;
     }
     this.pos += n;
-    },
+  }
-    reset: function DecodeStream_reset() {
+
+  reset() {
     this.pos = 0;
-    },
+  }
-    getBaseStreams: function DecodeStream_getBaseStreams() {
+
+  getBaseStreams() {
     if (this.str && this.str.getBaseStreams) {
       return this.str.getBaseStreams();
     }
     return [];
-    },
+  }
-  };
+}
-
-  return DecodeStream;
-})();
-
-const StreamsSequenceStream = (function StreamsSequenceStreamClosure() {
-  // eslint-disable-next-line no-shadow
-  function StreamsSequenceStream(streams) {
-    this.streams = streams;
 
+class StreamsSequenceStream extends DecodeStream {
+  constructor(streams) {
     let maybeLength = 0;
-    for (let i = 0, ii = streams.length; i < ii; i++) {
+    for (const stream of streams) {
-      const stream = streams[i];
+      maybeLength +=
-      if (stream instanceof DecodeStream) {
+        stream instanceof DecodeStream
-        maybeLength += stream._rawMinBufferLength;
+          ? stream._rawMinBufferLength
-      } else {
+          : stream.length;
-        maybeLength += stream.length;
     }
-    }
+    super(maybeLength);
-    DecodeStream.call(this, maybeLength);
+
+    this.streams = streams;
   }
 
-  StreamsSequenceStream.prototype = Object.create(DecodeStream.prototype);
+  readBlock() {
-
-  StreamsSequenceStream.prototype.readBlock = function streamSequenceStreamReadBlock() {
     const streams = this.streams;
     if (streams.length === 0) {
       this.eof = true;
@@ -202,20 +202,17 @@ const StreamsSequenceStream = (function StreamsSequenceStreamClosure() {
     const buffer = this.ensureBuffer(newLength);
     buffer.set(chunk, bufferLength);
     this.bufferLength = newLength;
-  };
+  }
 
-  StreamsSequenceStream.prototype.getBaseStreams = function StreamsSequenceStream_getBaseStreams() {
+  getBaseStreams() {
     const baseStreams = [];
-    for (let i = 0, ii = this.streams.length; i < ii; i++) {
+    for (const stream of this.streams) {
-      const stream = this.streams[i];
       if (stream.getBaseStreams) {
         baseStreams.push(...stream.getBaseStreams());
       }
     }
     return baseStreams;
-  };
+  }
-
+}
-  return StreamsSequenceStream;
-})();
 
 export { DecodeStream, StreamsSequenceStream };