@cosyte/dicom 0.0.10 → 0.0.11

package/dist/index.mjs

@@ -9,7 +9,7 @@ var __export = (target, all) => {
 };
 
 // src/version.ts
-var VERSION = "0.0.10";
+var VERSION = "0.0.11";
 
 // src/dictionary/index.ts
 var dictionary_exports = {};
@@ -11711,11 +11711,14 @@ function isRecognizedVr(vr) {
 // src/parser/warnings.ts
 var WARNING_CODES = {
   // === Phase 2 actively emits (D-08 active list - alphabetical-within-prefix per CONTEXT specifics §) ===
+  DICOM_DUPLICATE_FILE_META_ELEMENT: "DICOM_DUPLICATE_FILE_META_ELEMENT",
+  DICOM_DUPLICATE_TAG_IN_DATA_SET: "DICOM_DUPLICATE_TAG_IN_DATA_SET",
   DICOM_EMPTY_ITEM_IN_SEQUENCE: "DICOM_EMPTY_ITEM_IN_SEQUENCE",
   DICOM_FILE_META_GROUP_LENGTH_MISMATCH: "DICOM_FILE_META_GROUP_LENGTH_MISMATCH",
   DICOM_FILE_META_GROUP_LENGTH_MISSING: "DICOM_FILE_META_GROUP_LENGTH_MISSING",
   DICOM_GROUP_LENGTH_IN_DATASET: "DICOM_GROUP_LENGTH_IN_DATASET",
   DICOM_IMPLICIT_VR_FOR_PRIVATE_TAG_WITHOUT_VR: "DICOM_IMPLICIT_VR_FOR_PRIVATE_TAG_WITHOUT_VR",
+  DICOM_ITEM_CROSSES_SEQUENCE_END: "DICOM_ITEM_CROSSES_SEQUENCE_END",
   DICOM_MISSING_PREAMBLE: "DICOM_MISSING_PREAMBLE",
   DICOM_NONZERO_RESERVED_BYTES: "DICOM_NONZERO_RESERVED_BYTES",
   DICOM_ODD_LENGTH_VALUE_PADDED: "DICOM_ODD_LENGTH_VALUE_PADDED",
@@ -11741,6 +11744,10 @@ var WARNING_CODES = {
   // reserved by Phase 7 - not emitted in Phase 2
   DICOM_DEIDENT_EMBEDDED_ATTRIBUTE_REMOVED: "DICOM_DEIDENT_EMBEDDED_ATTRIBUTE_REMOVED",
   // emitted by deidentify(), never by the parser
+  DICOM_DEIDENT_METHOD_NOT_ADDED: "DICOM_DEIDENT_METHOD_NOT_ADDED",
+  // emitted by deidentify(), never by the parser
+  DICOM_DEIDENT_METHOD_PRIOR_RETAINED: "DICOM_DEIDENT_METHOD_PRIOR_RETAINED",
+  // emitted by deidentify(), never by the parser
   DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE: "DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE",
   // emitted by deidentify(), never by the parser
   DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE: "DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE",
@@ -11765,6 +11772,36 @@ var WARNING_MESSAGES = Object.freeze({
   DICOM_SQ_NOT_DESCENDED: "Element ({tag}) resolved to VR=SQ from the dictionary but its defined-length value is not a valid item stream; kept as opaque bytes and NOT descended, so nothing nested inside it is visible to navigation, and deidentify() cannot audit it. See DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE.",
   DICOM_UN_PARSED_AS_SQ: "Element ({tag}) has VR=UN with undefined length; descended as Implicit VR LE sequence per CP-246.",
   DICOM_EMPTY_ITEM_IN_SEQUENCE: "Sequence ({tag}) contains an empty item (length=0); tolerated.",
+  // Neither the tag nor the replaced element's value is here, and the tag's
+  // absence is specific to this code rather than caution. See
+  // `duplicateTagInDataSet`. Short by measurement rather than by intention: one
+  // is raised per collision and the collision count is chosen by the input, so a
+  // 400-character draft was measured at 50 M characters over a 1 MiB file and
+  // cut. The reasoning lives in the factory's JSDoc, not in the string.
+  DICOM_DUPLICATE_TAG_IN_DATA_SET: "A Data Element carrying a tag this Data Set already holds replaced the earlier one at this byte offset; that element's value is not in the parsed object. PS3.5 7.1 and 7.5.1. Tag withheld.",
+  // The tag is deliberately absent for the same reason as the code above, and
+  // the surviving copy is named because the File Meta group resolves a repeat
+  // the OPPOSITE way round to a Data Set: first copy wins here, last read wins
+  // there. Short for the same measured reason - one is raised per repeat and the
+  // repeat count is chosen by the input.
+  // 🛑 NO SPEC CITATION HERE, AND ITS ABSENCE IS DELIBERATE. A draft ended this
+  // string "PS3.5 7.1.", which asserts that section's "at most once in a Data
+  // Set" governs the File Meta group - the applicability this slice states it
+  // cannot establish, because PS3.10 governs that group and is not vendored
+  // here. Under `{ strict: true }` this string is also the thrown message, so an
+  // unqualified citation there is the claim, not a footnote. Do not put it back.
+  DICOM_DUPLICATE_FILE_META_ELEMENT: "A File Meta Data Element repeats a (0002,xxxx) tag the group already carries; the copy at this byte offset is not in the parsed File Meta, and the FIRST copy of that tag is the one projected. Tag withheld.",
+  // No value and no length: the prior value is the file's own text. The tag is a
+  // constant of this code rather than composed from input, as in the two
+  // (0002,0000) messages above.
+  DICOM_DEIDENT_METHOD_NOT_ADDED: "The De-identification Method this run recorded could not be added beside the value (0012,0063) already carried without exceeding the largest Value Length that VR can encode, so the earlier value was replaced (PS3.15 E.1.1). The replaced text is not in the output.",
+  // No value and no length, for the same reason as the code above: the retained
+  // text is the file's own. The tag is a constant of this code.
+  DICOM_DEIDENT_METHOD_PRIOR_RETAINED: "A De-identification Method (0012,0063) value the source file already carried was kept beside the one this run recorded, as PS3.15 E.1.1 requires. That attribute is not in Table E.1-1, so no rule in this run inspected, audited or redacted those bytes: if the sender wrote identifying text there it is in the de-identified output, under (0012,0062) = YES. The text is withheld from this message.",
+  // The Item's own declared length is deliberately absent. See
+  // `itemCrossesSequenceEnd`; `{n2}` stays because the emit site's
+  // `endLimit < buffer.length` conjunct bounds it by the buffer.
+  DICOM_ITEM_CROSSES_SEQUENCE_END: "Item ({tag}) declares a length reaching past its enclosing sequence's declared end, so it reads the enclosing Data Set's bytes; {n2} bytes remained inside the sequence. The file's two length fields disagree (PS3.5 7.5.1 and 7.5.2 govern them); the item's is used. The declared length is withheld; the byte offset locates the item.",
   DICOM_PIXEL_DATA_LENGTH_MISMATCH: "(7FE0,0010) PixelData declared length {n} does not match computed {n2} bytes.",
   DICOM_IMPLICIT_VR_FOR_PRIVATE_TAG_WITHOUT_VR: "Private element ({tag}) under Implicit VR LE has no VR override; falling back to UN.",
   DICOM_PRIVATE_CREATOR_UNKNOWN: "Private element ({tag}) has a Private Creator the active profile's private dictionary does not name; falling back to UN. The creator string is not reproduced here - read the (gggg,00EE) element if you need it.",
@@ -11849,9 +11886,21 @@ function unParsedAsSQ(position, tag) {
 function sqNotDescended(position, tag) {
   return build(WARNING_CODES.DICOM_SQ_NOT_DESCENDED, position, { tag });
 }
+function itemCrossesSequenceEnd(position, tag, availableLength) {
+  return build(WARNING_CODES.DICOM_ITEM_CROSSES_SEQUENCE_END, position, {
+    tag,
+    n2: availableLength
+  });
+}
 function emptyItemInSequence(position, tag) {
   return build(WARNING_CODES.DICOM_EMPTY_ITEM_IN_SEQUENCE, position, { tag });
 }
+function duplicateTagInDataSet(position) {
+  return build(WARNING_CODES.DICOM_DUPLICATE_TAG_IN_DATA_SET, position);
+}
+function duplicateFileMetaElement(position) {
+  return build(WARNING_CODES.DICOM_DUPLICATE_FILE_META_ELEMENT, position);
+}
 function implicitVRForPrivateTagWithoutVR(position, tag) {
   return build(WARNING_CODES.DICOM_IMPLICIT_VR_FOR_PRIVATE_TAG_WITHOUT_VR, position, { tag });
 }
@@ -11861,6 +11910,12 @@ function privateCreatorUnknown(position, tag) {
 function burnedInAnnotationNotRemoved(position) {
   return build(WARNING_CODES.DICOM_BURNED_IN_ANNOTATION_NOT_REMOVED, position);
 }
+function deidentMethodNotAdded(position) {
+  return build(WARNING_CODES.DICOM_DEIDENT_METHOD_NOT_ADDED, position);
+}
+function deidentMethodPriorRetained(position) {
+  return build(WARNING_CODES.DICOM_DEIDENT_METHOD_PRIOR_RETAINED, position);
+}
 function embeddedAttributeRemoved(position, tag, vr, count) {
   return build(WARNING_CODES.DICOM_DEIDENT_EMBEDDED_ATTRIBUTE_REMOVED, position, {
     tag,
@@ -12155,6 +12210,16 @@ function parseFileMeta(buffer, datasetStart, ctx, emit) {
       fmElements.push(next);
     }
   }
+  const seenModeledTags = /* @__PURE__ */ new Set();
+  if (declaredFmLength !== void 0) seenModeledTags.add("00020000");
+  for (const e of fmElements) {
+    if (!MODELED_FM_TAGS.has(e.tag)) continue;
+    if (seenModeledTags.has(e.tag)) {
+      emit(duplicateFileMetaElement({ byteOffset: e.byteOffset, fileMeta: true }));
+      continue;
+    }
+    seenModeledTags.add(e.tag);
+  }
   const tsElement = fmElements.find((e) => e.tag === "00020010");
   if (tsElement === void 0 || tsElement.vr !== "UI") {
     throw new DicomParseError(
@@ -12201,7 +12266,7 @@ function readExplicitLeElement(cursor) {
   if (bytesConsumed !== headerLength + length) {
     throw new RangeError("File Meta element accounting mismatch");
   }
-  return { tag, vr, value, bytesConsumed };
+  return { tag, vr, value, bytesConsumed, byteOffset: headerStart };
 }
 function trimUI(buf) {
   let end = buf.length;
@@ -12641,6 +12706,14 @@ var Element = class {
   }
 };
 
+// src/parser/data-set-map.ts
+function defineElement(elements, element, emit) {
+  if (elements.has(element.tag)) {
+    emit(duplicateTagInDataSet({ byteOffset: element.byteOffset }));
+  }
+  elements.set(element.tag, element);
+}
+
 // src/dataset/item.ts
 var Item = class extends Dataset {
   index;
@@ -12762,6 +12835,15 @@ function parseSequence(buffer, valueStart, ctx, emit, opts) {
         items.push(new Item({ warnings: [], elements: inner.elements, index: itemIndex }));
         cursor.position = inner.endOffset;
       } else {
+        if (opts.explicitLength !== void 0 && endLimit < buffer.length && cursor.position + itemLength > endLimit) {
+          emit(
+            itemCrossesSequenceEnd(
+              { byteOffset: itemHeaderStart },
+              itemTag,
+              Math.max(0, endLimit - cursor.position)
+            )
+          );
+        }
         if (cursor.position + itemLength > buffer.length) {
           throw new DicomParseError(
             FATAL_CODES.INVALID_FILE_META,
@@ -12897,8 +12979,8 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
         cursor.position = seq.endOffset;
         const rawBytes = ctx.copyValues ? copyValueBytes(buffer.subarray(valueRawStart, cursor.position)) : buffer.subarray(valueRawStart, cursor.position);
         const privateCreator2 = safeModelCreator(resolvePrivateCreator(tag, ctx), ctx);
-        elements.set(
-          tag,
+        defineElement(
+          elements,
           new Element({
             tag,
             vr,
@@ -12909,7 +12991,8 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
             littleEndian: true,
             items: seq.items,
             ...privateCreator2 !== void 0 ? { privateCreator: privateCreator2 } : {}
-          })
+          }),
+          emit
         );
         continue;
       }
@@ -12928,8 +13011,8 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
           cursor.position = cp246.endOffset;
           const rawBytes = ctx.copyValues ? copyValueBytes(buffer.subarray(valueRawStart, cursor.position)) : buffer.subarray(valueRawStart, cursor.position);
           const privateCreator2 = safeModelCreator(resolvePrivateCreator(tag, ctx), ctx);
-          elements.set(
-            tag,
+          defineElement(
+            elements,
             new Element({
               tag,
               vr: "SQ",
@@ -12942,7 +13025,8 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
               littleEndian: true,
               items: cp246.items,
               ...privateCreator2 !== void 0 ? { privateCreator: privateCreator2 } : {}
-            })
+            }),
+            emit
           );
           continue;
         }
@@ -12978,8 +13062,8 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
       );
       if (seq.success) {
         const privateCreator2 = safeModelCreator(resolvePrivateCreator(tag, ctx), ctx);
-        elements.set(
-          tag,
+        defineElement(
+          elements,
           new Element({
             tag,
             vr,
@@ -12990,7 +13074,8 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
             littleEndian: true,
             items: seq.items,
             ...privateCreator2 !== void 0 ? { privateCreator: privateCreator2 } : {}
-          })
+          }),
+          emit
         );
         continue;
       }
@@ -13003,8 +13088,8 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
     }
     applySpecificCharacterSet(tag, valueSlice, ctx, emit, position);
     const privateCreator = safeModelCreator(resolvePrivateCreator(tag, ctx), ctx);
-    elements.set(
-      tag,
+    defineElement(
+      elements,
       new Element({
         tag,
         vr,
@@ -13016,7 +13101,8 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
         littleEndian: true,
         ...ctx.currentCharset !== void 0 ? { specificCharacterSet: ctx.currentCharset } : {},
         ...privateCreator !== void 0 ? { privateCreator } : {}
-      })
+      }),
+      emit
     );
   }
   return { elements, endOffset: cursor.position };
@@ -13123,8 +13209,8 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
       cursor.position = seqResult.endOffset;
       const rawBytes = ctx.copyValues ? copyValueBytes(buffer.subarray(headerStart, cursor.position)) : buffer.subarray(headerStart, cursor.position);
       const privateCreator2 = safeModelCreator(resolvePrivateCreator(tag, ctx), ctx);
-      elements.set(
-        tag,
+      defineElement(
+        elements,
         new Element({
           tag,
           vr: "SQ",
@@ -13135,7 +13221,8 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
           littleEndian: mode.littleEndian,
           items: seqResult.items,
           ...privateCreator2 !== void 0 ? { privateCreator: privateCreator2 } : {}
-        })
+        }),
+        emit
       );
       continue;
     }
@@ -13150,8 +13237,8 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
       const result = parseSequence(buffer, valueStart2, ctx, emit, seqOpts);
       cursor.position = result.endOffset;
       const rawBytes = ctx.copyValues ? copyValueBytes(buffer.subarray(headerStart, cursor.position)) : buffer.subarray(headerStart, cursor.position);
-      elements.set(
-        tag,
+      defineElement(
+        elements,
         new Element({
           tag,
           vr: "OB",
@@ -13162,7 +13249,8 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
           byteOffset: headerStart,
           littleEndian: mode.littleEndian,
           items: result.items
-        })
+        }),
+        emit
       );
       continue;
     }
@@ -13181,8 +13269,8 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
         cursor.position = cp246.endOffset;
         const rawBytes = ctx.copyValues ? copyValueBytes(buffer.subarray(headerStart, cursor.position)) : buffer.subarray(headerStart, cursor.position);
         const privateCreator3 = safeModelCreator(resolvePrivateCreator(tag, ctx), ctx);
-        elements.set(
-          tag,
+        defineElement(
+          elements,
           new Element({
             tag,
             vr: "SQ",
@@ -13195,15 +13283,16 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
             littleEndian: mode.littleEndian,
             items: cp246.items,
             ...privateCreator3 !== void 0 ? { privateCreator: privateCreator3 } : {}
-          })
+          }),
+          emit
         );
         continue;
       }
       const privateCreator2 = safeModelCreator(resolvePrivateCreator(tag, ctx), ctx);
       const fallbackEnd = buffer.length;
       const fallbackBytes = ctx.copyValues ? copyValueBytes(buffer.subarray(headerStart, fallbackEnd)) : buffer.subarray(headerStart, fallbackEnd);
-      elements.set(
-        tag,
+      defineElement(
+        elements,
         new Element({
           tag,
           vr: "UN",
@@ -13213,7 +13302,8 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
           byteOffset: headerStart,
           littleEndian: mode.littleEndian,
           ...privateCreator2 !== void 0 ? { privateCreator: privateCreator2 } : {}
-        })
+        }),
+        emit
       );
       cursor.position = fallbackEnd;
       continue;
@@ -13248,8 +13338,8 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
     applySpecificCharacterSet(tag, valueSlice, ctx, emit, position);
     const privateCreator = safeModelCreator(resolvePrivateCreator(tag, ctx), ctx);
     const finalVr = vr;
-    elements.set(
-      tag,
+    defineElement(
+      elements,
       new Element({
         tag,
         vr: finalVr,
@@ -13261,7 +13351,8 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
         littleEndian: mode.littleEndian,
         ...ctx.currentCharset !== void 0 ? { specificCharacterSet: ctx.currentCharset } : {},
         ...privateCreator !== void 0 ? { privateCreator } : {}
-      })
+      }),
+      emit
     );
   }
   return { elements, endOffset: cursor.position };
@@ -15093,6 +15184,19 @@ function itemStreamOverrunsSequence(el, encoding) {
   const headerBytes = encoding === "implicit" ? 0 : EXPLICIT_SQ_HEADER_BYTES;
   return el.rawBytes.length - headerBytes > el.length;
 }
+function settledBound(source, encoding) {
+  let index = source.length;
+  let byteOffset;
+  for (const [at, el] of source.entries()) {
+    if (!itemStreamOverrunsSequence(el, encoding) && !isUnauditableSequence(el)) continue;
+    if (index === source.length) index = at + 1;
+    if (byteOffset === void 0 || el.byteOffset < byteOffset) byteOffset = el.byteOffset;
+  }
+  return { index, byteOffset };
+}
+function isSettled(el, at, bound) {
+  return at < bound.index && (bound.byteOffset === void 0 || el.byteOffset <= bound.byteOffset);
+}
 function keepsPrivate(el, ctx, creators) {
   if (!ctx.active.has("RetainSafePrivate") || ctx.profile === void 0) return false;
   if (isPrivateCreatorElement(el.tag)) {
@@ -15112,10 +15216,11 @@ function processElements(source, ctx, contextPath, reservationsUsable) {
     undefinedVrElements: [],
     warnings: []
   };
-  const creators = creatorsInScope(source);
-  for (const el of source) {
+  const bound = settledBound(source, ctx.encoding);
+  const creators = creatorsInScope(source.filter((el, at) => isSettled(el, at, bound)));
+  for (const [at, el] of source.entries()) {
     if (isPrivateTag(el.tag)) {
-      if (reservationsUsable && keepsPrivate(el, ctx, creators))
+      if (reservationsUsable && isSettled(el, at, bound) && keepsPrivate(el, ctx, creators))
         keepOrEmpty(el, ctx, contextPath, out);
       else out.removedPrivateTags.push(el.tag);
       continue;
@@ -15248,6 +15353,47 @@ function defaultMethod(active) {
   const base = "Cosyte @cosyte/dicom: PS3.15 Basic Application Level Confidentiality Profile";
   return active.size === 0 ? base : `${base} + ${[...active].join(", ")}`;
 }
+var VALUE_DELIMITER = 92;
+var MAX_SHORT_FORM_VALUE_BYTES = 65534;
+function addDeidentificationMethod(existing, method) {
+  const added = trimTrailingPad(Buffer.from(method, "latin1"));
+  if (existing === void 0 || existing.vr !== "LO") {
+    return { value: added, replacedPrior: false, retainedPrior: false };
+  }
+  const kept = Buffer.from(trimTrailingPad(existing.rawBytes));
+  if (kept.length === 0) return { value: added, replacedPrior: false, retainedPrior: false };
+  const keptValues = splitValues(kept).map(trimTrailingPad);
+  const missing = added.length === 0 ? [] : splitValues(added).filter((v) => !keptValues.some((k) => k.equals(trimTrailingPad(v))));
+  const parts = [kept];
+  for (const value2 of missing) {
+    parts.push(Buffer.from([VALUE_DELIMITER]), value2);
+  }
+  const value = trimTrailingPad(Buffer.concat(parts));
+  if (value.length > MAX_SHORT_FORM_VALUE_BYTES) {
+    return { value: added, replacedPrior: true, retainedPrior: false };
+  }
+  return { value, replacedPrior: false, retainedPrior: true };
+}
+function trimTrailingPad(value) {
+  let end = value.length;
+  while (end > 0) {
+    const last = value[end - 1];
+    if (last === 32 || last === 0) end--;
+    else break;
+  }
+  return value.subarray(0, end);
+}
+function splitValues(value) {
+  const out = [];
+  let start = 0;
+  for (let i = 0; i <= value.length; i++) {
+    if (i === value.length || value[i] === VALUE_DELIMITER) {
+      out.push(value.subarray(start, i));
+      start = i + 1;
+    }
+  }
+  return out;
+}
 function hasUncleanedBurnedIn(ds) {
   if (!ds.has(TAG_PIXEL_DATA)) return false;
   const flag = ds.get(TAG_BURNED_IN_ANNOTATION);
@@ -15281,11 +15427,23 @@ function deidentify(ds, options = {}) {
     insertedScalar(TAG_PATIENT_IDENTITY_REMOVED, "CS", Buffer.from("YES", "latin1"), littleEndian)
   );
   const method = options.deidentificationMethod ?? defaultMethod(active);
+  const priorMethod = elements.get(TAG_DEIDENTIFICATION_METHOD);
+  const deidentMethod = addDeidentificationMethod(priorMethod, method);
   elements.set(
     TAG_DEIDENTIFICATION_METHOD,
-    insertedScalar(TAG_DEIDENTIFICATION_METHOD, "LO", Buffer.from(method, "latin1"), littleEndian)
+    insertedScalar(TAG_DEIDENTIFICATION_METHOD, "LO", deidentMethod.value, littleEndian)
   );
   const warnings = [...processed.warnings];
+  if (deidentMethod.replacedPrior) {
+    warnings.push(
+      deidentMethodNotAdded({ byteOffset: priorMethod?.byteOffset ?? 0, fileMeta: false })
+    );
+  }
+  if (deidentMethod.retainedPrior) {
+    warnings.push(
+      deidentMethodPriorRetained({ byteOffset: priorMethod?.byteOffset ?? 0, fileMeta: false })
+    );
+  }
   if (hasUncleanedBurnedIn(ds)) {
     const offset = ds.get(TAG_PIXEL_DATA)?.byteOffset ?? 0;
     warnings.push(burnedInAnnotationNotRemoved({ byteOffset: offset, fileMeta: false }));