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

src/core/stream.js

@@ -15,9 +15,8 @@
 
 import { stringToBytes } from "../shared/util.js";
 
-const Stream = (function StreamClosure() {
+class Stream {
-  // eslint-disable-next-line no-shadow
+  constructor(arrayBuffer, start, length, dict) {
-  function Stream(arrayBuffer, start, length, dict) {
     this.bytes =
       arrayBuffer instanceof Uint8Array
         ? arrayBuffer
@@ -28,36 +27,38 @@ const Stream = (function StreamClosure() {
     this.dict = dict;
   }
 
-  // required methods for a stream. if a particular stream does not
-  // implement these, an error should be thrown
-  Stream.prototype = {
   get length() {
     return this.end - this.start;
-    },
+  }
+
   get isEmpty() {
     return this.length === 0;
-    },
+  }
-    getByte: function Stream_getByte() {
+
+  getByte() {
     if (this.pos >= this.end) {
       return -1;
     }
     return this.bytes[this.pos++];
-    },
+  }
-    getUint16: function Stream_getUint16() {
+
+  getUint16() {
     const b0 = this.getByte();
     const b1 = this.getByte();
     if (b0 === -1 || b1 === -1) {
       return -1;
     }
     return (b0 << 8) + b1;
-    },
+  }
-    getInt32: function Stream_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;
-    },
+  }
+
   // Returns subarray of original buffer, should only be read.
   getBytes(length, forceClamped = false) {
     const bytes = this.bytes;
@@ -77,19 +78,21 @@ const Stream = (function StreamClosure() {
     const subarray = bytes.subarray(pos, end);
     // `this.bytes` is always a `Uint8Array` here.
     return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
-    },
+  }
-    peekByte: function Stream_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;
-    },
+  }
 
   getByteRange(begin, end) {
     if (begin < 0) {
@@ -99,49 +102,38 @@ const Stream = (function StreamClosure() {
       end = this.end;
     }
     return this.bytes.subarray(begin, end);
-    },
+  }
 
-    skip: function Stream_skip(n) {
+  skip(n) {
     if (!n) {
       n = 1;
     }
     this.pos += n;
-    },
+  }
-    reset: function Stream_reset() {
+
+  reset() {
     this.pos = this.start;
-    },
+  }
-    moveStart: function Stream_moveStart() {
+
+  moveStart() {
     this.start = this.pos;
-    },
+  }
-    makeSubStream: function Stream_makeSubStream(start, length, dict) {
+
+  makeSubStream(start, length, dict = null) {
     return new Stream(this.bytes.buffer, start, length, dict);
-    },
+  }
-  };
-
-  return Stream;
-})();
-
-const StringStream = (function StringStreamClosure() {
-  // eslint-disable-next-line no-shadow
-  function StringStream(str) {
-    const bytes = stringToBytes(str);
-    Stream.call(this, bytes);
 }
 
-  StringStream.prototype = Stream.prototype;
+class StringStream extends Stream {
-
+  constructor(str) {
-  return StringStream;
+    super(stringToBytes(str));
-})();
+  }
-
-const NullStream = (function NullStreamClosure() {
-  // eslint-disable-next-line no-shadow
-  function NullStream() {
-    Stream.call(this, new Uint8Array(0));
 }
 
-  NullStream.prototype = Stream.prototype;
+class NullStream extends Stream {
-
+  constructor() {
-  return NullStream;
+    super(new Uint8Array(0));
-})();
+  }
+}
 
 export { NullStream, Stream, StringStream };