dcmjs 0.48.0 → 0.49.0

package/build/dcmjs.es.js

@@ -7951,14 +7951,14 @@ var Inflate_1$1 = Inflate$1;
 var inflate_2 = inflate$1;
 var inflateRaw_1$1 = inflateRaw$1;
 var ungzip$1 = inflate$1;
-var constants = constants$2;
+var constants$3 = constants$2;
 
 var inflate_1$1 = {
 	Inflate: Inflate_1$1,
 	inflate: inflate_2,
 	inflateRaw: inflateRaw_1$1,
 	ungzip: ungzip$1,
-	constants: constants
+	constants: constants$3
 };
 
 const { Deflate, deflate, deflateRaw, gzip } = deflate_1$1;
@@ -8024,26 +8024,28 @@ var SplitDataView = /*#__PURE__*/function () {
   _createClass(SplitDataView, [{
     key: "consume",
     value: function consume(offset) {
-      var _this$consumeListener;
       this.consumeOffset = Math.max(offset, this.consumeOffset);
       if (!this.consumed || !this.offsets.length) {
         return;
       }
-      var nextOffset = this.offsets[this.consumed.length];
-      var nextLength = this.lengths[this.consumed.length];
-      if (nextOffset === undefined || nextLength === undefined) {
-        return;
-      }
-      var currentEnd = nextOffset + nextLength;
-      if (this.consumeOffset < currentEnd) {
-        // Haven't finished consuming all the data in the current block
-        return;
+      while (true) {
+        var _this$consumeListener;
+        var nextOffset = this.offsets[this.consumed.length];
+        var nextLength = this.lengths[this.consumed.length];
+        if (nextOffset === undefined || nextLength === undefined) {
+          return;
+        }
+        var currentEnd = nextOffset + nextLength;
+        if (this.consumeOffset < currentEnd) {
+          // Haven't finished consuming all the data in the current block
+          return;
+        }
+        // Consume the entire buffer for now
+        this.consumed.push((_this$consumeListener = this.consumeListener) === null || _this$consumeListener === void 0 ? void 0 : _this$consumeListener.call(this, this.buffers, 0, Math.min(this.buffers.length, nextOffset - this.consumeOffset)));
+        this.buffers[this.consumed.length - 1] = null;
+        this.views[this.consumed.length - 1] = null;
+        // Continue loop to check if there are more buffers to consume
       }
-      // Consume the entire buffer for now
-      this.consumed.push((_this$consumeListener = this.consumeListener) === null || _this$consumeListener === void 0 ? void 0 : _this$consumeListener.call(this, this.buffers, 0, Math.min(this.buffers.length, nextOffset - this.consumeOffset)));
-      this.buffers[this.consumed.length - 1] = null;
-      this.views[this.consumed.length - 1] = null;
-      this.consume(offset);
     }
 
     /**
@@ -8386,6 +8388,52 @@ var SplitDataView = /*#__PURE__*/function () {
         this.writeCommit(view, offset);
       }
     }
+
+    /**
+     * Reports on the amount of memory held by the buffers in the view.
+     * @param {number} consumeOffset - The current consume offset (typically from BufferStream.offset)
+     * @returns {Object} An object containing:
+     *   - bufferCount: Number of buffers still held (not null)
+     *   - totalSize: Total size of all buffers in bytes
+     *   - consumeOffset: The current consume offset
+     *   - buffersBeforeOffset: Number of buffers before the consume offset
+     *   - bytesBeforeOffset: Total bytes before the consume offset
+     */
+  }, {
+    key: "getBufferMemoryInfo",
+    value: function getBufferMemoryInfo(consumeOffset) {
+      var bufferCount = 0;
+      var totalSize = 0;
+      var buffersBeforeOffset = 0;
+      var bytesBeforeOffset = 0;
+      var currentConsumeOffset = consumeOffset !== null && consumeOffset !== void 0 ? consumeOffset : this.consumeOffset;
+      for (var i = 0; i < this.buffers.length; i++) {
+        var buffer = this.buffers[i];
+        if (buffer !== null && buffer !== undefined) {
+          bufferCount++;
+          totalSize += buffer.byteLength;
+
+          // Count buffers and bytes that are before the consume offset
+          var bufferStart = this.offsets[i];
+          var bufferEnd = bufferStart + this.lengths[i];
+          if (bufferEnd <= currentConsumeOffset) {
+            // Buffer is completely before the offset
+            buffersBeforeOffset++;
+            bytesBeforeOffset += buffer.byteLength;
+          } else if (bufferStart < currentConsumeOffset) {
+            // Buffer spans the offset, count the portion before it
+            bytesBeforeOffset += currentConsumeOffset - bufferStart;
+          }
+        }
+      }
+      return {
+        bufferCount: bufferCount,
+        totalSize: totalSize,
+        consumeOffset: currentConsumeOffset,
+        buffersBeforeOffset: buffersBeforeOffset,
+        bytesBeforeOffset: bytesBeforeOffset
+      };
+    }
   }]);
   return SplitDataView;
 }();
@@ -8948,6 +8996,20 @@ var BufferStream = /*#__PURE__*/function () {
     value: function toEnd() {
       this.offset = this.view.byteLength;
     }
+
+    /**
+     * Reports on the amount of memory held by the buffers in the view.
+     * @returns {Object} An object containing:
+     *   - bufferCount: Number of buffers still held (not null)
+     *   - totalSize: Total size of all buffers in bytes
+     *   - consumeOffset: The current consume offset
+     *   - buffersBeforeOffset: Number of buffers before the consume offset
+     */
+  }, {
+    key: "getBufferMemoryInfo",
+    value: function getBufferMemoryInfo() {
+      return this.view.getBufferMemoryInfo(this.offset);
+    }
   }]);
   return BufferStream;
 }();
@@ -9110,6 +9172,15 @@ var EXPLICIT_BIG_ENDIAN = "1.2.840.10008.1.2.2";
  * canonical UNDEFINED_LENGTH_FIX value of -1 instead
  */
 var UNDEFINED_LENGTH = 0xffffffff;
+/**
+ * Use a -1 value for the undefined length being fixed as this is consistent
+ * with other usage and can't be confused with a real length.
+ */
+var UNDEFINED_LENGTH_FIX = -1;
+var ITEM_DELIMITATION_LENGTH = 0x00000000;
+
+// Delimitation Value
+var SEQUENCE_DELIMITATION_VALUE = 0x00000000;
 
 // Value multiplicity and padding
 var VM_DELIMITER = 0x5c;
@@ -9130,6 +9201,53 @@ var unencapsulatedTransferSyntaxes = {
   EXPLICIT_LITTLE_ENDIAN: true
 };
 
+/**
+ * Video transfer syntax UIDs (MPEG2, H.264, H.265)
+ * These transfer syntaxes treat the entire pixel data stream as a single frame
+ * regardless of the number of fragments.
+ */
+var videoTransferSyntaxUIDs = new Set(["1.2.840.10008.1.2.4.100",
+// MPEG2 Main Profile @ Main Level
+"1.2.840.10008.1.2.4.100.1",
+// MPEG2 Main Profile @ Main Level (retired)
+"1.2.840.10008.1.2.4.101",
+// MPEG2 Main Profile @ High Level
+"1.2.840.10008.1.2.4.101.1",
+// MPEG2 Main Profile @ High Level (retired)
+"1.2.840.10008.1.2.4.102",
+// MPEG-4 AVC/H.264 High Profile / Level 4.1
+"1.2.840.10008.1.2.4.102.1",
+// MPEG-4 AVC/H.264 High Profile / Level 4.1 (retired)
+"1.2.840.10008.1.2.4.103",
+// MPEG-4 AVC/H.264 BD-compatible High Profile / Level 4.1
+"1.2.840.10008.1.2.4.103.1",
+// MPEG-4 AVC/H.264 BD-compatible High Profile / Level 4.1 (retired)
+"1.2.840.10008.1.2.4.104",
+// MPEG-4 AVC/H.264 High Profile / Level 4.2 For 2D Video
+"1.2.840.10008.1.2.4.104.1",
+// MPEG-4 AVC/H.264 High Profile / Level 4.2 For 2D Video (retired)
+"1.2.840.10008.1.2.4.105",
+// MPEG-4 AVC/H.264 High Profile / Level 4.2 For 3D Video
+"1.2.840.10008.1.2.4.105.1",
+// MPEG-4 AVC/H.264 High Profile / Level 4.2 For 3D Video (retired)
+"1.2.840.10008.1.2.4.106",
+// MPEG-4 AVC/H.264 Stereo High Profile / Level 4.2
+"1.2.840.10008.1.2.4.106.1",
+// MPEG-4 AVC/H.264 Stereo High Profile / Level 4.2 (retired)
+"1.2.840.10008.1.2.4.107",
+// HEVC/H.265 Main Profile / Level 5.1
+"1.2.840.10008.1.2.4.108" // HEVC/H.265 Main 10 Profile / Level 5.1
+]);
+
+/**
+ * Checks if a transfer syntax UID is a video transfer syntax
+ * @param {string} uid - Transfer syntax UID to check
+ * @returns {boolean} - True if the UID is a video transfer syntax
+ */
+function isVideoTransferSyntax(uid) {
+  return uid && videoTransferSyntaxUIDs.has(uid);
+}
+
 /**
  * This is an enumeration of some HEX values for the tag strings, used to replace
  * constants in a few places.
@@ -9148,7 +9266,13 @@ var TagHex = {
   NumberOfFrames: "00280008",
   SpecificCharacterSet: "00080005",
   PixelRepresentation: "00280103",
-  DataSetTrailingPadding: "FFFCFFFC"
+  DataSetTrailingPadding: "FFFCFFFC",
+  StudyInstanceUID: "0020000D",
+  SeriesInstanceUID: "0020000E",
+  SOPInstanceUID: "00080018",
+  TimezoneOffsetFromUTC: "00080201",
+  AvailableTransferSyntaxUID: "00083002",
+  MediaStorageSOPInstanceUID: "00020003"
 };
 var encodingMapping = {
   "": "iso-8859-1",
@@ -9187,6 +9311,202 @@ var encodingMapping = {
   gbk: "gbk"
 };
 
+/**
+ * Maps DICOM tag hex strings to their normalized lower camelCase names
+ * for use in listener.information tracking
+ */
+var TAG_NAME_MAP = {
+  "0020000D": "studyInstanceUid",
+  "0020000E": "seriesInstanceUid",
+  "00080018": "sopInstanceUid",
+  "00020010": "transferSyntaxUid",
+  "00083002": "availableTransferSyntaxUid",
+  "00080201": "timezoneOffsetFromUtc",
+  "00080005": "specificCharacterSet",
+  "00280008": "numberOfFrames",
+  "00280010": "rows",
+  "00280011": "columns",
+  "00280002": "samplesPerPixel",
+  "00280100": "bitsAllocated",
+  "00280103": "pixelRepresentation"
+};
+
+/**
+ * Default tags to track in listener.information
+ */
+var DEFAULT_INFORMATION_TAGS = new Set(["0020000D",
+// StudyInstanceUID
+"0020000E",
+// SeriesInstanceUID
+"00080018",
+// SOPInstanceUID
+"00020010",
+// TransferSyntaxUID
+"00083002",
+// AvailableTransferSyntaxUID
+"00080201",
+// TimezoneOffsetFromUTC
+"00080005",
+// SpecificCharacterSet
+"00280008",
+// NumberOfFrames
+"00280010",
+// Rows
+"00280011",
+// Columns
+"00280002",
+// SamplesPerPixel
+"00280100",
+// BitsAllocated
+"00280103" // PixelRepresentation
+]);
+
+/**
+ * All valid DICOM VR (Value Representation) codes
+ */
+var VALID_VRS = new Set(["AE",
+// Application Entity
+"AS",
+// Age String
+"AT",
+// Attribute Tag
+"CS",
+// Code String
+"DA",
+// Date
+"DS",
+// Decimal String
+"DT",
+// Date Time
+"FL",
+// Floating Point Single
+"FD",
+// Floating Point Double
+"IS",
+// Integer String
+"LO",
+// Long String
+"LT",
+// Long Text
+"OB",
+// Other Byte
+"OD",
+// Other Double
+"OF",
+// Other Float
+"OL",
+// Other Long
+"OV",
+// Other 64-bit Very Long
+"OW",
+// Other Word
+"PN",
+// Person Name
+"SH",
+// Short String
+"SL",
+// Signed Long
+"SQ",
+// Sequence of Items
+"SS",
+// Signed Short
+"ST",
+// Short Text
+"SV",
+// Signed 64-bit Very Long
+"TM",
+// Time
+"UC",
+// Unlimited Characters
+"UI",
+// Unique Identifier
+"UL",
+// Unsigned Long
+"UN",
+// Unknown
+"UR",
+// Universal Resource
+"US",
+// Unsigned Short
+"UT",
+// Unlimited Text
+"UV" // Unsigned 64-bit Very Long
+]);
+
+/**
+ * DICOM VR (Value Representation) types that are allowed for bulkdata encoding
+ * According to DICOMweb specification
+ */
+var BULKDATA_VRS = new Set(["DS",
+// Decimal String
+"FL",
+// Floating Point Single
+"FD",
+// Floating Point Double
+"IS",
+// Integer String
+"LT",
+// Long Text
+"OB",
+// Other Byte
+"OD",
+// Other Double
+"OF",
+// Other Float
+"OL",
+// Other Long
+"OV",
+// Other 64-bit Very Long
+"OW",
+// Other Word
+"SL",
+// Signed Long
+"SS",
+// Signed Short
+"ST",
+// Short Text
+"SV",
+// Signed 64-bit Very Long
+"UC",
+// Unlimited Characters
+"UL",
+// Unsigned Long
+"UN",
+// Unknown
+"US",
+// Unsigned Short
+"UT",
+// Unlimited Text
+"UV" // Unsigned 64-bit Very Long
+]);
+
+var constants = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	BULKDATA_VRS: BULKDATA_VRS,
+	DEFAULT_INFORMATION_TAGS: DEFAULT_INFORMATION_TAGS,
+	DEFLATED_EXPLICIT_LITTLE_ENDIAN: DEFLATED_EXPLICIT_LITTLE_ENDIAN,
+	EXPLICIT_BIG_ENDIAN: EXPLICIT_BIG_ENDIAN,
+	EXPLICIT_LITTLE_ENDIAN: EXPLICIT_LITTLE_ENDIAN$1,
+	IMPLICIT_LITTLE_ENDIAN: IMPLICIT_LITTLE_ENDIAN,
+	ITEM_DELIMITATION_LENGTH: ITEM_DELIMITATION_LENGTH,
+	PADDING_NULL: PADDING_NULL,
+	PADDING_SPACE: PADDING_SPACE,
+	PN_COMPONENT_DELIMITER: PN_COMPONENT_DELIMITER,
+	SEQUENCE_DELIMITATION_VALUE: SEQUENCE_DELIMITATION_VALUE,
+	SEQUENCE_DELIMITER_TAG: SEQUENCE_DELIMITER_TAG,
+	SEQUENCE_ITEM_TAG: SEQUENCE_ITEM_TAG,
+	TAG_NAME_MAP: TAG_NAME_MAP,
+	TagHex: TagHex,
+	UNDEFINED_LENGTH: UNDEFINED_LENGTH,
+	UNDEFINED_LENGTH_FIX: UNDEFINED_LENGTH_FIX,
+	VALID_VRS: VALID_VRS,
+	VM_DELIMITER: VM_DELIMITER,
+	encodingMapping: encodingMapping,
+	isVideoTransferSyntax: isVideoTransferSyntax,
+	unencapsulatedTransferSyntaxes: unencapsulatedTransferSyntaxes,
+	videoTransferSyntaxUIDs: videoTransferSyntaxUIDs
+});
+
 /**
  * Converts a PN string to the dicom+json equivalent, or returns the
  * original object
@@ -11156,7 +11476,8 @@ var DicomMetaDictionary = /*#__PURE__*/function () {
       return namedDataset;
     }
 
-    /** converts from DICOM JSON Model dataset to a natural dataset
+    /**
+     * converts from DICOM JSON Model dataset to a natural dataset
      * - sequences become lists
      * - single element lists are replaced by their first element,
      *     with single element lists remaining lists, but being a
@@ -12166,80 +12487,1426 @@ var Colors = /*#__PURE__*/function () {
       } else {
         return Math.pow((n + 0.055) / 1.055, 2.4);
       }
-    }
-  }, {
-    key: "rgb2XYZ",
-    value: function rgb2XYZ(rgb) {
-      var R = Colors.invGammaCorrection(rgb[0]);
-      var G = Colors.invGammaCorrection(rgb[1]);
-      var B = Colors.invGammaCorrection(rgb[2]);
-      return [0.4123955889674142161 * R + 0.3575834307637148171 * G + 0.1804926473817015735 * B, 0.2125862307855955516 * R + 0.7151703037034108499 * G + 0.07220049864333622685 * B, 0.01929721549174694484 * R + 0.1191838645808485318 * G + 0.950497125131579766 * B];
-    }
+    }
+  }, {
+    key: "rgb2XYZ",
+    value: function rgb2XYZ(rgb) {
+      var R = Colors.invGammaCorrection(rgb[0]);
+      var G = Colors.invGammaCorrection(rgb[1]);
+      var B = Colors.invGammaCorrection(rgb[2]);
+      return [0.4123955889674142161 * R + 0.3575834307637148171 * G + 0.1804926473817015735 * B, 0.2125862307855955516 * R + 0.7151703037034108499 * G + 0.07220049864333622685 * B, 0.01929721549174694484 * R + 0.1191838645808485318 * G + 0.950497125131579766 * B];
+    }
+  }, {
+    key: "xyz2LAB",
+    value: function xyz2LAB(xyz) {
+      var whitePoint = Colors.d65WhitePointXYZ();
+      var X = xyz[0] / whitePoint[0];
+      var Y = xyz[1] / whitePoint[1];
+      var Z = xyz[2] / whitePoint[2];
+      X = Colors.labf(X);
+      Y = Colors.labf(Y);
+      Z = Colors.labf(Z);
+      return [116 * Y - 16, 500 * (X - Y), 200 * (Y - Z)];
+    }
+  }, {
+    key: "lab2RGB",
+    value: function lab2RGB(lab) {
+      return Colors.xyz2RGB(Colors.lab2XYZ(lab));
+    }
+  }, {
+    key: "lab2XYZ",
+    value: function lab2XYZ(lab) {
+      var L = (lab[0] + 16) / 116;
+      var a = L + lab[1] / 500;
+      var b = L - lab[2] / 200;
+      var whitePoint = Colors.d65WhitePointXYZ();
+      return [whitePoint[0] * Colors.labfInv(a), whitePoint[1] * Colors.labfInv(L), whitePoint[2] * Colors.labfInv(b)];
+    }
+  }, {
+    key: "xyz2RGB",
+    value: function xyz2RGB(xyz) {
+      var R1 = 3.2406 * xyz[0] - 1.5372 * xyz[1] - 0.4986 * xyz[2];
+      var G1 = -0.9689 * xyz[0] + 1.8758 * xyz[1] + 0.0415 * xyz[2];
+      var B1 = 0.0557 * xyz[0] - 0.204 * xyz[1] + 1.057 * xyz[2];
+
+      /* Force nonnegative values so that gamma correction is well-defined. */
+      var minimumComponent = Math.min(R1, G1);
+      minimumComponent = Math.min(minimumComponent, B1);
+      if (minimumComponent < 0) {
+        R1 -= minimumComponent;
+        G1 -= minimumComponent;
+        B1 -= minimumComponent;
+      }
+
+      /* Transform from RGB to R'G'B' */
+      return [Colors.gammaCorrection(R1), Colors.gammaCorrection(G1), Colors.gammaCorrection(B1)];
+    }
+  }, {
+    key: "labf",
+    value: function labf(n) {
+      if (n >= 8.85645167903563082e-3) {
+        return Math.pow(n, 0.333333333333333);
+      } else {
+        return 841.0 / 108.0 * n + 4.0 / 29.0;
+      }
+    }
+  }, {
+    key: "labfInv",
+    value: function labfInv(n) {
+      if (n >= 0.206896551724137931) {
+        return n * n * n;
+      } else {
+        return 108.0 / 841.0 * (n - 4.0 / 29.0);
+      }
+    }
+  }]);
+  return Colors;
+}();
+
+/**
+ * Creates an information filter that tracks top-level DICOM attributes.
+ *
+ * @param {Set<string>} tags - Optional set of tag hex strings to track.
+ *        If not provided, uses DEFAULT_INFORMATION_TAGS.
+ * @returns {Object} A filter object that adds listener.information attribute
+ */
+function createInformationFilter() {
+  var tags = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_INFORMATION_TAGS;
+  var filter = {
+    information: null,
+    /**
+     * Initializes the filter, synchronizing the information object with the parent listener
+     */
+    _init: function _init(options) {
+      filter.information = (options === null || options === void 0 ? void 0 : options.information) || {};
+      this.information = filter.information;
+    },
+    /**
+     * Intercepts addTag calls to track top-level attributes in listener.information
+     */
+    addTag: function addTag(next, tag, tagInfo) {
+      var _this$current;
+      // Check if this is a top-level tag (level 0) and is in our tracked set
+      if (((_this$current = this.current) === null || _this$current === void 0 ? void 0 : _this$current.level) === 0 && tags.has(tag)) {
+        // Store a reference to track this tag for value updates
+        var normalizedName = TAG_NAME_MAP[tag] || tag;
+        this.information[normalizedName] = null;
+
+        // Mark this tag for tracking
+        var result = next(tag, tagInfo);
+        this.current._trackInformation = normalizedName;
+        return result;
+      }
+      return next(tag, tagInfo);
+    },
+    /**
+     * Intercepts value calls to populate information values
+     */
+    value: function value(next, v) {
+      var _this$current2;
+      // If current context is tracking information, store the first value
+      if ((_this$current2 = this.current) !== null && _this$current2 !== void 0 && _this$current2._trackInformation) {
+        var name = this.current._trackInformation;
+        this.information[name] = v;
+        this.current._trackInformation = null;
+      }
+      return next(v);
+    }
+  };
+  return filter;
+}
+
+/**
+ * A DICOM Metadata listener implements the basic listener for creating a dicom
+ * metadata instance from a stream of notification events.
+ *
+ * There are additional listeners defined in @cornerstonejs/metadata as well as
+ * other event sources in that package.
+ *
+ * **Important behaviors:**
+ * - Each frame is ALWAYS delivered as an array (ArrayBuffer[]), even for single frames
+ * - Video transfer syntaxes are handled as though they were a single frame
+ * - Binary data can be delivered fragmented - a single frame may be split across multiple ArrayBuffer fragments
+ * - Multiple fragments are combined into one array per frame
+ *
+ * **WARNING** This class is still under development, do not count on the API
+ * not changing a bit over the next few dcmjs releases.
+ */
+var DicomMetadataListener = /*#__PURE__*/function () {
+  /**
+   * Creates a new DicomMetadataListener instance.
+   *
+   * @param {Object} options - Configuration options
+   * @param {Object} options.informationFilter - Optional information filter to use.
+   *        If not provided, creates one automatically.
+   * @param {Set<string>} options.informationTags - Optional set of tag hex strings
+   *        to track in listener.information. If not provided, uses default tags.
+   * @param {...Object} filters - Optional filter objects that can intercept
+   *        method calls. Each filter can have methods like addTag, startObject,
+   *        pop, or value. Each filter method receives a 'next'
+   *        function as the first argument, followed by the same arguments as
+   *        the original method.
+   *
+   * @example
+   * const listener = new DicomMetadataListener();
+   *
+   * @example
+   * const listener = new DicomMetadataListener(
+   *   { informationTags: new Set(['0020000D', '0020000E']) }
+   * );
+   *
+   * @example
+   * const listener = new DicomMetadataListener(
+   *   {},
+   *   {
+   *     addTag(next, tag, tagInfo) {
+   *       console.log('Adding tag:', tag);
+   *       return next(tag, tagInfo);
+   *     }
+   *   }
+   * );
+   */
+  function DicomMetadataListener() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    for (var _len = arguments.length, filters = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      filters[_key - 1] = arguments[_key];
+    }
+    _classCallCheck(this, DicomMetadataListener);
+    _defineProperty(this, "current", null);
+    _defineProperty(this, "fmi", null);
+    _defineProperty(this, "dict", null);
+    _defineProperty(this, "filters", []);
+    _defineProperty(this, "information", null);
+    // Handle legacy constructor format where first arg might be a filter
+    if (typeof options.addTag === "function" || typeof options.startObject === "function" || typeof options.pop === "function" || typeof options.value === "function") {
+      // Legacy format: all arguments are filters
+      filters = [options].concat(_toConsumableArray(filters));
+      options = {};
+    }
+
+    // Information filter should always be first so it can track tags
+    // Use the provided informationFilter or create a new one
+    var informationFilter = options.informationFilter || createInformationFilter(options.informationTags);
+    this.filters = [informationFilter].concat(_toConsumableArray(filters));
+    this._createMethodChains();
+
+    // Initialize filters to synchronize state
+    this.init(options);
+  }
+
+  /**
+   * Initializes state, allowing it to be re-used.
+   * @param {Object} options - Optional options to pass to the filters to re-initialize them
+   * @param {Object} options.information - Optional information to pass to the filters
+   * @returns {void}
+   */
+  _createClass(DicomMetadataListener, [{
+    key: "init",
+    value: function init() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
+      this.current = null;
+      this.fmi = null;
+      this.dict = null;
+      this.information = null;
+      var _iterator = _createForOfIteratorHelper(this.filters),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _filter$_init;
+          var filter = _step.value;
+          (_filter$_init = filter._init) === null || _filter$_init === void 0 || _filter$_init.call(this, options);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+
+    /**
+     * Creates method chains for each method that can be filtered.
+     * @private
+     */
+  }, {
+    key: "_createMethodChains",
+    value: function _createMethodChains() {
+      var _this = this;
+      var methods = ["addTag", "startObject", "pop", "value"];
+      for (var _i = 0, _methods = methods; _i < _methods.length; _i++) {
+        var methodName = _methods[_i];
+        var baseMethod = this["_base".concat(methodName.charAt(0).toUpperCase() + methodName.slice(1))].bind(this);
+
+        // Build the chain by wrapping each filter
+        // Start with the base implementation
+        var chain = baseMethod;
+
+        // Apply filters in reverse order so they execute in forward order
+        var _loop = function _loop() {
+          var filter = _this.filters[i];
+          if (filter && typeof filter[methodName] === "function") {
+            var filterFn = filter[methodName];
+            var next = chain;
+            chain = function chain() {
+              for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+                args[_key2] = arguments[_key2];
+              }
+              return filterFn.call.apply(filterFn, [_this, next].concat(args));
+            };
+          }
+        };
+        for (var i = this.filters.length - 1; i >= 0; i--) {
+          _loop();
+        }
+
+        // Replace the method with the chained version
+        this[methodName] = chain;
+      }
+    }
+
+    /**
+     * Base implementation: Adds a new tag value
+     * @private
+     */
+  }, {
+    key: "_baseAddTag",
+    value: function _baseAddTag(tag, tagInfo) {
+      var _this$current$level;
+      var dest = {
+        vr: tagInfo === null || tagInfo === void 0 ? void 0 : tagInfo.vr,
+        Value: null
+      };
+      if (this.current && this.current.dest) {
+        this.current.dest[tag] = dest;
+      }
+      // Tags are at the same level as their parent (they're properties, not nested structures)
+      var level = this.current ? (_this$current$level = this.current.level) !== null && _this$current$level !== void 0 ? _this$current$level : 0 : 0;
+      this.current = {
+        parent: this.current,
+        dest: dest,
+        type: tag,
+        tag: tag,
+        vr: tagInfo === null || tagInfo === void 0 ? void 0 : tagInfo.vr,
+        level: level,
+        length: tagInfo === null || tagInfo === void 0 ? void 0 : tagInfo.length
+      };
+    }
+
+    /**
+     * Base implementation: Starts a new object, using the provided value
+     * @private
+     */
+  }, {
+    key: "_baseStartObject",
+    value: function _baseStartObject() {
+      var _this$current$level2;
+      var dest = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      // Objects/sequences are nested structures, so they increment the level
+      // Root object is at level 0, nested objects are one level deeper
+      var level = this.current ? ((_this$current$level2 = this.current.level) !== null && _this$current$level2 !== void 0 ? _this$current$level2 : 0) + 1 : 0;
+      if (this.current) {
+        this.value(dest);
+      }
+      this.current = {
+        parent: this.current,
+        dest: dest,
+        type: "object",
+        level: level
+      };
+    }
+
+    /**
+     * Base implementation: Pops the current value being created off the stack.
+     * @private
+     */
+  }, {
+    key: "_basePop",
+    value: function _basePop() {
+      var _this$current$pop, _this$current$pop2, _this$current3, _result$Value;
+      var result = (_this$current$pop = (_this$current$pop2 = (_this$current3 = this.current).pop) === null || _this$current$pop2 === void 0 ? void 0 : _this$current$pop2.call(_this$current3)) !== null && _this$current$pop !== void 0 ? _this$current$pop : this.current.dest;
+      if (result.InlineBinary) {
+        console.log("********* InlineBinary already set", result, this.current);
+      }
+      if (result.Value === null) {
+        result.Value = [];
+      } else if (((_result$Value = result.Value) === null || _result$Value === void 0 ? void 0 : _result$Value.length) === 1 && (result.Value[0] === null || result.Value[0] === undefined)) {
+        result.Value = [];
+      }
+      this.current = this.current.parent;
+      return result;
+    }
+
+    /**
+     * Base implementation: Registers a new value for the current destination being created.
+     *
+     * Note: Binary data (ArrayBuffer) can be delivered fragmented across multiple calls.
+     * Multiple fragments are combined into arrays. Each frame is always delivered as an array.
+     *
+     * @private
+     */
+  }, {
+    key: "_baseValue",
+    value: function _baseValue(v) {
+      var _this$current$dest;
+      if (Array.isArray(this.current.dest)) {
+        this.current.dest.push(v);
+        return;
+      }
+      (_this$current$dest = this.current.dest).Value || (_this$current$dest.Value = []);
+      this.current.dest.Value.push(v);
+    }
+
+    /**
+     * Gets the Transfer Syntax UID from the File Meta Information (FMI)
+     * @returns {string|undefined} - Transfer syntax UID or undefined if not available
+     */
+  }, {
+    key: "getTransferSyntaxUID",
+    value: function getTransferSyntaxUID() {
+      var _this$fmi$transferSyn;
+      if (!this.fmi) {
+        return undefined;
+      }
+      var transferSyntaxTag = "00020010"; // TransferSyntaxUID tag
+      if ((_this$fmi$transferSyn = this.fmi[transferSyntaxTag]) !== null && _this$fmi$transferSyn !== void 0 && _this$fmi$transferSyn.Value && Array.isArray(this.fmi[transferSyntaxTag].Value) && this.fmi[transferSyntaxTag].Value.length > 0) {
+        return this.fmi[transferSyntaxTag].Value[0];
+      }
+      return undefined;
+    }
+  }]);
+  return DicomMetadataListener;
+}();
+
+/**
+ * This is an asynchronous binary DICOM reader.
+ *
+ * Assume this is still preliminary as to the exact interface as it is
+ * initially being released for testing purposes only.
+ *
+ * There is no support for compressed streams.
+ */
+var AsyncDicomReader = /*#__PURE__*/function () {
+  function AsyncDicomReader() {
+    var _options$maxFragmentS;
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, AsyncDicomReader);
+    _defineProperty(this, "syntax", EXPLICIT_LITTLE_ENDIAN$1);
+    this.isLittleEndian = options === null || options === void 0 ? void 0 : options.isLittleEndian;
+    // Default maxFragmentSize is 128 MB (128 * 1024 * 1024 bytes)
+    this.maxFragmentSize = (_options$maxFragmentS = options === null || options === void 0 ? void 0 : options.maxFragmentSize) !== null && _options$maxFragmentS !== void 0 ? _options$maxFragmentS : 128 * 1024 * 1024;
+    this.stream = new ReadBufferStream(null, this.isLittleEndian, _objectSpread2({
+      clearBuffers: true
+    }, options));
+  }
+
+  /**
+   * Reads the preamble and checks for the DICM marker.
+   * Returns true if found/read, leaving the stream past the
+   * marker, or false, having not found the marker.
+   *
+   * If no preamble is found, attempts to detect raw LEI/LEE encoding
+   * by examining the first tag structure.
+   */
+  _createClass(AsyncDicomReader, [{
+    key: "readPreamble",
+    value: (function () {
+      var _readPreamble = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var stream;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              stream = this.stream;
+              _context.next = 3;
+              return stream.ensureAvailable();
+            case 3:
+              stream.reset();
+              stream.increment(128);
+              if (!(stream.readAsciiString(4) !== "DICM")) {
+                _context.next = 10;
+                break;
+              }
+              stream.reset();
+              // No preamble found - try to detect raw dataset encoding
+              _context.next = 9;
+              return this.detectRawEncoding();
+            case 9:
+              return _context.abrupt("return", false);
+            case 10:
+              return _context.abrupt("return", true);
+            case 11:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function readPreamble() {
+        return _readPreamble.apply(this, arguments);
+      }
+      return readPreamble;
+    }()
+    /**
+     * Detects whether a raw dataset (no Part 10 preamble) is LEI or LEE encoded.
+     * This is done by examining the first tag structure:
+     * - LEI: Tag (4 bytes) + Length (4 bytes) - no VR
+     * - LEE: Tag (4 bytes) + VR (2 bytes ASCII) + Length (2 or 4 bytes)
+     *
+     * We check if bytes 4-5 look like a valid DICOM VR (2 ASCII letters that
+     * match known VR codes). If a valid VR is detected, we use LEE, otherwise LEI.
+     */
+    )
+  }, {
+    key: "detectRawEncoding",
+    value: (function () {
+      var _detectRawEncoding = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+        var stream, group, byte4, byte5, potentialLength, isASCIILetter, vrCandidate;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              stream = this.stream;
+              _context2.next = 3;
+              return stream.ensureAvailable(8);
+            case 3:
+              // Need at least 8 bytes (tag + length) to detect
+
+              stream.reset();
+              stream.setEndian(true); // Little endian for both LEI and LEE
+
+              // Read the tag (first 4 bytes)
+              group = stream.readUint16();
+              stream.readUint16();
+
+              // Verify this looks like a DICOM file - first tag should be in group 0008
+              if (!(group !== 0x0008)) {
+                _context2.next = 9;
+                break;
+              }
+              throw new Error("Invalid DICOM file: expected first tag group to be 0x0008, found 0x".concat(group.toString(16).padStart(4, "0")));
+            case 9:
+              // Check if bytes 4-5 (after tag) look like a valid VR (2 ASCII letters)
+              byte4 = stream.peekUint8(0);
+              byte5 = stream.peekUint8(1); // If we're going to assume LEI, check the length is even (DICOM requirement)
+              // Read the length value (4 bytes after tag in LEI format) as little-endian uint32
+              _context2.next = 13;
+              return stream.ensureAvailable(8);
+            case 13:
+              // Need at least 8 bytes (tag + length)
+              potentialLength = stream.view.getUint32(stream.offset, true); // true = little endian
+              isASCIILetter = function isASCIILetter(byte) {
+                return byte >= 0x41 && byte <= 0x5a ||
+                // A-Z
+                byte >= 0x61 && byte <= 0x7a; // a-z
+              };
+              if (!(isASCIILetter(byte4) && isASCIILetter(byte5))) {
+                _context2.next = 26;
+                break;
+              }
+              // Check if it's a valid VR code
+              vrCandidate = String.fromCharCode(byte4, byte5).toUpperCase();
+              if (!VALID_VRS.has(vrCandidate)) {
+                _context2.next = 21;
+                break;
+              }
+              // Valid VR detected - this is LEE (Explicit Little Endian)
+              this.syntax = EXPLICIT_LITTLE_ENDIAN$1;
+              _context2.next = 24;
+              break;
+            case 21:
+              if (!(potentialLength % 2 !== 0)) {
+                _context2.next = 23;
+                break;
+              }
+              throw new Error("Invalid DICOM file: detected LEI encoding but length is odd (".concat(potentialLength, "), which is not allowed in DICOM"));
+            case 23:
+              this.syntax = IMPLICIT_LITTLE_ENDIAN;
+            case 24:
+              _context2.next = 29;
+              break;
+            case 26:
+              if (!(potentialLength % 2 !== 0)) {
+                _context2.next = 28;
+                break;
+              }
+              throw new Error("Invalid DICOM file: detected LEI encoding but length is odd (".concat(potentialLength, "), which is not allowed in DICOM"));
+            case 28:
+              this.syntax = IMPLICIT_LITTLE_ENDIAN;
+            case 29:
+              // Reset stream to beginning for reading
+              stream.reset();
+            case 30:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function detectRawEncoding() {
+        return _detectRawEncoding.apply(this, arguments);
+      }
+      return detectRawEncoding;
+    }())
+  }, {
+    key: "readFile",
+    value: function () {
+      var _readFile = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+        var options,
+          hasPreamble,
+          _listener,
+          information,
+          listener,
+          _this$meta,
+          _information,
+          _args3 = arguments;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              options = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : undefined;
+              _context3.next = 3;
+              return this.readPreamble();
+            case 3:
+              hasPreamble = _context3.sent;
+              if (hasPreamble) {
+                _context3.next = 14;
+                break;
+              }
+              // Handle raw dataset (no Part 10 preamble)
+              // Encoding should already be detected in readPreamble()
+              this.meta = {}; // No meta header for raw datasets
+              _listener = (options === null || options === void 0 ? void 0 : options.listener) || new DicomMetadataListener();
+              if (_listener.information) {
+                information = _listener.information;
+                information.transferSyntaxUid = this.syntax;
+              }
+              this.dict || (this.dict = {});
+              _listener.startObject(this.dict);
+              _context3.next = 12;
+              return this.read(_listener, options);
+            case 12:
+              this.dict = _context3.sent;
+              return _context3.abrupt("return", this);
+            case 14:
+              _context3.next = 16;
+              return this.readMeta(options);
+            case 16:
+              this.meta = _context3.sent;
+              listener = (options === null || options === void 0 ? void 0 : options.listener) || new DicomMetadataListener();
+              if (listener.information) {
+                _information = listener.information;
+                _information.transferSyntaxUid = this.syntax;
+                _information.sopInstanceUid = (_this$meta = this.meta) === null || _this$meta === void 0 || (_this$meta = _this$meta[TagHex.MediaStoreSOPInstanceUID]) === null || _this$meta === void 0 ? void 0 : _this$meta.Value[0];
+              }
+              this.dict || (this.dict = {});
+              listener.startObject(this.dict);
+              _context3.next = 23;
+              return this.read(listener, options);
+            case 23:
+              this.dict = _context3.sent;
+              return _context3.abrupt("return", this);
+            case 25:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function readFile() {
+        return _readFile.apply(this, arguments);
+      }
+      return readFile;
+    }()
+    /**
+     * Reads the file meta information.
+     *
+     * @param options.maxSizeMeta - maximum number of bytes for reading the meta
+     *      header when it isn't in a group length section.
+     * @param options.ignoreErrors - allow reading past some errors.
+     *        In this case, reading a meta section not inside a group length.
+     */
+  }, {
+    key: "readMeta",
+    value: (function () {
+      var _readMeta = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+        var options,
+          stream,
+          metaStartPos,
+          el,
+          metaLength,
+          metaStream,
+          _args4 = arguments;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              options = _args4.length > 0 && _args4[0] !== undefined ? _args4[0] : undefined;
+              stream = this.stream;
+              _context4.next = 4;
+              return stream.ensureAvailable();
+            case 4:
+              metaStartPos = stream.offset;
+              el = this.readTagHeader();
+              if (!(el.tag !== TagHex.FileMetaInformationGroupLength)) {
+                _context4.next = 15;
+                break;
+              }
+              if (options !== null && options !== void 0 && options.ignoreErrors) {
+                _context4.next = 9;
+                break;
+              }
+              throw new Error("Invalid DICOM file, meta length tag is malformed or not present.");
+            case 9:
+              // reset stream to the position where we started reading tags
+              stream.offset = metaStartPos;
+              // Wait for at least 10k to be available to make sure there is enough
+              // data to read the entire Meta header
+              _context4.next = 12;
+              return stream.ensureAvailable((options === null || options === void 0 ? void 0 : options.maxSizeMeta) || 1024 * 10);
+            case 12:
+              // read meta header elements sequentially
+              this.meta = DicomMessage._read(stream, EXPLICIT_LITTLE_ENDIAN$1, {
+                untilTag: "00030000",
+                stopOnGreaterTag: true,
+                ignoreErrors: true
+              });
+              _context4.next = 20;
+              break;
+            case 15:
+              // meta length tag is present
+              metaLength = el.vrObj.readBytes(stream);
+              _context4.next = 18;
+              return stream.ensureAvailable(metaLength);
+            case 18:
+              // read header buffer using the specified meta length
+              metaStream = stream.more(metaLength);
+              this.meta = DicomMessage._read(metaStream, EXPLICIT_LITTLE_ENDIAN$1, {});
+            case 20:
+              this.syntax = this.meta[TagHex.TransferSyntaxUID].Value[0];
+              return _context4.abrupt("return", this.meta);
+            case 22:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function readMeta() {
+        return _readMeta.apply(this, arguments);
+      }
+      return readMeta;
+    }())
+  }, {
+    key: "read",
+    value: function () {
+      var _read = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(listener, options) {
+        var untilOffset, stream, tagInfo, tag, tagObj, length, addTagResult;
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              untilOffset = (options === null || options === void 0 ? void 0 : options.untilOffset) || Number.MAX_SAFE_INTEGER;
+              this.listener = listener;
+              stream = this.stream;
+              _context5.next = 5;
+              return stream.ensureAvailable();
+            case 5:
+              if (!(stream.offset < untilOffset && stream.isAvailable(1, false))) {
+                _context5.next = 43;
+                break;
+              }
+              // Consume before reading the tag so that data before the
+              // current tag can be cleared.
+              stream.consume();
+              tagInfo = this.readTagHeader(options);
+              tag = tagInfo.tag, tagObj = tagInfo.tagObj, length = tagInfo.length;
+              if (!(tag === TagHex.ItemDelimitationEnd)) {
+                _context5.next = 11;
+                break;
+              }
+              return _context5.abrupt("return", listener.pop());
+            case 11:
+              if (!tagObj.isInstruction()) {
+                _context5.next = 13;
+                break;
+              }
+              return _context5.abrupt("continue", 5);
+            case 13:
+              if (!(tagObj.group() === 0 || tag === TagHex.DataSetTrailingPadding)) {
+                _context5.next = 16;
+                break;
+              }
+              // Group length
+              stream.increment(tagObj.length);
+              return _context5.abrupt("continue", 5);
+            case 16:
+              addTagResult = listener.addTag(tag, tagInfo);
+              if (!this.isSequence(tagInfo)) {
+                _context5.next = 22;
+                break;
+              }
+              _context5.next = 20;
+              return this.readSequence(listener, tagInfo, options);
+            case 20:
+              _context5.next = 38;
+              break;
+            case 22:
+              if (!tagObj.isPixelDataTag()) {
+                _context5.next = 27;
+                break;
+              }
+              _context5.next = 25;
+              return this.readPixelData(tagInfo);
+            case 25:
+              _context5.next = 38;
+              break;
+            case 27:
+              if (!(length === UNDEFINED_LENGTH_FIX)) {
+                _context5.next = 31;
+                break;
+              }
+              throw new Error("Can't handle tag ".concat(tagInfo.tag, " with -1 length and not sequence"));
+            case 31:
+              if (!((addTagResult === null || addTagResult === void 0 ? void 0 : addTagResult.expectsRaw) === true && length > 0)) {
+                _context5.next = 36;
+                break;
+              }
+              _context5.next = 34;
+              return this.readRawBinary(tagInfo);
+            case 34:
+              _context5.next = 38;
+              break;
+            case 36:
+              _context5.next = 38;
+              return this.readSingle(tagInfo, listener, options);
+            case 38:
+              listener.pop();
+              _context5.next = 41;
+              return this.stream.ensureAvailable();
+            case 41:
+              _context5.next = 5;
+              break;
+            case 43:
+              return _context5.abrupt("return", listener.pop());
+            case 44:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function read(_x, _x2) {
+        return _read.apply(this, arguments);
+      }
+      return read;
+    }()
+  }, {
+    key: "readSequence",
+    value: function () {
+      var _readSequence = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(listener, sqTagInfo, options) {
+        var length, stream, syntax, endOffset, tagInfo, tag;
+        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              length = sqTagInfo.length;
+              stream = this.stream, syntax = this.syntax;
+              endOffset = length === UNDEFINED_LENGTH_FIX ? Number.MAX_SAFE_INTEGER : stream.offset + length;
+            case 3:
+              _context6.t0 = stream.offset < endOffset;
+              if (!_context6.t0) {
+                _context6.next = 8;
+                break;
+              }
+              _context6.next = 7;
+              return stream.ensureAvailable();
+            case 7:
+              _context6.t0 = _context6.sent;
+            case 8:
+              if (!_context6.t0) {
+                _context6.next = 25;
+                break;
+              }
+              tagInfo = this.readTagHeader(syntax, options);
+              tag = tagInfo.tag;
+              if (!(tag === TagHex.Item)) {
+                _context6.next = 17;
+                break;
+              }
+              listener.startObject();
+              _context6.next = 15;
+              return this.read(listener, _objectSpread2(_objectSpread2({}, options), {}, {
+                untilOffset: endOffset
+              }));
+            case 15:
+              _context6.next = 23;
+              break;
+            case 17:
+              if (!(tag === TagHex.SequenceDelimitationEnd)) {
+                _context6.next = 21;
+                break;
+              }
+              return _context6.abrupt("return");
+            case 21:
+              console.warn("Unknown tag info", length, tagInfo);
+              throw new Error();
+            case 23:
+              _context6.next = 3;
+              break;
+            case 25:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function readSequence(_x3, _x4, _x5) {
+        return _readSequence.apply(this, arguments);
+      }
+      return readSequence;
+    }()
+  }, {
+    key: "readPixelData",
+    value: function readPixelData(tagInfo) {
+      if (tagInfo.length === -1) {
+        return this.readCompressed(tagInfo);
+      }
+      return this.readUncompressed(tagInfo);
+    }
+
+    /**
+     * Emits one or more listener.value() calls for a fragment, splitting if needed.
+     * This does NOT start/pop any array contexts; callers control the surrounding structure.
+     */
+  }, {
+    key: "_emitSplitValues",
+    value: (function () {
+      var _emitSplitValues2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7(length) {
+        var stream, listener, maxFragmentSize, offset, chunkSize, buffer;
+        return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              stream = this.stream, listener = this.listener;
+              maxFragmentSize = this.maxFragmentSize;
+              offset = 0;
+            case 3:
+              if (!(offset < length)) {
+                _context7.next = 13;
+                break;
+              }
+              chunkSize = Math.min(maxFragmentSize, length - offset);
+              _context7.next = 7;
+              return stream.ensureAvailable(chunkSize);
+            case 7:
+              buffer = stream.readArrayBuffer(chunkSize);
+              listener.value(buffer);
+              offset += chunkSize;
+              stream.consume();
+              _context7.next = 3;
+              break;
+            case 13:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function _emitSplitValues(_x6) {
+        return _emitSplitValues2.apply(this, arguments);
+      }
+      return _emitSplitValues;
+    }()
+    /**
+     * Reads compressed streams.
+     */
+    )
+  }, {
+    key: "readCompressed",
+    value: (function () {
+      var _readCompressed = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee8(_tagInfo) {
+        var _listener$information;
+        var stream, listener, transferSyntaxUid, isVideo, numberOfFrames, isSingleFrame, offsets, singleArray, startOffset, frameNumber, lastFrame, frameTag, length;
+        return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              stream = this.stream, listener = this.listener;
+              transferSyntaxUid = this.syntax;
+              _context8.next = 4;
+              return stream.ensureAvailable();
+            case 4:
+              // Check if this is a video transfer syntax
+              isVideo = isVideoTransferSyntax(transferSyntaxUid); // Check number of frames - only use video logic for single frame (or undefined)
+              numberOfFrames = (_listener$information = listener.information) === null || _listener$information === void 0 ? void 0 : _listener$information.numberOfFrames;
+              isSingleFrame = !numberOfFrames || parseInt(numberOfFrames) <= 1;
+              _context8.next = 9;
+              return this.readOffsets();
+            case 9:
+              offsets = _context8.sent;
+              singleArray = isVideo || isSingleFrame;
+              if (singleArray && !offsets) {
+                offsets = [0];
+              }
+              if (offsets) {
+                // Last frame ends when the sequence ends, so merge the frame data
+                offsets.push(Number.MAX_SAFE_INTEGER / 2);
+              }
+              startOffset = stream.offset;
+              frameNumber = 0;
+              lastFrame = null;
+            case 16:
+              stream.consume();
+              _context8.next = 20;
+              return stream.ensureAvailable();
+            case 20:
+              frameTag = this.readTagHeader();
+              if (!(frameTag.tag === TagHex.SequenceDelimitationEnd)) {
+                _context8.next = 24;
+                break;
+              }
+              if (lastFrame) {
+                // Always deliver frames as arrays, using streaming splitFrame
+                listener.pop();
+              }
+              return _context8.abrupt("return");
+            case 24:
+              if (!(frameTag.tag !== TagHex.Item)) {
+                _context8.next = 26;
+                break;
+              }
+              throw new Error("frame tag isn't item: ".concat(frameTag.tag));
+            case 26:
+              length = frameTag.length;
+              if (!lastFrame) {
+                lastFrame = [];
+                listener.startObject(lastFrame);
+              }
+              _context8.next = 30;
+              return this._emitSplitValues(length);
+            case 30:
+              if (!offsets || stream.offset >= offsets[frameNumber + 1] + startOffset) {
+                lastFrame = null;
+                listener.pop();
+                frameNumber++;
+              }
+              _context8.next = 16;
+              break;
+            case 33:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function readCompressed(_x7) {
+        return _readCompressed.apply(this, arguments);
+      }
+      return readCompressed;
+    }())
+  }, {
+    key: "readOffsets",
+    value: function () {
+      var _readOffsets = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
+        var tagInfo, offsets, numOfFrames, i;
+        return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              tagInfo = this.readTagHeader();
+              if (!(tagInfo.tag !== TagHex.Item)) {
+                _context9.next = 3;
+                break;
+              }
+              throw new Error("Offsets tag is missing: ".concat(tagInfo.tag));
+            case 3:
+              if (!(tagInfo.length === 0)) {
+                _context9.next = 5;
+                break;
+              }
+              return _context9.abrupt("return");
+            case 5:
+              offsets = [];
+              numOfFrames = tagInfo.length / 4;
+              _context9.next = 9;
+              return this.stream.ensureAvailable(tagInfo.length);
+            case 9:
+              for (i = 0; i < numOfFrames; i++) {
+                offsets.push(this.stream.readUint32());
+              }
+              return _context9.abrupt("return", offsets);
+            case 11:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this);
+      }));
+      function readOffsets() {
+        return _readOffsets.apply(this, arguments);
+      }
+      return readOffsets;
+    }()
+    /**
+     * Reads uncompressed pixel data, delivering it to the listener streaming it.
+     */
+  }, {
+    key: "readUncompressed",
+    value: (function () {
+      var _readUncompressed = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee0(tagInfo) {
+        var _listener$information2;
+        var length, listener, numberOfFrames, frameLength, _listener$information3, _listener$information4, _listener$information5, _listener$information6, rows, cols, samplesPerPixel, bitsAllocated, bitsPerFrame, frameNumber;
+        return _regeneratorRuntime().wrap(function _callee0$(_context0) {
+          while (1) switch (_context0.prev = _context0.next) {
+            case 0:
+              length = tagInfo.length;
+              listener = this.listener;
+              numberOfFrames = parseInt(((_listener$information2 = listener.information) === null || _listener$information2 === void 0 ? void 0 : _listener$information2.numberOfFrames) || 1);
+              frameLength = length;
+              if (!(numberOfFrames > 1)) {
+                _context0.next = 17;
+                break;
+              }
+              rows = (_listener$information3 = listener.information) === null || _listener$information3 === void 0 ? void 0 : _listener$information3.rows;
+              cols = (_listener$information4 = listener.information) === null || _listener$information4 === void 0 ? void 0 : _listener$information4.columns;
+              samplesPerPixel = (_listener$information5 = listener.information) === null || _listener$information5 === void 0 ? void 0 : _listener$information5.samplesPerPixel;
+              bitsAllocated = (_listener$information6 = listener.information) === null || _listener$information6 === void 0 ? void 0 : _listener$information6.bitsAllocated;
+              bitsPerFrame = rows * cols * samplesPerPixel * bitsAllocated;
+              if (!(bitsPerFrame % 8 !== 0)) {
+                _context0.next = 16;
+                break;
+              }
+              if (!(bitsAllocated === 1)) {
+                _context0.next = 15;
+                break;
+              }
+              _context0.next = 14;
+              return this.readUncompressedBitFrame(tagInfo);
+            case 14:
+              return _context0.abrupt("return", _context0.sent);
+            case 15:
+              throw new Error("Odd frame length must be single bit: ".concat(rows, ",").concat(cols, " ").concat(samplesPerPixel, " ").concat(bitsAllocated));
+            case 16:
+              frameLength = bitsPerFrame / 8;
+            case 17:
+              frameNumber = 0;
+            case 18:
+              if (!(frameNumber < numberOfFrames)) {
+                _context0.next = 26;
+                break;
+              }
+              listener.startObject([]);
+              _context0.next = 22;
+              return this._emitSplitValues(frameLength);
+            case 22:
+              listener.pop();
+              // console.log(stream.getBufferMemoryInfo());
+            case 23:
+              frameNumber++;
+              _context0.next = 18;
+              break;
+            case 26:
+            case "end":
+              return _context0.stop();
+          }
+        }, _callee0, this);
+      }));
+      function readUncompressed(_x8) {
+        return _readUncompressed.apply(this, arguments);
+      }
+      return readUncompressed;
+    }()
+    /**
+     * Reads uncompressed pixel data with support for odd frame lengths (in bits).
+     * This method handles cases where frames are packed sequentially bit-by-bit,
+     * without restarting at byte boundaries. Each frame is unpacked starting at byte 0.
+     *
+     * For odd-length bit frames:
+     * - bitsAllocated is always 1 (single bit per pixel)
+     * - rows * cols * samplesPerPixel is not a multiple of 8
+     * - Frames are packed sequentially into bits without byte alignment
+     * - Each frame is unpacked to start at byte 0
+     *
+     * @param {Object} tagInfo - Tag information containing length and other metadata
+     */
+    )
   }, {
-    key: "xyz2LAB",
-    value: function xyz2LAB(xyz) {
-      var whitePoint = Colors.d65WhitePointXYZ();
-      var X = xyz[0] / whitePoint[0];
-      var Y = xyz[1] / whitePoint[1];
-      var Z = xyz[2] / whitePoint[2];
-      X = Colors.labf(X);
-      Y = Colors.labf(Y);
-      Z = Colors.labf(Z);
-      return [116 * Y - 16, 500 * (X - Y), 200 * (Y - Z)];
-    }
+    key: "readUncompressedBitFrame",
+    value: (function () {
+      var _readUncompressedBitFrame = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee1(tagInfo) {
+        var _listener$information7, _listener$information8, _listener$information9, _listener$information0, _listener$information1;
+        var length, listener, stream, numberOfFrames, rows, cols, samplesPerPixel, bitsAllocated, bitsPerFrame, bytesPerFrame, totalBits, totalBytes, allPixelData, frameNumber, bitOffset, frameBuffer, frameView, sourceView, bitIndex, globalBitIndex, sourceByteIndex, sourceBitIndex, targetByteIndex, targetBitIndex, sourceByte, bitValue;
+        return _regeneratorRuntime().wrap(function _callee1$(_context1) {
+          while (1) switch (_context1.prev = _context1.next) {
+            case 0:
+              length = tagInfo.length;
+              listener = this.listener, stream = this.stream;
+              numberOfFrames = parseInt(((_listener$information7 = listener.information) === null || _listener$information7 === void 0 ? void 0 : _listener$information7.numberOfFrames) || 1);
+              rows = (_listener$information8 = listener.information) === null || _listener$information8 === void 0 ? void 0 : _listener$information8.rows;
+              cols = (_listener$information9 = listener.information) === null || _listener$information9 === void 0 ? void 0 : _listener$information9.columns;
+              samplesPerPixel = ((_listener$information0 = listener.information) === null || _listener$information0 === void 0 ? void 0 : _listener$information0.samplesPerPixel) || 1;
+              bitsAllocated = (_listener$information1 = listener.information) === null || _listener$information1 === void 0 ? void 0 : _listener$information1.bitsAllocated;
+              if (!(!rows || !cols || !bitsAllocated)) {
+                _context1.next = 9;
+                break;
+              }
+              throw new Error("Missing required pixel data information: rows, columns, or bitsAllocated");
+            case 9:
+              if (!(bitsAllocated !== 1)) {
+                _context1.next = 11;
+                break;
+              }
+              throw new Error("Odd-length bit frames require bitsAllocated=1, got ".concat(bitsAllocated));
+            case 11:
+              bitsPerFrame = rows * cols * samplesPerPixel * bitsAllocated;
+              bytesPerFrame = Math.ceil(bitsPerFrame / 8);
+              totalBits = bitsPerFrame * numberOfFrames;
+              totalBytes = Math.ceil(totalBits / 8);
+              if (!(totalBytes !== length)) {
+                _context1.next = 17;
+                break;
+              }
+              throw new Error("The calculated length ".concat(totalBytes, " does not match the actual length ").concat(length));
+            case 17:
+              _context1.next = 19;
+              return stream.ensureAvailable(length);
+            case 19:
+              allPixelData = stream.readArrayBuffer(totalBytes);
+              stream.consume();
+
+              // Extract each frame, unpacking bits so each frame starts at byte 0
+              for (frameNumber = 0; frameNumber < numberOfFrames; frameNumber++) {
+                listener.startObject([]);
+
+                // Calculate the bit offset for this frame in the packed data
+                bitOffset = frameNumber * bitsPerFrame; // Create a buffer for this frame (starting at byte 0)
+                frameBuffer = new ArrayBuffer(bytesPerFrame);
+                frameView = new Uint8Array(frameBuffer);
+                sourceView = new Uint8Array(allPixelData); // Extract bits for this frame
+                for (bitIndex = 0; bitIndex < bitsPerFrame; bitIndex++) {
+                  globalBitIndex = bitOffset + bitIndex;
+                  sourceByteIndex = Math.floor(globalBitIndex / 8);
+                  sourceBitIndex = globalBitIndex % 8;
+                  targetByteIndex = Math.floor(bitIndex / 8);
+                  targetBitIndex = bitIndex % 8; // Read the bit from source
+                  sourceByte = sourceView[sourceByteIndex];
+                  bitValue = sourceByte >> 7 - sourceBitIndex & 1; // Write the bit to target (starting at byte 0)
+                  if (bitValue) {
+                    frameView[targetByteIndex] |= 1 << 7 - targetBitIndex;
+                  }
+                }
+
+                // Deliver the frame buffer
+                listener.value(frameBuffer);
+                listener.pop();
+              }
+            case 22:
+            case "end":
+              return _context1.stop();
+          }
+        }, _callee1, this);
+      }));
+      function readUncompressedBitFrame(_x9) {
+        return _readUncompressedBitFrame.apply(this, arguments);
+      }
+      return readUncompressedBitFrame;
+    }()
+    /**
+     * Reads raw binary data in chunks and delivers it to the listener.
+     * This method reads data in 64KB chunks to manage memory efficiently.
+     */
+    )
   }, {
-    key: "lab2RGB",
-    value: function lab2RGB(lab) {
-      return Colors.xyz2RGB(Colors.lab2XYZ(lab));
-    }
+    key: "readRawBinary",
+    value: (function () {
+      var _readRawBinary = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee10(tagInfo) {
+        var length;
+        return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              length = tagInfo.length;
+              this._emitSplitValues(length);
+            case 2:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10, this);
+      }));
+      function readRawBinary(_x0) {
+        return _readRawBinary.apply(this, arguments);
+      }
+      return readRawBinary;
+    }())
   }, {
-    key: "lab2XYZ",
-    value: function lab2XYZ(lab) {
-      var L = (lab[0] + 16) / 116;
-      var a = L + lab[1] / 500;
-      var b = L - lab[2] / 200;
-      var whitePoint = Colors.d65WhitePointXYZ();
-      return [whitePoint[0] * Colors.labfInv(a), whitePoint[1] * Colors.labfInv(L), whitePoint[2] * Colors.labfInv(b)];
+    key: "isSequence",
+    value: function isSequence(tagInfo) {
+      var vr = tagInfo.vr,
+        length = tagInfo.length;
+      return vr === "SQ" || vr === "UN" && length === UNDEFINED_LENGTH_FIX;
     }
-  }, {
-    key: "xyz2RGB",
-    value: function xyz2RGB(xyz) {
-      var R1 = 3.2406 * xyz[0] - 1.5372 * xyz[1] - 0.4986 * xyz[2];
-      var G1 = -0.9689 * xyz[0] + 1.8758 * xyz[1] + 0.0415 * xyz[2];
-      var B1 = 0.0557 * xyz[0] - 0.204 * xyz[1] + 1.057 * xyz[2];
-
-      /* Force nonnegative values so that gamma correction is well-defined. */
-      var minimumComponent = Math.min(R1, G1);
-      minimumComponent = Math.min(minimumComponent, B1);
-      if (minimumComponent < 0) {
-        R1 -= minimumComponent;
-        G1 -= minimumComponent;
-        B1 -= minimumComponent;
-      }
 
-      /* Transform from RGB to R'G'B' */
-      return [Colors.gammaCorrection(R1), Colors.gammaCorrection(G1), Colors.gammaCorrection(B1)];
-    }
+    /**
+     * Reads a tag header.
+     */
   }, {
-    key: "labf",
-    value: function labf(n) {
-      if (n >= 8.85645167903563082e-3) {
-        return Math.pow(n, 0.333333333333333);
+    key: "readTagHeader",
+    value: function readTagHeader() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+        untilTag: null,
+        includeUntilTagValue: false
+      };
+      var stream = this.stream,
+        syntax = this.syntax;
+      var untilTag = options.untilTag,
+        includeUntilTagValue = options.includeUntilTagValue;
+      var implicit = syntax == IMPLICIT_LITTLE_ENDIAN;
+      var isLittleEndian = syntax !== EXPLICIT_BIG_ENDIAN;
+      stream.setEndian(isLittleEndian);
+      var tagObj = Tag.readTag(stream);
+      var tag = tagObj.cleanString;
+      if (untilTag && untilTag === tag) {
+        if (!includeUntilTagValue) {
+          return {
+            tag: tag,
+            tagObj: tagObj,
+            vr: 0,
+            values: 0,
+            untilTag: true
+          };
+        }
+      }
+      var length = null;
+      var vr = null;
+      var vrType;
+      var isCommand = tagObj.group() === 0;
+      if (tagObj.isInstruction()) {
+        length = stream.readUint32();
+        vr = ValueRepresentation.createByTypeString("UN");
+      } else if (implicit && !isCommand) {
+        length = stream.readUint32();
+        var elementData = DicomMessage.lookupTag(tagObj);
+        if (elementData) {
+          vrType = elementData.vr;
+        } else {
+          //unknown tag
+          if (length == UNDEFINED_LENGTH) {
+            vrType = "SQ";
+          } else if (tagObj.isPixelDataTag()) {
+            vrType = "OW";
+          } else if (vrType == "xs") {
+            var _this$listener$inform;
+            // This should work for any tag after PixelRepresentation,
+            // which is all but 2 of the xs code values.
+            var signed = ((_this$listener$inform = this.listener.information) === null || _this$listener$inform === void 0 ? void 0 : _this$listener$inform.pixelRepresentation) === 0;
+            vrType = signed ? "SS" : "US";
+          } else if (tagObj.isPrivateCreator()) {
+            vrType = "LO";
+          } else {
+            vrType = "UN";
+          }
+        }
+        vr = ValueRepresentation.createByTypeString(vrType);
       } else {
-        return 841.0 / 108.0 * n + 4.0 / 29.0;
+        var _DicomMessage$lookupT;
+        vrType = stream.readVR();
+        if (vrType === "UN" && (_DicomMessage$lookupT = DicomMessage.lookupTag(tagObj)) !== null && _DicomMessage$lookupT !== void 0 && _DicomMessage$lookupT.vr) {
+          vrType = DicomMessage.lookupTag(tagObj).vr;
+          vr = ValueRepresentation.parseUnknownVr(vrType);
+        } else {
+          vr = ValueRepresentation.createByTypeString(vrType);
+        }
+        if (vr.isLength32()) {
+          stream.increment(2);
+          length = stream.readUint32();
+        } else {
+          length = stream.readUint16();
+        }
       }
+      var punctuatedTag = DicomMetaDictionary.punctuateTag(tag);
+      var entry = DicomMetaDictionary.dictionary[punctuatedTag];
+
+      // Include both the string and object values for vr and tag
+      var header = {
+        vrObj: vr,
+        vr: vr.type,
+        tag: tag,
+        tagObj: tagObj,
+        vm: entry === null || entry === void 0 ? void 0 : entry.vm,
+        name: entry === null || entry === void 0 ? void 0 : entry.name,
+        length: length === UNDEFINED_LENGTH ? -1 : length
+      };
+      return header;
     }
+
+    /**
+     * Reads a single tag values and delivers them to the listener.
+     *
+     * If the tag is specific character set, will assign the decoder to that
+     * character set.
+     */
   }, {
-    key: "labfInv",
-    value: function labfInv(n) {
-      if (n >= 0.206896551724137931) {
-        return n * n * n;
-      } else {
-        return 108.0 / 841.0 * (n - 4.0 / 29.0);
+    key: "readSingle",
+    value: (function () {
+      var _readSingle = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee11(tagInfo, listener, options) {
+        var length, stream, syntax, vr, values, times, i, _vr$read, value, _vr$read2, _value, delimiterChar, _values, _values2, coding;
+        return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              length = tagInfo.length;
+              stream = this.stream, syntax = this.syntax;
+              _context11.next = 4;
+              return this.stream.ensureAvailable(length);
+            case 4:
+              vr = ValueRepresentation.createByTypeString(tagInfo.vr);
+              values = [];
+              if (vr.isBinary() && length > vr.maxLength && !vr.noMultiple) {
+                times = length / vr.maxLength;
+                i = 0;
+                while (i++ < times) {
+                  _vr$read = vr.read(stream, vr.maxLength, syntax), value = _vr$read.value;
+                  values.push(value);
+                }
+              } else {
+                _value = (_vr$read2 = vr.read(stream, length, syntax)) === null || _vr$read2 === void 0 ? void 0 : _vr$read2.value;
+                if (!vr.isBinary() && singleVRs.indexOf(vr.type) == -1) {
+                  values = _value;
+                  if (typeof _value === "string") {
+                    delimiterChar = String.fromCharCode(VM_DELIMITER);
+                    values = vr.dropPadByte(_value.split(delimiterChar));
+                  }
+                } else if (vr.type == "OW" || vr.type == "OB") {
+                  values = _value;
+                } else {
+                  Array.isArray(_value) ? values = _value : values.push(_value);
+                }
+              }
+              if (!(tagInfo.tag === TagHex.SpecificCharacterSet)) {
+                _context11.next = 21;
+                break;
+              }
+              if (!(values.length > 0)) {
+                _context11.next = 21;
+                break;
+              }
+              _values = values, _values2 = _slicedToArray(_values, 1), coding = _values2[0];
+              coding = coding.replace(/[_ ]/g, "-").toLowerCase();
+              if (!(coding in encodingMapping)) {
+                _context11.next = 16;
+                break;
+              }
+              coding = encodingMapping[coding];
+              this.stream.setDecoder(new TextDecoder(coding));
+              _context11.next = 21;
+              break;
+            case 16:
+              if (!(options !== null && options !== void 0 && options.ignoreErrors)) {
+                _context11.next = 20;
+                break;
+              }
+              log.warn("Unsupported character set: ".concat(coding, ", using default character set"));
+              _context11.next = 21;
+              break;
+            case 20:
+              throw Error("Unsupported character set: ".concat(coding));
+            case 21:
+              values.forEach(function (value) {
+                return listener.value(value);
+              });
+              return _context11.abrupt("return", values);
+            case 23:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11, this);
+      }));
+      function readSingle(_x1, _x10, _x11) {
+        return _readSingle.apply(this, arguments);
       }
-    }
+      return readSingle;
+    }())
   }]);
-  return Colors;
+  return AsyncDicomReader;
 }();
 
 function datasetToDict(dataset) {
@@ -22629,106 +24296,86 @@ var message = {
 };
 
 /**
- * A DICOM Metadata listener implements the basic listener for creating a dicom
- * metadata instance from a stream of notification events.
+ * A filter for DicomMetadataListener that converts ArrayBuffer[] child values
+ * into expanded listener.startObject([]) and value(fragment) calls.
  *
- * There are additional listeners defined in @cornerstonejs/metadata as well as
- * other event sources in that package.
+ * This is useful when you have compressed or fragmented pixel data delivered
+ * as an array of ArrayBuffers and want to process each fragment individually
+ * through the standard listener sequence pattern.
  *
- * **WARNING** This class is still under development, do not count on the API
- * not changing a bit over the next few dcmjs releases.
+ * @example
+ * // Use as a filter in DicomMetadataListener constructor
+ * const listener = new DicomMetadataListener(ArrayBufferExpanderFilter);
+ * await reader.readFile({ listener });
+ *
+ * @example
+ * // Combine with other filters
+ * const listener = new DicomMetadataListener(
+ *   ArrayBufferExpanderFilter,
+ *   myCustomFilter
+ * );
  */
-var DicomMetadataListener = /*#__PURE__*/function () {
-  function DicomMetadataListener() {
-    _classCallCheck(this, DicomMetadataListener);
-    _defineProperty(this, "current", null);
-    _defineProperty(this, "fmi", null);
-    _defineProperty(this, "dict", null);
-  }
-  _createClass(DicomMetadataListener, [{
-    key: "addTag",
-    value:
-    /**
-     * Adds a new tag value
-     */
-    function addTag(tag, tagInfo) {
-      var dest = {
-        vr: tagInfo === null || tagInfo === void 0 ? void 0 : tagInfo.vr,
-        Value: null
-      };
-      if (this.current.dest) {
-        this.current.dest[tag] = dest;
-      }
-      this.current = {
-        parent: this.current,
-        dest: dest,
-        type: tag
-      };
-    }
-
-    /**
-     * Starts a new object, using the provided value
-     */
-  }, {
-    key: "startObject",
-    value: function startObject() {
-      var dest = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      this.current = {
-        parent: this.current,
-        dest: dest,
-        type: "object"
-      };
-    }
-
-    /**
-     * Starts a new array, using the provided value
-     */
-  }, {
-    key: "startArray",
-    value: function startArray() {
-      var dest = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-      this.current = {
-        parent: this.current,
-        dest: dest,
-        type: "array"
-      };
-    }
-
-    /**
-     * Pops the current value being created off the stack.
-     */
-  }, {
-    key: "pop",
-    value: function pop() {
-      var _this$current$pop, _this$current$pop2, _this$current;
-      var result = (_this$current$pop = (_this$current$pop2 = (_this$current = this.current).pop) === null || _this$current$pop2 === void 0 ? void 0 : _this$current$pop2.call(_this$current)) !== null && _this$current$pop !== void 0 ? _this$current$pop : this.current.dest;
-      this.current = this.current.parent;
-      return result;
-    }
+var ArrayBufferExpanderFilter = {
+  /**
+   * Filter method that intercepts value calls to expand ArrayBuffer[] into
+   * individual fragments.
+   *
+   * When the value is an array where every element is an ArrayBuffer:
+   * 1. Saves the current tag context
+   * 2. Calls this.startObject([]) to create a new array context
+   * 3. Calls this.value(fragment) for each ArrayBuffer in the array
+   * 4. Calls this.pop() to get the resulting array
+   * 5. Assigns that array to the tag's Value field
+   *
+   * This is necessary because when AsyncDicomReader delivers ArrayBuffer[]
+   * directly to value(), it does not call startObject/pop around them, so we
+   * must make those calls to properly represent the array structure.
+   *
+   * Otherwise, it passes the value through unchanged to the next filter.
+   *
+   * @param {Function} next - The next function in the filter chain
+   * @param {*} v - The value to process
+   */
+  value: function value(next, v) {
+    // Check if the value is an array of ArrayBuffers
+    if (Array.isArray(v) && v.length > 0 && v.every(function (item) {
+      return item instanceof ArrayBuffer || ArrayBuffer.isView(item);
+    })) {
+      // Expand the ArrayBuffer[] into the proper sequence
+      // The reader hasn't called startObject for this, so we must
+
+      // Save the current tag context
+      var tagContext = this.current;
+
+      // Call startObject with an array to create a new array context
+      this.startObject([]);
+
+      // Add each fragment
+      var _iterator = _createForOfIteratorHelper(v),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var fragment = _step.value;
+          this.value(fragment);
+        }
 
-    /**
-     * Registers a new value for the current destination being created
-     */
-  }, {
-    key: "value",
-    value: function value(v) {
-      var _this$current$dest;
-      (_this$current$dest = this.current.dest).Value || (_this$current$dest.Value = []);
-      this.current.dest.Value.push(v);
-    }
+        // Pop to get the resulting array structure
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      var arrayResult = this.pop();
 
-    /**
-     * Reads the Value[0] instance of the given tag for pixel data parsing.
-     */
-  }, {
-    key: "getValue",
-    value: function getValue(tag) {
-      var _this$current$parent$;
-      return (_this$current$parent$ = this.current.parent[tag]) === null || _this$current$parent$ === void 0 || (_this$current$parent$ = _this$current$parent$.Value) === null || _this$current$parent$ === void 0 ? void 0 : _this$current$parent$[0];
+      // Now we're back in the tag context - assign the array to Value
+      // The arrayResult will have a Value property with the fragments
+      tagContext.dest.Value = arrayResult.Value || arrayResult;
+    } else {
+      // Pass through non-ArrayBuffer[] values unchanged
+      next(v);
     }
-  }]);
-  return DicomMetadataListener;
-}();
+  }
+};
 
 var utilities = {
   TID1500: TID1500,
@@ -22738,7 +24385,11 @@ var utilities = {
   orientation: orientation,
   compression: compression,
   dicomJson: dicomJson,
-  DicomMetadataListener: DicomMetadataListener
+  DicomMetadataListener: DicomMetadataListener,
+  ArrayBufferExpanderFilter: ArrayBufferExpanderFilter,
+  toFloat: toFloat,
+  toInt: toInt,
+  createInformationFilter: createInformationFilter
 };
 
 var _value = Symbol("value");
@@ -25382,6 +27033,9 @@ var data = {
   datasetToBuffer: datasetToBuffer,
   datasetToBlob: datasetToBlob
 };
+var async = {
+  AsyncDicomReader: AsyncDicomReader
+};
 var derivations = {
   DerivedDataset: DerivedDataset,
   DerivedPixels: DerivedPixels,
@@ -25408,18 +27062,20 @@ var anonymizer = {
 var dcmjs = {
   DICOMWEB: DICOMWEB,
   adapters: adapters,
+  constants: constants,
   data: data,
   derivations: derivations,
   normalizers: normalizers,
   sr: sr,
   utilities: utilities,
   log: log,
-  anonymizer: anonymizer
+  anonymizer: anonymizer,
+  async: async
 };
 DicomDict.setDicomMessageClass(DicomMessage);
 ValueRepresentation.setDicomMessageClass(DicomMessage);
 ValueRepresentation.setTagClass(Tag);
 Tag.setDicomMessageClass(DicomMessage);
 
-export { DICOMWEB, adapters, anonymizer, data, dcmjs as default, derivations, log, normalizers, sr, utilities };
+export { DICOMWEB, adapters, anonymizer, async, constants, data, dcmjs as default, derivations, log, normalizers, sr, utilities };
 //# sourceMappingURL=dcmjs.es.js.map