dcmjs 0.33.1 → 0.34.0

package/build/dcmjs.es.js

@@ -8502,7 +8502,7 @@ function toWindows(inputArray, size) {
 
 var DicomMessage$3, Tag$1;
 var binaryVRs = ["FL", "FD", "SL", "SS", "UL", "US", "AT"],
-  explicitVRs = ["OB", "OW", "OF", "SQ", "UC", "UR", "UT", "UN"],
+  explicitVRs = ["OB", "OW", "OF", "SQ", "UC", "UR", "UT", "UN", "OD"],
   singleVRs$1 = ["SQ", "OF", "OW", "OB", "UN"];
 var ValueRepresentation = /*#__PURE__*/function () {
   function ValueRepresentation(type) {
@@ -8512,6 +8512,7 @@ var ValueRepresentation = /*#__PURE__*/function () {
     this._isBinary = binaryVRs.indexOf(this.type) != -1;
     this._allowMultiple = !this._isBinary && singleVRs$1.indexOf(this.type) == -1;
     this._isExplicit = explicitVRs.indexOf(this.type) != -1;
+    this._storeRaw = true;
   }
   _createClass(ValueRepresentation, [{
     key: "isBinary",
@@ -8528,6 +8529,19 @@ var ValueRepresentation = /*#__PURE__*/function () {
     value: function isExplicit() {
       return this._isExplicit;
     }
+
+    /**
+     * Flag that specifies whether to store the original unformatted value that is read from the dicom input buffer.
+     * The `_rawValue` is used for lossless round trip processing, which preserves data (whitespace, special chars) on write
+     * that may be lost after casting to other data structures like Number, or applying formatting for readability.
+     *
+     * Example DecimalString: _rawValue: ["-0.000"], Value: [0]
+     */
+  }, {
+    key: "storeRaw",
+    value: function storeRaw() {
+      return this._storeRaw;
+    }
   }, {
     key: "addValueAccessors",
     value: function addValueAccessors(value) {
@@ -8544,11 +8558,29 @@ var ValueRepresentation = /*#__PURE__*/function () {
   }, {
     key: "read",
     value: function read(stream, length, syntax) {
+      var readOptions = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {
+        forceStoreRaw: false
+      };
       if (this.fixed && this.maxLength) {
         if (!length) return this.defaultValue;
         if (this.maxLength != length) log.error("Invalid length for fixed length tag, vr " + this.type + ", length " + this.maxLength + " != " + length);
       }
-      return this.readBytes(stream, length, syntax);
+      var rawValue = this.readBytes(stream, length, syntax);
+      var value = this.applyFormatting(rawValue);
+
+      // avoid duplicating large binary data structures like pixel data which are unlikely to be formatted or directly manipulated
+      if (!this.storeRaw() && !readOptions.forceStoreRaw) {
+        rawValue = undefined;
+      }
+      return {
+        rawValue: rawValue,
+        value: value
+      };
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      return value;
     }
   }, {
     key: "readBytes",
@@ -8759,8 +8791,11 @@ var BinaryRepresentation = /*#__PURE__*/function (_ValueRepresentation3) {
   _inherits(BinaryRepresentation, _ValueRepresentation3);
   var _super3 = _createSuper(BinaryRepresentation);
   function BinaryRepresentation(type) {
+    var _this;
     _classCallCheck(this, BinaryRepresentation);
-    return _super3.call(this, type);
+    _this = _super3.call(this, type);
+    _this._storeRaw = false;
+    return _this;
   }
   _createClass(BinaryRepresentation, [{
     key: "writeBytes",
@@ -8961,17 +8996,22 @@ var ApplicationEntity = /*#__PURE__*/function (_AsciiStringRepresent) {
   _inherits(ApplicationEntity, _AsciiStringRepresent);
   var _super4 = _createSuper(ApplicationEntity);
   function ApplicationEntity() {
-    var _this;
+    var _this2;
     _classCallCheck(this, ApplicationEntity);
-    _this = _super4.call(this, "AE");
-    _this.maxLength = 16;
-    _this.padByte = PADDING_SPACE;
-    return _this;
+    _this2 = _super4.call(this, "AE");
+    _this2.maxLength = 16;
+    _this2.padByte = PADDING_SPACE;
+    return _this2;
   }
   _createClass(ApplicationEntity, [{
     key: "readBytes",
     value: function readBytes(stream, length) {
-      return stream.readAsciiString(length).trim();
+      return stream.readAsciiString(length);
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      return value.trim();
     }
   }]);
   return ApplicationEntity;
@@ -8980,17 +9020,31 @@ var CodeString = /*#__PURE__*/function (_AsciiStringRepresent2) {
   _inherits(CodeString, _AsciiStringRepresent2);
   var _super5 = _createSuper(CodeString);
   function CodeString() {
-    var _this2;
+    var _this3;
     _classCallCheck(this, CodeString);
-    _this2 = _super5.call(this, "CS");
-    _this2.maxLength = 16;
-    _this2.padByte = PADDING_SPACE;
-    return _this2;
+    _this3 = _super5.call(this, "CS");
+    _this3.maxLength = 16;
+    _this3.padByte = PADDING_SPACE;
+    return _this3;
   }
   _createClass(CodeString, [{
     key: "readBytes",
     value: function readBytes(stream, length) {
-      return stream.readAsciiString(length).trim();
+      var BACKSLASH = String.fromCharCode(VM_DELIMITER);
+      return stream.readAsciiString(length).split(BACKSLASH);
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      var trim = function trim(str) {
+        return str.trim();
+      };
+      if (Array.isArray(value)) {
+        return value.map(function (str) {
+          return trim(str);
+        });
+      }
+      return trim(value);
     }
   }]);
   return CodeString;
@@ -8999,14 +9053,14 @@ var AgeString = /*#__PURE__*/function (_AsciiStringRepresent3) {
   _inherits(AgeString, _AsciiStringRepresent3);
   var _super6 = _createSuper(AgeString);
   function AgeString() {
-    var _this3;
+    var _this4;
     _classCallCheck(this, AgeString);
-    _this3 = _super6.call(this, "AS");
-    _this3.maxLength = 4;
-    _this3.padByte = PADDING_SPACE;
-    _this3.fixed = true;
-    _this3.defaultValue = "";
-    return _this3;
+    _this4 = _super6.call(this, "AS");
+    _this4.maxLength = 4;
+    _this4.padByte = PADDING_SPACE;
+    _this4.fixed = true;
+    _this4.defaultValue = "";
+    return _this4;
   }
   return _createClass(AgeString);
 }(AsciiStringRepresentation);
@@ -9014,14 +9068,14 @@ var AttributeTag = /*#__PURE__*/function (_ValueRepresentation4) {
   _inherits(AttributeTag, _ValueRepresentation4);
   var _super7 = _createSuper(AttributeTag);
   function AttributeTag() {
-    var _this4;
+    var _this5;
     _classCallCheck(this, AttributeTag);
-    _this4 = _super7.call(this, "AT");
-    _this4.maxLength = 4;
-    _this4.valueLength = 4;
-    _this4.padByte = PADDING_NULL;
-    _this4.fixed = true;
-    return _this4;
+    _this5 = _super7.call(this, "AT");
+    _this5.maxLength = 4;
+    _this5.valueLength = 4;
+    _this5.padByte = PADDING_NULL;
+    _this5.fixed = true;
+    return _this5;
   }
   _createClass(AttributeTag, [{
     key: "readBytes",
@@ -9040,14 +9094,14 @@ var DateValue = /*#__PURE__*/function (_AsciiStringRepresent4) {
   _inherits(DateValue, _AsciiStringRepresent4);
   var _super8 = _createSuper(DateValue);
   function DateValue(value) {
-    var _this5;
+    var _this6;
     _classCallCheck(this, DateValue);
-    _this5 = _super8.call(this, "DA", value);
-    _this5.maxLength = 18;
-    _this5.padByte = PADDING_SPACE;
+    _this6 = _super8.call(this, "DA", value);
+    _this6.maxLength = 18;
+    _this6.padByte = PADDING_SPACE;
     //this.fixed = true;
-    _this5.defaultValue = "";
-    return _this5;
+    _this6.defaultValue = "";
+    return _this6;
   }
   return _createClass(DateValue);
 }(AsciiStringRepresentation);
@@ -9055,33 +9109,39 @@ var DecimalString = /*#__PURE__*/function (_AsciiStringRepresent5) {
   _inherits(DecimalString, _AsciiStringRepresent5);
   var _super9 = _createSuper(DecimalString);
   function DecimalString() {
-    var _this6;
+    var _this7;
     _classCallCheck(this, DecimalString);
-    _this6 = _super9.call(this, "DS");
-    _this6.maxLength = 16;
-    _this6.padByte = PADDING_SPACE;
-    return _this6;
+    _this7 = _super9.call(this, "DS");
+    _this7.maxLength = 16;
+    _this7.padByte = PADDING_SPACE;
+    return _this7;
   }
   _createClass(DecimalString, [{
     key: "readBytes",
     value: function readBytes(stream, length) {
       var BACKSLASH = String.fromCharCode(VM_DELIMITER);
       var ds = stream.readAsciiString(length);
-      ds = ds.replace(/[^0-9.\\\-+e]/gi, "");
       if (ds.indexOf(BACKSLASH) !== -1) {
         // handle decimal string with multiplicity
-        var dsArray = ds.split(BACKSLASH);
-        ds = dsArray.map(function (ds) {
-          return ds === "" ? null : Number(ds);
-        });
-      } else {
-        ds = [ds === "" ? null : Number(ds)];
+        return ds.split(BACKSLASH);
       }
-      return ds;
+      return [ds];
     }
   }, {
-    key: "formatValue",
-    value: function formatValue(value) {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      var formatNumber = function formatNumber(numberStr) {
+        var returnVal = numberStr.trim().replace(/[^0-9.\\\-+e]/gi, "");
+        return returnVal === "" ? null : Number(returnVal);
+      };
+      if (Array.isArray(value)) {
+        return value.map(formatNumber);
+      }
+      return formatNumber(value);
+    }
+  }, {
+    key: "convertToString",
+    value: function convertToString(value) {
       if (value === null) return "";
       var str = String(value);
       if (str.length > this.maxLength) {
@@ -9116,10 +9176,10 @@ var DecimalString = /*#__PURE__*/function (_AsciiStringRepresent5) {
   }, {
     key: "writeBytes",
     value: function writeBytes(stream, value, writeOptions) {
-      var _this7 = this;
+      var _this8 = this;
       var val = Array.isArray(value) ? value.map(function (ds) {
-        return _this7.formatValue(ds);
-      }) : [this.formatValue(value)];
+        return _this8.convertToString(ds);
+      }) : [this.convertToString(value)];
       return _get(_getPrototypeOf(DecimalString.prototype), "writeBytes", this).call(this, stream, val, writeOptions);
     }
   }]);
@@ -9129,12 +9189,12 @@ var DateTime = /*#__PURE__*/function (_AsciiStringRepresent6) {
   _inherits(DateTime, _AsciiStringRepresent6);
   var _super10 = _createSuper(DateTime);
   function DateTime() {
-    var _this8;
+    var _this9;
     _classCallCheck(this, DateTime);
-    _this8 = _super10.call(this, "DT");
-    _this8.maxLength = 26;
-    _this8.padByte = PADDING_SPACE;
-    return _this8;
+    _this9 = _super10.call(this, "DT");
+    _this9.maxLength = 26;
+    _this9.padByte = PADDING_SPACE;
+    return _this9;
   }
   return _createClass(DateTime);
 }(AsciiStringRepresentation);
@@ -9142,19 +9202,24 @@ var FloatingPointSingle = /*#__PURE__*/function (_ValueRepresentation5) {
   _inherits(FloatingPointSingle, _ValueRepresentation5);
   var _super11 = _createSuper(FloatingPointSingle);
   function FloatingPointSingle() {
-    var _this9;
+    var _this10;
     _classCallCheck(this, FloatingPointSingle);
-    _this9 = _super11.call(this, "FL");
-    _this9.maxLength = 4;
-    _this9.padByte = PADDING_NULL;
-    _this9.fixed = true;
-    _this9.defaultValue = 0.0;
-    return _this9;
+    _this10 = _super11.call(this, "FL");
+    _this10.maxLength = 4;
+    _this10.padByte = PADDING_NULL;
+    _this10.fixed = true;
+    _this10.defaultValue = 0.0;
+    return _this10;
   }
   _createClass(FloatingPointSingle, [{
     key: "readBytes",
     value: function readBytes(stream) {
-      return Number(stream.readFloat());
+      return stream.readFloat();
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      return Number(value);
     }
   }, {
     key: "writeBytes",
@@ -9168,19 +9233,24 @@ var FloatingPointDouble = /*#__PURE__*/function (_ValueRepresentation6) {
   _inherits(FloatingPointDouble, _ValueRepresentation6);
   var _super12 = _createSuper(FloatingPointDouble);
   function FloatingPointDouble() {
-    var _this10;
+    var _this11;
     _classCallCheck(this, FloatingPointDouble);
-    _this10 = _super12.call(this, "FD");
-    _this10.maxLength = 8;
-    _this10.padByte = PADDING_NULL;
-    _this10.fixed = true;
-    _this10.defaultValue = 0.0;
-    return _this10;
+    _this11 = _super12.call(this, "FD");
+    _this11.maxLength = 8;
+    _this11.padByte = PADDING_NULL;
+    _this11.fixed = true;
+    _this11.defaultValue = 0.0;
+    return _this11;
   }
   _createClass(FloatingPointDouble, [{
     key: "readBytes",
     value: function readBytes(stream) {
-      return Number(stream.readDouble());
+      return stream.readDouble();
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      return Number(value);
     }
   }, {
     key: "writeBytes",
@@ -9194,42 +9264,48 @@ var IntegerString = /*#__PURE__*/function (_AsciiStringRepresent7) {
   _inherits(IntegerString, _AsciiStringRepresent7);
   var _super13 = _createSuper(IntegerString);
   function IntegerString() {
-    var _this11;
+    var _this12;
     _classCallCheck(this, IntegerString);
-    _this11 = _super13.call(this, "IS");
-    _this11.maxLength = 12;
-    _this11.padByte = PADDING_SPACE;
-    return _this11;
+    _this12 = _super13.call(this, "IS");
+    _this12.maxLength = 12;
+    _this12.padByte = PADDING_SPACE;
+    return _this12;
   }
   _createClass(IntegerString, [{
     key: "readBytes",
     value: function readBytes(stream, length) {
       var BACKSLASH = String.fromCharCode(VM_DELIMITER);
-      var is = stream.readAsciiString(length).trim();
-      is = is.replace(/[^0-9.\\\-+e]/gi, "");
+      var is = stream.readAsciiString(length);
       if (is.indexOf(BACKSLASH) !== -1) {
         // handle integer string with multiplicity
-        var integerStringArray = is.split(BACKSLASH);
-        is = integerStringArray.map(function (is) {
-          return is === "" ? null : Number(is);
-        });
-      } else {
-        is = [is === "" ? null : Number(is)];
+        return is.split(BACKSLASH);
+      }
+      return [is];
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      var formatNumber = function formatNumber(numberStr) {
+        var returnVal = numberStr.trim().replace(/[^0-9.\\\-+e]/gi, "");
+        return returnVal === "" ? null : Number(returnVal);
+      };
+      if (Array.isArray(value)) {
+        return value.map(formatNumber);
       }
-      return is;
+      return formatNumber(value);
     }
   }, {
-    key: "formatValue",
-    value: function formatValue(value) {
+    key: "convertToString",
+    value: function convertToString(value) {
       return value === null ? "" : String(value);
     }
   }, {
     key: "writeBytes",
     value: function writeBytes(stream, value, writeOptions) {
-      var _this12 = this;
+      var _this13 = this;
       var val = Array.isArray(value) ? value.map(function (is) {
-        return _this12.formatValue(is);
-      }) : [this.formatValue(value)];
+        return _this13.convertToString(is);
+      }) : [this.convertToString(value)];
       return _get(_getPrototypeOf(IntegerString.prototype), "writeBytes", this).call(this, stream, val, writeOptions);
     }
   }]);
@@ -9239,17 +9315,22 @@ var LongString = /*#__PURE__*/function (_EncodedStringReprese) {
   _inherits(LongString, _EncodedStringReprese);
   var _super14 = _createSuper(LongString);
   function LongString() {
-    var _this13;
+    var _this14;
     _classCallCheck(this, LongString);
-    _this13 = _super14.call(this, "LO");
-    _this13.maxCharLength = 64;
-    _this13.padByte = PADDING_SPACE;
-    return _this13;
+    _this14 = _super14.call(this, "LO");
+    _this14.maxCharLength = 64;
+    _this14.padByte = PADDING_SPACE;
+    return _this14;
   }
   _createClass(LongString, [{
     key: "readBytes",
     value: function readBytes(stream, length) {
-      return stream.readEncodedString(length).trim();
+      return stream.readEncodedString(length);
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      return value.trim();
     }
   }]);
   return LongString;
@@ -9258,17 +9339,22 @@ var LongText = /*#__PURE__*/function (_EncodedStringReprese2) {
   _inherits(LongText, _EncodedStringReprese2);
   var _super15 = _createSuper(LongText);
   function LongText() {
-    var _this14;
+    var _this15;
     _classCallCheck(this, LongText);
-    _this14 = _super15.call(this, "LT");
-    _this14.maxCharLength = 10240;
-    _this14.padByte = PADDING_SPACE;
-    return _this14;
+    _this15 = _super15.call(this, "LT");
+    _this15.maxCharLength = 10240;
+    _this15.padByte = PADDING_SPACE;
+    return _this15;
   }
   _createClass(LongText, [{
     key: "readBytes",
     value: function readBytes(stream, length) {
-      return rtrim(stream.readEncodedString(length));
+      return stream.readEncodedString(length);
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      return rtrim(value);
     }
   }]);
   return LongText;
@@ -9277,12 +9363,12 @@ var PersonName = /*#__PURE__*/function (_EncodedStringReprese3) {
   _inherits(PersonName, _EncodedStringReprese3);
   var _super16 = _createSuper(PersonName);
   function PersonName() {
-    var _this15;
+    var _this16;
     _classCallCheck(this, PersonName);
-    _this15 = _super16.call(this, "PN");
-    _this15.maxLength = null;
-    _this15.padByte = PADDING_SPACE;
-    return _this15;
+    _this16 = _super16.call(this, "PN");
+    _this16.maxLength = null;
+    _this16.padByte = PADDING_SPACE;
+    return _this16;
   }
   _createClass(PersonName, [{
     key: "addValueAccessors",
@@ -9356,8 +9442,20 @@ var PersonName = /*#__PURE__*/function (_EncodedStringReprese3) {
   }, {
     key: "readBytes",
     value: function readBytes(stream, length) {
-      var result = this.readPaddedEncodedString(stream, length);
-      return dicomJson.pnConvertToJsonObject(result);
+      return this.readPaddedEncodedString(stream, length).split(String.fromCharCode(VM_DELIMITER));
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      var parsePersonName = function parsePersonName(valueStr) {
+        return dicomJson.pnConvertToJsonObject(valueStr, false);
+      };
+      if (Array.isArray(value)) {
+        return value.map(function (valueStr) {
+          return parsePersonName(valueStr);
+        });
+      }
+      return parsePersonName(value);
     }
   }, {
     key: "writeBytes",
@@ -9381,17 +9479,22 @@ var ShortString = /*#__PURE__*/function (_EncodedStringReprese4) {
   _inherits(ShortString, _EncodedStringReprese4);
   var _super17 = _createSuper(ShortString);
   function ShortString() {
-    var _this16;
+    var _this17;
     _classCallCheck(this, ShortString);
-    _this16 = _super17.call(this, "SH");
-    _this16.maxCharLength = 16;
-    _this16.padByte = PADDING_SPACE;
-    return _this16;
+    _this17 = _super17.call(this, "SH");
+    _this17.maxCharLength = 16;
+    _this17.padByte = PADDING_SPACE;
+    return _this17;
   }
   _createClass(ShortString, [{
     key: "readBytes",
     value: function readBytes(stream, length) {
-      return stream.readEncodedString(length).trim();
+      return stream.readEncodedString(length);
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      return value.trim();
     }
   }]);
   return ShortString;
@@ -9400,14 +9503,14 @@ var SignedLong = /*#__PURE__*/function (_ValueRepresentation7) {
   _inherits(SignedLong, _ValueRepresentation7);
   var _super18 = _createSuper(SignedLong);
   function SignedLong() {
-    var _this17;
+    var _this18;
     _classCallCheck(this, SignedLong);
-    _this17 = _super18.call(this, "SL");
-    _this17.maxLength = 4;
-    _this17.padByte = PADDING_NULL;
-    _this17.fixed = true;
-    _this17.defaultValue = 0;
-    return _this17;
+    _this18 = _super18.call(this, "SL");
+    _this18.maxLength = 4;
+    _this18.padByte = PADDING_NULL;
+    _this18.fixed = true;
+    _this18.defaultValue = 0;
+    return _this18;
   }
   _createClass(SignedLong, [{
     key: "readBytes",
@@ -9426,13 +9529,14 @@ var SequenceOfItems = /*#__PURE__*/function (_ValueRepresentation8) {
   _inherits(SequenceOfItems, _ValueRepresentation8);
   var _super19 = _createSuper(SequenceOfItems);
   function SequenceOfItems() {
-    var _this18;
+    var _this19;
     _classCallCheck(this, SequenceOfItems);
-    _this18 = _super19.call(this, "SQ");
-    _this18.maxLength = null;
-    _this18.padByte = PADDING_NULL;
-    _this18.noMultiple = true;
-    return _this18;
+    _this19 = _super19.call(this, "SQ");
+    _this19.maxLength = null;
+    _this19.padByte = PADDING_NULL;
+    _this19.noMultiple = true;
+    _this19._storeRaw = false;
+    return _this19;
   }
   _createClass(SequenceOfItems, [{
     key: "readBytes",
@@ -9554,15 +9658,15 @@ var SignedShort = /*#__PURE__*/function (_ValueRepresentation9) {
   _inherits(SignedShort, _ValueRepresentation9);
   var _super20 = _createSuper(SignedShort);
   function SignedShort() {
-    var _this19;
+    var _this20;
     _classCallCheck(this, SignedShort);
-    _this19 = _super20.call(this, "SS");
-    _this19.maxLength = 2;
-    _this19.valueLength = 2;
-    _this19.padByte = PADDING_NULL;
-    _this19.fixed = true;
-    _this19.defaultValue = 0;
-    return _this19;
+    _this20 = _super20.call(this, "SS");
+    _this20.maxLength = 2;
+    _this20.valueLength = 2;
+    _this20.padByte = PADDING_NULL;
+    _this20.fixed = true;
+    _this20.defaultValue = 0;
+    return _this20;
   }
   _createClass(SignedShort, [{
     key: "readBytes",
@@ -9581,17 +9685,22 @@ var ShortText = /*#__PURE__*/function (_EncodedStringReprese5) {
   _inherits(ShortText, _EncodedStringReprese5);
   var _super21 = _createSuper(ShortText);
   function ShortText() {
-    var _this20;
+    var _this21;
     _classCallCheck(this, ShortText);
-    _this20 = _super21.call(this, "ST");
-    _this20.maxCharLength = 1024;
-    _this20.padByte = PADDING_SPACE;
-    return _this20;
+    _this21 = _super21.call(this, "ST");
+    _this21.maxCharLength = 1024;
+    _this21.padByte = PADDING_SPACE;
+    return _this21;
   }
   _createClass(ShortText, [{
     key: "readBytes",
     value: function readBytes(stream, length) {
-      return rtrim(stream.readEncodedString(length));
+      return stream.readEncodedString(length);
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      return rtrim(value);
     }
   }]);
   return ShortText;
@@ -9600,17 +9709,22 @@ var TimeValue = /*#__PURE__*/function (_AsciiStringRepresent8) {
   _inherits(TimeValue, _AsciiStringRepresent8);
   var _super22 = _createSuper(TimeValue);
   function TimeValue() {
-    var _this21;
+    var _this22;
     _classCallCheck(this, TimeValue);
-    _this21 = _super22.call(this, "TM");
-    _this21.maxLength = 14;
-    _this21.padByte = PADDING_SPACE;
-    return _this21;
+    _this22 = _super22.call(this, "TM");
+    _this22.maxLength = 14;
+    _this22.padByte = PADDING_SPACE;
+    return _this22;
   }
   _createClass(TimeValue, [{
     key: "readBytes",
     value: function readBytes(stream, length) {
-      return rtrim(stream.readAsciiString(length));
+      return stream.readAsciiString(length);
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      return rtrim(value);
     }
   }]);
   return TimeValue;
@@ -9619,18 +9733,23 @@ var UnlimitedCharacters = /*#__PURE__*/function (_EncodedStringReprese6) {
   _inherits(UnlimitedCharacters, _EncodedStringReprese6);
   var _super23 = _createSuper(UnlimitedCharacters);
   function UnlimitedCharacters() {
-    var _this22;
+    var _this23;
     _classCallCheck(this, UnlimitedCharacters);
-    _this22 = _super23.call(this, "UC");
-    _this22.maxLength = null;
-    _this22.multi = true;
-    _this22.padByte = PADDING_SPACE;
-    return _this22;
+    _this23 = _super23.call(this, "UC");
+    _this23.maxLength = null;
+    _this23.multi = true;
+    _this23.padByte = PADDING_SPACE;
+    return _this23;
   }
   _createClass(UnlimitedCharacters, [{
     key: "readBytes",
     value: function readBytes(stream, length) {
-      return rtrim(stream.readEncodedString(length));
+      return stream.readEncodedString(length);
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      return rtrim(value);
     }
   }]);
   return UnlimitedCharacters;
@@ -9639,17 +9758,22 @@ var UnlimitedText = /*#__PURE__*/function (_EncodedStringReprese7) {
   _inherits(UnlimitedText, _EncodedStringReprese7);
   var _super24 = _createSuper(UnlimitedText);
   function UnlimitedText() {
-    var _this23;
+    var _this24;
     _classCallCheck(this, UnlimitedText);
-    _this23 = _super24.call(this, "UT");
-    _this23.maxLength = null;
-    _this23.padByte = PADDING_SPACE;
-    return _this23;
+    _this24 = _super24.call(this, "UT");
+    _this24.maxLength = null;
+    _this24.padByte = PADDING_SPACE;
+    return _this24;
   }
   _createClass(UnlimitedText, [{
     key: "readBytes",
     value: function readBytes(stream, length) {
-      return rtrim(stream.readEncodedString(length));
+      return stream.readEncodedString(length);
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      return rtrim(value);
     }
   }]);
   return UnlimitedText;
@@ -9658,14 +9782,14 @@ var UnsignedShort = /*#__PURE__*/function (_ValueRepresentation10) {
   _inherits(UnsignedShort, _ValueRepresentation10);
   var _super25 = _createSuper(UnsignedShort);
   function UnsignedShort() {
-    var _this24;
+    var _this25;
     _classCallCheck(this, UnsignedShort);
-    _this24 = _super25.call(this, "US");
-    _this24.maxLength = 2;
-    _this24.padByte = PADDING_NULL;
-    _this24.fixed = true;
-    _this24.defaultValue = 0;
-    return _this24;
+    _this25 = _super25.call(this, "US");
+    _this25.maxLength = 2;
+    _this25.padByte = PADDING_NULL;
+    _this25.fixed = true;
+    _this25.defaultValue = 0;
+    return _this25;
   }
   _createClass(UnsignedShort, [{
     key: "readBytes",
@@ -9684,14 +9808,14 @@ var UnsignedLong = /*#__PURE__*/function (_ValueRepresentation11) {
   _inherits(UnsignedLong, _ValueRepresentation11);
   var _super26 = _createSuper(UnsignedLong);
   function UnsignedLong() {
-    var _this25;
+    var _this26;
     _classCallCheck(this, UnsignedLong);
-    _this25 = _super26.call(this, "UL");
-    _this25.maxLength = 4;
-    _this25.padByte = PADDING_NULL;
-    _this25.fixed = true;
-    _this25.defaultValue = 0;
-    return _this25;
+    _this26 = _super26.call(this, "UL");
+    _this26.maxLength = 4;
+    _this26.padByte = PADDING_NULL;
+    _this26.fixed = true;
+    _this26.defaultValue = 0;
+    return _this26;
   }
   _createClass(UnsignedLong, [{
     key: "readBytes",
@@ -9710,19 +9834,18 @@ var UniqueIdentifier = /*#__PURE__*/function (_AsciiStringRepresent9) {
   _inherits(UniqueIdentifier, _AsciiStringRepresent9);
   var _super27 = _createSuper(UniqueIdentifier);
   function UniqueIdentifier() {
-    var _this26;
+    var _this27;
     _classCallCheck(this, UniqueIdentifier);
-    _this26 = _super27.call(this, "UI");
-    _this26.maxLength = 64;
-    _this26.padByte = PADDING_NULL;
-    return _this26;
+    _this27 = _super27.call(this, "UI");
+    _this27.maxLength = 64;
+    _this27.padByte = PADDING_NULL;
+    return _this27;
   }
   _createClass(UniqueIdentifier, [{
     key: "readBytes",
     value: function readBytes(stream, length) {
       var result = this.readPaddedAsciiString(stream, length);
       var BACKSLASH = String.fromCharCode(VM_DELIMITER);
-      var uidRegExp = /[^0-9.]/g;
 
       // Treat backslashes as a delimiter for multiple UIDs, in which case an
       // array of UIDs is returned. This is used by DICOM Q&R to support
@@ -9733,12 +9856,21 @@ var UniqueIdentifier = /*#__PURE__*/function (_AsciiStringRepresent9) {
       // https://dicom.nema.org/medical/dicom/current/output/chtml/part05/sect_6.4.html
 
       if (result.indexOf(BACKSLASH) === -1) {
-        return result.replace(uidRegExp, "");
+        return result;
       } else {
-        return result.split(BACKSLASH).map(function (uid) {
-          return uid.replace(uidRegExp, "");
-        });
+        return result.split(BACKSLASH);
+      }
+    }
+  }, {
+    key: "applyFormatting",
+    value: function applyFormatting(value) {
+      var removeInvalidUidChars = function removeInvalidUidChars(uidStr) {
+        return uidStr.replace(/[^0-9.]/g, "");
+      };
+      if (Array.isArray(value)) {
+        return value.map(removeInvalidUidChars);
       }
+      return removeInvalidUidChars(value);
     }
   }]);
   return UniqueIdentifier;
@@ -9747,12 +9879,12 @@ var UniversalResource = /*#__PURE__*/function (_AsciiStringRepresent10) {
   _inherits(UniversalResource, _AsciiStringRepresent10);
   var _super28 = _createSuper(UniversalResource);
   function UniversalResource() {
-    var _this27;
+    var _this28;
     _classCallCheck(this, UniversalResource);
-    _this27 = _super28.call(this, "UR");
-    _this27.maxLength = null;
-    _this27.padByte = PADDING_SPACE;
-    return _this27;
+    _this28 = _super28.call(this, "UR");
+    _this28.maxLength = null;
+    _this28.padByte = PADDING_SPACE;
+    return _this28;
   }
   _createClass(UniversalResource, [{
     key: "readBytes",
@@ -9766,13 +9898,13 @@ var UnknownValue = /*#__PURE__*/function (_BinaryRepresentation) {
   _inherits(UnknownValue, _BinaryRepresentation);
   var _super29 = _createSuper(UnknownValue);
   function UnknownValue() {
-    var _this28;
+    var _this29;
     _classCallCheck(this, UnknownValue);
-    _this28 = _super29.call(this, "UN");
-    _this28.maxLength = null;
-    _this28.padByte = PADDING_NULL;
-    _this28.noMultiple = true;
-    return _this28;
+    _this29 = _super29.call(this, "UN");
+    _this29.maxLength = null;
+    _this29.padByte = PADDING_NULL;
+    _this29.noMultiple = true;
+    return _this29;
   }
   return _createClass(UnknownValue);
 }(BinaryRepresentation);
@@ -9780,46 +9912,43 @@ var ParsedUnknownValue = /*#__PURE__*/function (_BinaryRepresentation2) {
   _inherits(ParsedUnknownValue, _BinaryRepresentation2);
   var _super30 = _createSuper(ParsedUnknownValue);
   function ParsedUnknownValue(vr) {
-    var _this29;
+    var _this30;
     _classCallCheck(this, ParsedUnknownValue);
-    _this29 = _super30.call(this, vr);
-    _this29.maxLength = null;
-    _this29.padByte = 0;
-    _this29.noMultiple = true;
-    _this29._isBinary = true;
-    _this29._allowMultiple = false;
-    _this29._isExplicit = true;
-    return _this29;
+    _this30 = _super30.call(this, vr);
+    _this30.maxLength = null;
+    _this30.padByte = 0;
+    _this30.noMultiple = true;
+    _this30._isBinary = true;
+    _this30._allowMultiple = false;
+    _this30._isExplicit = true;
+    _this30._storeRaw = true;
+    return _this30;
   }
   _createClass(ParsedUnknownValue, [{
     key: "read",
-    value: function read(stream, length, syntax) {
+    value: function read(stream, length, syntax, readOptions) {
       var arrayBuffer = this.readBytes(stream, length, syntax)[0];
       var streamFromBuffer = new ReadBufferStream(arrayBuffer, true);
       var vr = ValueRepresentation.createByTypeString(this.type);
-      var values = [];
       if (vr.isBinary() && length > vr.maxLength && !vr.noMultiple) {
+        var values = [];
+        var rawValues = [];
         var times = length / vr.maxLength,
           i = 0;
         while (i++ < times) {
-          values.push(vr.read(streamFromBuffer, vr.maxLength, syntax));
+          var _vr$read = vr.read(streamFromBuffer, vr.maxLength, syntax, readOptions),
+            rawValue = _vr$read.rawValue,
+            value = _vr$read.value;
+          rawValues.push(rawValue);
+          values.push(value);
         }
+        return {
+          rawValue: rawValues,
+          value: values
+        };
       } else {
-        var val = vr.read(streamFromBuffer, length, syntax);
-        if (!vr.isBinary() && singleVRs$1.indexOf(vr.type) == -1) {
-          values = val;
-          if (typeof val === "string") {
-            values = val.split(String.fromCharCode(VM_DELIMITER));
-          }
-        } else if (vr.type == "SQ") {
-          values = val;
-        } else if (vr.type == "OW" || vr.type == "OB") {
-          values = val;
-        } else {
-          Array.isArray(val) ? values = val : values.push(val);
-        }
+        return vr.read(streamFromBuffer, length, syntax, readOptions);
       }
-      return values;
     }
   }]);
   return ParsedUnknownValue;
@@ -9828,13 +9957,13 @@ var OtherWordString = /*#__PURE__*/function (_BinaryRepresentation3) {
   _inherits(OtherWordString, _BinaryRepresentation3);
   var _super31 = _createSuper(OtherWordString);
   function OtherWordString() {
-    var _this30;
+    var _this31;
     _classCallCheck(this, OtherWordString);
-    _this30 = _super31.call(this, "OW");
-    _this30.maxLength = null;
-    _this30.padByte = PADDING_NULL;
-    _this30.noMultiple = true;
-    return _this30;
+    _this31 = _super31.call(this, "OW");
+    _this31.maxLength = null;
+    _this31.padByte = PADDING_NULL;
+    _this31.noMultiple = true;
+    return _this31;
   }
   return _createClass(OtherWordString);
 }(BinaryRepresentation);
@@ -9842,13 +9971,13 @@ var OtherByteString = /*#__PURE__*/function (_BinaryRepresentation4) {
   _inherits(OtherByteString, _BinaryRepresentation4);
   var _super32 = _createSuper(OtherByteString);
   function OtherByteString() {
-    var _this31;
+    var _this32;
     _classCallCheck(this, OtherByteString);
-    _this31 = _super32.call(this, "OB");
-    _this31.maxLength = null;
-    _this31.padByte = PADDING_NULL;
-    _this31.noMultiple = true;
-    return _this31;
+    _this32 = _super32.call(this, "OB");
+    _this32.maxLength = null;
+    _this32.padByte = PADDING_NULL;
+    _this32.noMultiple = true;
+    return _this32;
   }
   return _createClass(OtherByteString);
 }(BinaryRepresentation);
@@ -9856,13 +9985,13 @@ var OtherDoubleString = /*#__PURE__*/function (_BinaryRepresentation5) {
   _inherits(OtherDoubleString, _BinaryRepresentation5);
   var _super33 = _createSuper(OtherDoubleString);
   function OtherDoubleString() {
-    var _this32;
+    var _this33;
     _classCallCheck(this, OtherDoubleString);
-    _this32 = _super33.call(this, "OD");
-    _this32.maxLength = null;
-    _this32.padByte = PADDING_NULL;
-    _this32.noMultiple = true;
-    return _this32;
+    _this33 = _super33.call(this, "OD");
+    _this33.maxLength = null;
+    _this33.padByte = PADDING_NULL;
+    _this33.noMultiple = true;
+    return _this33;
   }
   return _createClass(OtherDoubleString);
 }(BinaryRepresentation);
@@ -9870,13 +9999,13 @@ var OtherFloatString = /*#__PURE__*/function (_BinaryRepresentation6) {
   _inherits(OtherFloatString, _BinaryRepresentation6);
   var _super34 = _createSuper(OtherFloatString);
   function OtherFloatString() {
-    var _this33;
+    var _this34;
     _classCallCheck(this, OtherFloatString);
-    _this33 = _super34.call(this, "OF");
-    _this33.maxLength = null;
-    _this33.padByte = PADDING_NULL;
-    _this33.noMultiple = true;
-    return _this33;
+    _this34 = _super34.call(this, "OF");
+    _this34.maxLength = null;
+    _this34.padByte = PADDING_NULL;
+    _this34.noMultiple = true;
+    return _this34;
   }
   return _createClass(OtherFloatString);
 }(BinaryRepresentation); // these VR instances are precreate and are reused for each requested vr/tag
@@ -10097,6 +10226,40 @@ var Tag = /*#__PURE__*/function () {
   return Tag;
 }();
 
+/**
+ * Performs a deep equality check between two objects. Used primarily during DICOM write operations
+ * to determine whether a data element underlying value has changed since it was initially read.
+ *
+ * @param {Object} obj1 - The first object to compare.
+ * @param {Object} obj2 - The second object to compare.
+ * @returns {boolean} - Returns `true` if the structures and values of the objects are deeply equal, `false` otherwise.
+ */
+function deepEqual(obj1, obj2) {
+  // Use Object.is to consider for treatment of `NaN` and signed 0's i.e. `+0` or `-0` in IS/DS
+  if (Object.is(obj1, obj2)) {
+    return true;
+  }
+
+  // expect objects or a null instance if initial check failed
+  if (_typeof(obj1) !== 'object' || _typeof(obj2) !== 'object' || obj1 === null || obj2 === null) {
+    return false;
+  }
+
+  // all keys should match a deep equality check
+  var keys1 = Object.keys(obj1);
+  var keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (var _i = 0, _keys = keys1; _i < _keys.length; _i++) {
+    var key = _keys[_i];
+    if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
 var singleVRs = ["SQ", "OF", "OW", "OB", "UN", "LT"];
 var encodingMapping = {
   "": "iso-8859-1",
@@ -10204,6 +10367,7 @@ var DicomMessage = /*#__PURE__*/function () {
             vr: readInfo.vr.type
           });
           dict[cleanTagString].Value = readInfo.values;
+          dict[cleanTagString]._rawValue = readInfo.rawValues;
           if (untilTag && untilTag === cleanTagString) {
             break;
           }
@@ -10238,7 +10402,8 @@ var DicomMessage = /*#__PURE__*/function () {
         ignoreErrors: false,
         untilTag: null,
         includeUntilTagValue: false,
-        noCopy: false
+        noCopy: false,
+        forceStoreRaw: false
       };
       var stream = new ReadBufferStream(buffer, null, {
           noCopy: options.noCopy
@@ -10288,12 +10453,32 @@ var DicomMessage = /*#__PURE__*/function () {
       sortedTags.forEach(function (tagString) {
         var tag = Tag.fromString(tagString),
           tagObject = jsonObjects[tagString],
-          vrType = tagObject.vr,
-          values = tagObject.Value;
+          vrType = tagObject.vr;
+        var values = DicomMessage._getTagWriteValues(vrType, tagObject);
         written += tag.write(useStream, vrType, values, syntax, writeOptions);
       });
       return written;
     }
+  }, {
+    key: "_getTagWriteValues",
+    value: function _getTagWriteValues(vrType, tagObject) {
+      if (!tagObject._rawValue) {
+        return tagObject.Value;
+      }
+
+      // apply VR specific formatting to the original _rawValue and compare to the Value
+      var vr = ValueRepresentation.createByTypeString(vrType);
+      var originalValue = tagObject._rawValue.map(function (val) {
+        return vr.applyFormatting(val);
+      });
+
+      // if Value has not changed, write _rawValue unformatted back into the file
+      if (deepEqual(tagObject.Value, originalValue)) {
+        return tagObject._rawValue;
+      } else {
+        return tagObject.Value;
+      }
+    }
   }, {
     key: "_readTag",
     value: function _readTag(stream, syntax) {
@@ -10356,25 +10541,37 @@ var DicomMessage = /*#__PURE__*/function () {
         }
       }
       var values = [];
+      var rawValues = [];
       if (vr.isBinary() && length > vr.maxLength && !vr.noMultiple) {
         var times = length / vr.maxLength,
           i = 0;
         while (i++ < times) {
-          values.push(vr.read(stream, vr.maxLength, syntax));
+          var _vr$read = vr.read(stream, vr.maxLength, syntax, options),
+            rawValue = _vr$read.rawValue,
+            value = _vr$read.value;
+          rawValues.push(rawValue);
+          values.push(value);
         }
       } else {
-        var val = vr.read(stream, length, syntax);
+        var _vr$read2 = vr.read(stream, length, syntax, options),
+          _rawValue = _vr$read2.rawValue,
+          _value = _vr$read2.value;
         if (!vr.isBinary() && singleVRs.indexOf(vr.type) == -1) {
-          values = val;
-          if (typeof val === "string") {
-            values = val.split(String.fromCharCode(VM_DELIMITER));
+          rawValues = _rawValue;
+          values = _value;
+          if (typeof _value === "string") {
+            rawValues = _rawValue.split(String.fromCharCode(VM_DELIMITER));
+            values = _value.split(String.fromCharCode(VM_DELIMITER));
           }
         } else if (vr.type == "SQ") {
-          values = val;
+          rawValues = _rawValue;
+          values = _value;
         } else if (vr.type == "OW" || vr.type == "OB") {
-          values = val;
+          rawValues = _rawValue;
+          values = _value;
         } else {
-          Array.isArray(val) ? values = val : values.push(val);
+          Array.isArray(_value) ? values = _value : values.push(_value);
+          Array.isArray(_rawValue) ? rawValues = _rawValue : rawValues.push(_rawValue);
         }
       }
       stream.setEndian(oldEndian);
@@ -10383,6 +10580,7 @@ var DicomMessage = /*#__PURE__*/function () {
         vr: vr
       });
       retObj.values = values;
+      retObj.rawValues = rawValues;
       return retObj;
     }
   }, {