dcmjs 0.43.0 → 0.44.0

package/build/dcmjs.es.js

@@ -7614,6 +7614,331 @@ var pako = {
 	constants: constants_1
 };
 
+/**
+ * This is a data view which is split across multiple pieces, and maintains
+ * a running size, with nullable chunks.
+ */
+var SplitDataView = /*#__PURE__*/function () {
+  function SplitDataView() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+      defaultSize: 256 * 1024
+    };
+    _classCallCheck(this, SplitDataView);
+    _defineProperty(this, "buffers", []);
+    _defineProperty(this, "views", []);
+    _defineProperty(this, "offsets", []);
+    _defineProperty(this, "size", 0);
+    _defineProperty(this, "byteLength", 0);
+    /** The default size is 256k */
+    _defineProperty(this, "defaultSize", 256 * 1024);
+    this.defaultSize = options.defaultSize || this.defaultSize;
+  }
+  _createClass(SplitDataView, [{
+    key: "checkSize",
+    value: function checkSize(end) {
+      while (end > this.byteLength) {
+        var buffer = new ArrayBuffer(this.defaultSize);
+        this.buffers.push(buffer);
+        this.views.push(new DataView(buffer));
+        this.offsets.push(this.byteLength);
+        this.byteLength += buffer.byteLength;
+      }
+    }
+
+    /**
+     * Adds the buffer to the end of the current buffers list,
+     * updating the size etc.
+     *
+     * @param {*} buffer
+     * @param {*} options.start for the start of the new buffer to use
+     * @param {*} options.end for the end of the buffer to use
+     * @param {*} options.transfer to transfer the buffer to be owned
+     */
+  }, {
+    key: "addBuffer",
+    value: function addBuffer(buffer) {
+      var _this$buffers;
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      buffer = buffer.buffer || buffer;
+      var start = (options === null || options === void 0 ? void 0 : options.start) || 0;
+      var end = (options === null || options === void 0 ? void 0 : options.end) || buffer.byteLength;
+      var transfer = options === null || options === void 0 ? void 0 : options.transfer;
+      if (start === end) {
+        return;
+      }
+      var addBuffer = transfer ? buffer : buffer.slice(start, end);
+      var lastOffset = this.offsets.length ? this.offsets[this.offsets.length - 1] : 0;
+      var lastLength = this.buffers.length ? (_this$buffers = this.buffers[this.buffers.length - 1]) === null || _this$buffers === void 0 ? void 0 : _this$buffers.byteLength : 0;
+      this.buffers.push(addBuffer);
+      this.views.push(new DataView(addBuffer));
+      this.offsets.push(lastOffset + lastLength);
+      this.size += addBuffer.byteLength;
+      this.byteLength += addBuffer.byteLength;
+    }
+
+    /** Copies one view contents into this one as a mirror */
+  }, {
+    key: "from",
+    value: function from(view, _options) {
+      var _this$offsets, _this$buffers2, _this$views;
+      this.size = view.size;
+      this.byteLength = view.byteLength;
+      (_this$offsets = this.offsets).push.apply(_this$offsets, _toConsumableArray(view.offsets));
+      (_this$buffers2 = this.buffers).push.apply(_this$buffers2, _toConsumableArray(view.buffers));
+      (_this$views = this.views).push.apply(_this$views, _toConsumableArray(view.views));
+      // TODO - use the options to skip copying irrelevant data
+    }
+  }, {
+    key: "slice",
+    value: function slice() {
+      var start = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      var end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.size;
+      if (start === end) {
+        return new Uint8Array(0).buffer;
+      }
+      var index = this.findStart(start);
+      if (index === undefined) {
+        throw new Error("Start ".concat(start, " out of range of 0...").concat(this.byteLength));
+      }
+      var buffer = this.buffers[index];
+      if (!buffer) {
+        console.error("Buffer should be defined here");
+        return;
+      }
+      var offset = this.offsets[index];
+      var length = buffer.byteLength;
+      if (end < offset + length) {
+        return buffer.slice(start - offset, end - offset);
+      }
+      var createBuffer = new Uint8Array(end - start);
+      var offsetStart = 0;
+      while (start + offsetStart < end && index < this.buffers.length) {
+        buffer = this.buffers[index];
+        length = buffer.byteLength;
+        offset = this.offsets[index];
+        var bufStart = start + offsetStart - offset;
+        var addLength = Math.min(end - start - offsetStart, length - bufStart);
+        createBuffer.set(new Uint8Array(buffer, bufStart, addLength), offsetStart);
+        offsetStart += addLength;
+        index++;
+      }
+      return createBuffer.buffer;
+    }
+  }, {
+    key: "findStart",
+    value: function findStart() {
+      var start = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      for (var index = 0; index < this.buffers.length; index++) {
+        if (start >= this.offsets[index] && start < this.offsets[index] + this.buffers[index].byteLength) {
+          return index;
+        }
+      }
+    }
+  }, {
+    key: "findView",
+    value: function findView(start) {
+      var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var index = this.findStart(start);
+      var buffer = this.buffers[index];
+      var viewOffset = this.offsets[index];
+      var viewLength = buffer.byteLength;
+      if (start + length - viewOffset <= viewLength) {
+        return {
+          view: this.views[index],
+          viewOffset: viewOffset,
+          index: index
+        };
+      }
+      var newBuffer = this.slice(start, start + length);
+      return {
+        view: new DataView(newBuffer),
+        viewOffset: start,
+        writeCommit: true
+      };
+    }
+  }, {
+    key: "writeCommit",
+    value: function writeCommit(view, start) {
+      this.writeBuffer(view.buffer, start);
+    }
+  }, {
+    key: "writeBuffer",
+    value: function writeBuffer(data, start) {
+      var index = this.findStart(start);
+      var offset = 0;
+      while (offset < data.byteLength) {
+        var buffer = this.buffers[index];
+        if (!buffer) {
+          throw new Error("Not enough space to write ".concat(data.byteLength));
+        }
+        var bufferOffset = this.offsets[index];
+        var startWrite = start + offset - bufferOffset;
+        var writeLen = Math.min(buffer.byteLength - startWrite, data.byteLength - offset);
+        var byteBuffer = new Uint8Array(buffer, startWrite, writeLen);
+        var setData = new Uint8Array(data.buffer || data, offset, writeLen);
+        byteBuffer.set(setData);
+        offset += writeLen;
+        index++;
+      }
+    }
+  }, {
+    key: "getUint8",
+    value: function getUint8(offset) {
+      var _this$findView = this.findView(offset, 1),
+        view = _this$findView.view,
+        viewOffset = _this$findView.viewOffset;
+      return view.getUint8(offset - viewOffset);
+    }
+  }, {
+    key: "getUint16",
+    value: function getUint16(offset, isLittleEndian) {
+      var _this$findView2 = this.findView(offset, 2),
+        view = _this$findView2.view,
+        viewOffset = _this$findView2.viewOffset;
+      return view.getUint16(offset - viewOffset, isLittleEndian);
+    }
+  }, {
+    key: "getUint32",
+    value: function getUint32(offset, isLittleEndian) {
+      var _this$findView3 = this.findView(offset, 4),
+        view = _this$findView3.view,
+        viewOffset = _this$findView3.viewOffset;
+      return view.getUint32(offset - viewOffset, isLittleEndian);
+    }
+  }, {
+    key: "getFloat32",
+    value: function getFloat32(offset, isLittleEndian) {
+      var _this$findView4 = this.findView(offset, 4),
+        view = _this$findView4.view,
+        viewOffset = _this$findView4.viewOffset;
+      return view.getFloat32(offset - viewOffset, isLittleEndian);
+    }
+  }, {
+    key: "getFloat64",
+    value: function getFloat64(offset, isLittleEndian) {
+      var _this$findView5 = this.findView(offset, 8),
+        view = _this$findView5.view,
+        viewOffset = _this$findView5.viewOffset;
+      return view.getFloat64(offset - viewOffset, isLittleEndian);
+    }
+  }, {
+    key: "getInt8",
+    value: function getInt8(offset) {
+      var _this$findView6 = this.findView(offset, 1),
+        view = _this$findView6.view,
+        viewOffset = _this$findView6.viewOffset;
+      return view.getInt8(offset - viewOffset);
+    }
+  }, {
+    key: "getInt16",
+    value: function getInt16(offset, isLittleEndian) {
+      var _this$findView7 = this.findView(offset, 2),
+        view = _this$findView7.view,
+        viewOffset = _this$findView7.viewOffset;
+      return view.getInt16(offset - viewOffset, isLittleEndian);
+    }
+  }, {
+    key: "getInt32",
+    value: function getInt32(offset, isLittleEndian) {
+      var _this$findView8 = this.findView(offset, 4),
+        view = _this$findView8.view,
+        viewOffset = _this$findView8.viewOffset;
+      return view.getInt32(offset - viewOffset, isLittleEndian);
+    }
+  }, {
+    key: "setUint8",
+    value: function setUint8(offset, value) {
+      var _this$findView9 = this.findView(offset, 1),
+        view = _this$findView9.view,
+        viewOffset = _this$findView9.viewOffset;
+      view.setUint8(offset - viewOffset, value);
+      // Commit is unneeded since 1 byte will always be available
+    }
+  }, {
+    key: "setUint16",
+    value: function setUint16(offset, value, isLittleEndian) {
+      var _this$findView0 = this.findView(offset, 2),
+        view = _this$findView0.view,
+        viewOffset = _this$findView0.viewOffset,
+        writeCommit = _this$findView0.writeCommit;
+      view.setUint16(offset - viewOffset, value, isLittleEndian);
+      if (writeCommit) {
+        this.writeCommit(view, offset);
+      }
+    }
+  }, {
+    key: "setUint32",
+    value: function setUint32(offset, value, isLittleEndian) {
+      var _this$findView1 = this.findView(offset, 4),
+        view = _this$findView1.view,
+        viewOffset = _this$findView1.viewOffset,
+        writeCommit = _this$findView1.writeCommit;
+      view.setUint32(offset - viewOffset, value, isLittleEndian);
+      if (writeCommit) {
+        this.writeCommit(view, offset);
+      }
+    }
+  }, {
+    key: "setFloat32",
+    value: function setFloat32(offset, value, isLittleEndian) {
+      var _this$findView10 = this.findView(offset, 4),
+        view = _this$findView10.view,
+        viewOffset = _this$findView10.viewOffset,
+        writeCommit = _this$findView10.writeCommit;
+      view.setFloat32(offset - viewOffset, value, isLittleEndian);
+      if (writeCommit) {
+        this.writeCommit(view, offset);
+      }
+    }
+  }, {
+    key: "setFloat64",
+    value: function setFloat64(offset, value, isLittleEndian) {
+      var _this$findView11 = this.findView(offset, 8),
+        view = _this$findView11.view,
+        viewOffset = _this$findView11.viewOffset,
+        writeCommit = _this$findView11.writeCommit;
+      view.setFloat64(offset - viewOffset, value, isLittleEndian);
+      if (writeCommit) {
+        this.writeCommit(view, offset);
+      }
+    }
+  }, {
+    key: "setInt8",
+    value: function setInt8(offset, value) {
+      var _this$findView12 = this.findView(offset, 1),
+        view = _this$findView12.view,
+        viewOffset = _this$findView12.viewOffset;
+      view.setInt8(offset - viewOffset, value);
+      // Commit is unneeded since 1 byte will always be available
+    }
+  }, {
+    key: "setInt16",
+    value: function setInt16(offset, value, isLittleEndian) {
+      var _this$findView13 = this.findView(offset, 2),
+        view = _this$findView13.view,
+        viewOffset = _this$findView13.viewOffset,
+        writeCommit = _this$findView13.writeCommit;
+      view.setInt16(offset - viewOffset, value, isLittleEndian);
+      if (writeCommit) {
+        this.writeCommit(view, offset);
+      }
+    }
+  }, {
+    key: "setInt32",
+    value: function setInt32(offset, value, isLittleEndian) {
+      var _this$findView14 = this.findView(offset, 4),
+        view = _this$findView14.view,
+        viewOffset = _this$findView14.viewOffset,
+        writeCommit = _this$findView14.writeCommit;
+      view.setInt32(offset - viewOffset, value, isLittleEndian);
+      if (writeCommit) {
+        this.writeCommit(view, offset);
+      }
+    }
+  }]);
+  return SplitDataView;
+}();
+
 function toInt(val) {
   if (isNaN(val)) {
     throw new Error("Not a number: " + val);
@@ -7627,23 +7952,52 @@ function toFloat(val) {
   } else return val;
 }
 var BufferStream = /*#__PURE__*/function () {
-  function BufferStream(sizeOrBuffer, littleEndian) {
+  function BufferStream() {
+    var _options$defaultSize;
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
     _classCallCheck(this, BufferStream);
-    this.buffer = typeof sizeOrBuffer == "number" ? new ArrayBuffer(sizeOrBuffer) : sizeOrBuffer;
-    if (!this.buffer) {
-      this.buffer = new ArrayBuffer(0);
-    }
-    this.view = new DataView(this.buffer);
-    this.offset = 0;
-    this.isLittleEndian = littleEndian || false;
-    this.size = 0;
-    this.encoder = new TextEncoder("utf-8");
+    _defineProperty(this, "offset", 0);
+    _defineProperty(this, "startOffset", 0);
+    _defineProperty(this, "isLittleEndian", false);
+    _defineProperty(this, "size", 0);
+    _defineProperty(this, "view", new SplitDataView());
+    _defineProperty(this, "encoder", new TextEncoder("utf-8"));
+    this.isLittleEndian = (options === null || options === void 0 ? void 0 : options.littleEndian) || this.isLittleEndian;
+    this.view.defaultSize = (_options$defaultSize = options === null || options === void 0 ? void 0 : options.defaultSize) !== null && _options$defaultSize !== void 0 ? _options$defaultSize : this.view.defaultSize;
   }
   _createClass(BufferStream, [{
     key: "setEndian",
     value: function setEndian(isLittle) {
       this.isLittleEndian = isLittle;
     }
+  }, {
+    key: "slice",
+    value: function slice() {
+      var start = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.startOffset;
+      var end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.endOffset;
+      return this.view.slice(start, end);
+    }
+  }, {
+    key: "getBuffer",
+    value: function getBuffer() {
+      var start = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      var end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.size;
+      if (this.noCopy) {
+        return new Uint8Array(this.slice(start, end));
+      }
+      return this.slice(start, end);
+    }
+  }, {
+    key: "buffer",
+    get: function get() {
+      // console.warn("Deprecated buffer get");
+      return this.getBuffer();
+    }
+  }, {
+    key: "available",
+    get: function get() {
+      return this.endOffset - this.offset;
+    }
   }, {
     key: "writeUint8",
     value: function writeUint8(value) {
@@ -7725,7 +8079,7 @@ var BufferStream = /*#__PURE__*/function () {
     value: function writeUTF8String(value) {
       var encodedString = this.encoder.encode(value);
       this.checkSize(encodedString.byteLength);
-      new Uint8Array(this.buffer).set(encodedString, this.offset);
+      this.view.writeBuffer(encodedString, this.offset);
       return this.increment(encodedString.byteLength);
     }
   }, {
@@ -7736,8 +8090,8 @@ var BufferStream = /*#__PURE__*/function () {
       this.checkSize(len);
       var startOffset = this.offset;
       for (var i = 0; i < len; i++) {
-        var charcode = value.charCodeAt(i);
-        this.view.setUint8(startOffset + i, charcode);
+        var charCode = value.charCodeAt(i);
+        this.view.setUint8(startOffset + i, charCode);
       }
       return this.increment(len);
     }
@@ -7770,7 +8124,7 @@ var BufferStream = /*#__PURE__*/function () {
   }, {
     key: "readUint8Array",
     value: function readUint8Array(length) {
-      var arr = new Uint8Array(this.buffer, this.offset, length);
+      var arr = new Uint8Array(this.view.slice(this.offset, this.offset + length));
       this.increment(length);
       return arr;
     }
@@ -7786,6 +8140,13 @@ var BufferStream = /*#__PURE__*/function () {
       }
       return arr;
     }
+  }, {
+    key: "readInt8",
+    value: function readInt8() {
+      var val = this.view.getInt8(this.offset, this.isLittleEndian);
+      this.increment(1);
+      return val;
+    }
   }, {
     key: "readInt16",
     value: function readInt16() {
@@ -7820,8 +8181,8 @@ var BufferStream = /*#__PURE__*/function () {
       var result = "";
       var start = this.offset;
       var end = this.offset + length;
-      if (end >= this.buffer.byteLength) {
-        end = this.buffer.byteLength;
+      if (end >= this.view.byteLength) {
+        end = this.view.byteLength;
       }
       for (var i = start; i < end; ++i) {
         result += String.fromCharCode(this.view.getUint8(i));
@@ -7839,10 +8200,10 @@ var BufferStream = /*#__PURE__*/function () {
   }, {
     key: "readEncodedString",
     value: function readEncodedString(length) {
-      if (this.offset + length >= this.buffer.byteLength) {
-        length = this.buffer.byteLength - this.offset;
+      if (this.offset + length >= this.view.byteLength) {
+        length = this.view.byteLength - this.offset;
       }
-      var view = new DataView(this.buffer, this.offset, length);
+      var view = new DataView(this.slice(this.offset, this.offset + length));
       var result = this.decoder.decode(view);
       this.increment(length);
       return result;
@@ -7859,45 +8220,21 @@ var BufferStream = /*#__PURE__*/function () {
   }, {
     key: "checkSize",
     value: function checkSize(step) {
-      if (this.offset + step > this.buffer.byteLength) {
-        //throw new Error("Writing exceeded the size of buffer");
-        //
-        // Resize the buffer.
-        // The idea is that when it is necessary to increase the buffer size,
-        // there will likely be more bytes which need to be written to the
-        // buffer in the future. Buffer allocation is costly.
-        // So we increase the buffer size right now
-        // by a larger amount than necessary, to reserve space for later
-        // writes which then can be done much faster. The current size of
-        // the buffer is the best estimate of the scale by which the size
-        // should increase.
-        // So approximately doubling the size of the buffer
-        // (while ensuring it fits the new data) is a simple but effective strategy.
-        var dstSize = this.offset + step + this.buffer.byteLength;
-        var dst = new ArrayBuffer(dstSize);
-        new Uint8Array(dst).set(new Uint8Array(this.buffer));
-        this.buffer = dst;
-        this.view = new DataView(this.buffer);
-      }
+      this.view.checkSize(this.offset + step);
     }
+
+    /**
+     * Concatenates the stream, starting from the startOffset (to allow concat
+     * on an existing output from the beginning)
+     */
   }, {
     key: "concat",
     value: function concat(stream) {
-      var available = this.buffer.byteLength - this.offset;
-      if (stream.size > available) {
-        var newbuf = new ArrayBuffer(this.offset + stream.size);
-        var int8 = new Uint8Array(newbuf);
-        int8.set(new Uint8Array(this.getBuffer(0, this.offset)));
-        int8.set(new Uint8Array(stream.getBuffer(0, stream.size)), this.offset);
-        this.buffer = newbuf;
-        this.view = new DataView(this.buffer);
-      } else {
-        var _int = new Uint8Array(this.buffer);
-        _int.set(new Uint8Array(stream.getBuffer(0, stream.size)), this.offset);
-      }
+      this.view.checkSize(this.size + stream.size - stream.startOffset);
+      this.view.writeBuffer(new Uint8Array(stream.slice(stream.startOffset, stream.size)), this.offset);
       this.offset += stream.size;
       this.size = this.offset;
-      return this.buffer.byteLength;
+      return this.view.availableSize;
     }
   }, {
     key: "increment",
@@ -7908,14 +8245,23 @@ var BufferStream = /*#__PURE__*/function () {
       }
       return step;
     }
+
+    /**
+     * Adds the buffer to the end of the current buffers list,
+     * updating the size etc.
+     *
+     * @param {*} buffer
+     * @param {*} options.start for the start of the new buffer to use
+     * @param {*} options.end for the end of the buffer to use
+     * @param {*} options.transfer to transfer the buffer to be owned
+     */
   }, {
-    key: "getBuffer",
-    value: function getBuffer(start, end) {
-      if (!start && !end) {
-        start = 0;
-        end = this.size;
-      }
-      return this.buffer.slice(start, end);
+    key: "addBuffer",
+    value: function addBuffer(buffer) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      this.view.addBuffer(buffer, options);
+      this.size = this.view.size;
+      return this.size;
     }
   }, {
     key: "more",
@@ -7923,10 +8269,14 @@ var BufferStream = /*#__PURE__*/function () {
       if (this.offset + length > this.endOffset) {
         throw new Error("Request more than currently allocated buffer");
       }
-      var newBuf = new ReadBufferStream(this.buffer, null, {
-        start: this.offset,
-        stop: this.offset + length
-      });
+
+      // Optimize the more implementation to choose between a slice and
+      // a sub-string reference to the original set of views.
+      // const newBuf = new ReadBufferStream(this.buffer, null, {
+      //   start: this.offset,
+      //   stop: this.offset + length
+      // });
+      var newBuf = new ReadBufferStream(this.slice(this.offset, this.offset + length));
       this.increment(length);
       return newBuf;
     }
@@ -7939,12 +8289,12 @@ var BufferStream = /*#__PURE__*/function () {
   }, {
     key: "end",
     value: function end() {
-      return this.offset >= this.buffer.byteLength;
+      return this.offset >= this.view.byteLength;
     }
   }, {
     key: "toEnd",
     value: function toEnd() {
-      this.offset = this.buffer.byteLength;
+      this.offset = this.view.byteLength;
     }
   }]);
   return BufferStream;
@@ -7952,6 +8302,7 @@ var BufferStream = /*#__PURE__*/function () {
 var ReadBufferStream = /*#__PURE__*/function (_BufferStream) {
   _inherits(ReadBufferStream, _BufferStream);
   function ReadBufferStream(buffer, littleEndian) {
+    var _ref, _options$start;
     var _this;
     var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
       start: null,
@@ -7959,13 +8310,20 @@ var ReadBufferStream = /*#__PURE__*/function (_BufferStream) {
       noCopy: false
     };
     _classCallCheck(this, ReadBufferStream);
-    _this = _callSuper(this, ReadBufferStream, [buffer, littleEndian]);
-    _this.offset = options.start || 0;
-    _this.size = options.stop || _this.buffer.byteLength;
+    _this = _callSuper(this, ReadBufferStream, [{
+      littleEndian: littleEndian
+    }]);
     _this.noCopy = options.noCopy;
+    _this.decoder = new TextDecoder("latin1");
+    if (buffer instanceof BufferStream) {
+      _this.view.from(buffer.view, options);
+    } else if (buffer) {
+      _this.view.addBuffer(buffer);
+    }
+    _this.offset = (_ref = (_options$start = options.start) !== null && _options$start !== void 0 ? _options$start : buffer === null || buffer === void 0 ? void 0 : buffer.offset) !== null && _ref !== void 0 ? _ref : 0;
+    _this.size = options.stop || (buffer === null || buffer === void 0 ? void 0 : buffer.size) || (buffer === null || buffer === void 0 ? void 0 : buffer.byteLength) || 0;
     _this.startOffset = _this.offset;
     _this.endOffset = _this.size;
-    _this.decoder = new TextDecoder("latin1");
     return _this;
   }
   _createClass(ReadBufferStream, [{
@@ -7973,18 +8331,6 @@ var ReadBufferStream = /*#__PURE__*/function (_BufferStream) {
     value: function setDecoder(decoder) {
       this.decoder = decoder;
     }
-  }, {
-    key: "getBuffer",
-    value: function getBuffer(start, end) {
-      if (this.noCopy) {
-        return new Uint8Array(this.buffer, start, end - start);
-      }
-      if (!start && !end) {
-        start = 0;
-        end = this.size;
-      }
-      return this.buffer.slice(start, end);
-    }
   }, {
     key: "reset",
     value: function reset() {
@@ -8085,10 +8431,13 @@ var DeflatedReadBufferStream = /*#__PURE__*/function (_ReadBufferStream) {
 }(ReadBufferStream);
 var WriteBufferStream = /*#__PURE__*/function (_BufferStream2) {
   _inherits(WriteBufferStream, _BufferStream2);
-  function WriteBufferStream(buffer, littleEndian) {
+  function WriteBufferStream(defaultSize, littleEndian) {
     var _this2;
     _classCallCheck(this, WriteBufferStream);
-    _this2 = _callSuper(this, WriteBufferStream, [buffer, littleEndian]);
+    _this2 = _callSuper(this, WriteBufferStream, [{
+      defaultSize: defaultSize,
+      littleEndian: littleEndian
+    }]);
     _this2.size = 0;
     return _this2;
   }
@@ -9762,8 +10111,6 @@ var SequenceOfItems = /*#__PURE__*/function (_ValueRepresentation8) {
         var undefLength = sqlength == 0xffffffff,
           elements = [],
           read = 0;
-
-        /* eslint-disable-next-line no-constant-condition */
         while (true) {
           var tag = Tag$1.readTag(stream),
             length = null;
@@ -10541,15 +10888,23 @@ var DicomMessage = /*#__PURE__*/function () {
       var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
         ignoreErrors: false,
         untilTag: null,
-        includeUntilTagValue: false
+        includeUntilTagValue: false,
+        stopOnGreaterTag: false
       };
       var ignoreErrors = options.ignoreErrors,
-        untilTag = options.untilTag;
+        untilTag = options.untilTag,
+        stopOnGreaterTag = options.stopOnGreaterTag;
       var dict = {};
       try {
+        var previousTagOffset;
         while (!bufferStream.end()) {
+          previousTagOffset = bufferStream.offset;
           var readInfo = DicomMessage._readTag(bufferStream, syntax, options);
           var cleanTagString = readInfo.tag.toCleanString();
+          if (untilTag && stopOnGreaterTag && cleanTagString > untilTag) {
+            bufferStream.offset = previousTagOffset;
+            break;
+          }
           if (cleanTagString === "00080005") {
             if (readInfo.values.length > 0) {
               var coding = readInfo.values[0];
@@ -10623,15 +10978,36 @@ var DicomMessage = /*#__PURE__*/function () {
       if (stream.readAsciiString(4) !== "DICM") {
         throw new Error("Invalid DICOM file, expected header is missing");
       }
+
+      // save position before reading first tag
+      var metaStartPos = stream.offset;
+
+      // read the first tag to check if it's the meta length tag
       var el = DicomMessage._readTag(stream, useSyntax);
+      var metaHeader = {};
       if (el.tag.toCleanString() !== "00020000") {
-        throw new Error("Invalid DICOM file, meta length tag is malformed or not present.");
-      }
-      var metaLength = el.values[0];
+        // meta length tag is missing
+        if (!options.ignoreErrors) {
+          throw new Error("Invalid DICOM file, meta length tag is malformed or not present.");
+        }
+
+        // reset stream to the position where we started reading tags
+        stream.offset = metaStartPos;
 
-      //read header buffer
-      var metaStream = stream.more(metaLength);
-      var metaHeader = DicomMessage._read(metaStream, useSyntax, options);
+        // read meta header elements sequentially
+        metaHeader = DicomMessage._read(stream, useSyntax, {
+          untilTag: "00030000",
+          stopOnGreaterTag: true,
+          ignoreErrors: true
+        });
+      } else {
+        // meta length tag is present
+        var metaLength = el.values[0];
+
+        // read header buffer using the specified meta length
+        var metaStream = stream.more(metaLength);
+        metaHeader = DicomMessage._read(metaStream, useSyntax, options);
+      }
 
       //get the syntax
       var mainSyntax = metaHeader["00020010"].Value[0];