@cosyte/dicom 0.0.13 → 0.0.15

package/dist/index.cjs

@@ -11,7 +11,7 @@ var __export = (target, all) => {
 };
 
 // src/version.ts
-var VERSION = "0.0.13";
+var VERSION = "0.0.15";
 
 // src/dictionary/index.ts
 var dictionary_exports = {};
@@ -11787,6 +11787,11 @@ function safePrivateCreator(creator, profile) {
 function renderVr(vr) {
   return vr !== void 0 && KNOWN_VRS.has(vr) ? vr : WITHHELD;
 }
+var TAG_SHAPE = /^[0-9A-F]{8}$/u;
+function renderTag(tag) {
+  if (tag === void 0 || !TAG_SHAPE.test(tag)) return WITHHELD;
+  return lookup(tag) === void 0 ? WITHHELD : tag;
+}
 
 // src/parser/fatals.ts
 var SUPPORTED_TRANSFER_SYNTAXES = "1.2.840.10008.1.2, 1.2.840.10008.1.2.1, 1.2.840.10008.1.2.2, 1.2.840.10008.1.2.1.99";
@@ -11835,7 +11840,7 @@ var FATAL_MESSAGES = Object.freeze({
   // four bytes are not what they claim to be.
   FILE_META_GROUP_LENGTH_OVERRUNS: {
     code: FATAL_CODES.INVALID_FILE_META,
-    message: "(0002,0000) FileMetaInformationGroupLength declares more bytes than remain in the input; {n} bytes remain. The declared length is withheld; the byte offset locates the group."
+    message: "(0002,0000) FileMetaInformationGroupLength declares more bytes than remain in the input. The declared length and the count of bytes that remain are withheld; the byte offset locates the group."
   },
   FILE_META_TRANSFER_SYNTAX_MISSING: {
     code: FATAL_CODES.INVALID_FILE_META,
@@ -11878,7 +11883,7 @@ var FATAL_MESSAGES = Object.freeze({
   },
   ELEMENT_LENGTH_EXCEEDS_BUFFER: {
     code: FATAL_CODES.INVALID_FILE_META,
-    message: "An element declares a Value Length reaching past the end of the bytes being read; {n} bytes remain. Its tag and its declared length are withheld; the byte offset locates it."
+    message: "An element declares a Value Length reaching past the end of the bytes being read. Its tag, its declared length and the count of bytes that remain are withheld; the byte offset locates it."
   },
   UNEXPECTED_TAG_INSIDE_SEQUENCE: {
     code: FATAL_CODES.INVALID_FILE_META,
@@ -11949,8 +11954,8 @@ function unsupportedTransferSyntax(buffer, offset, ts) {
 function fileMetaTruncated(buffer, offset) {
   return at("FILE_META_TRUNCATED", buffer, offset);
 }
-function fileMetaGroupLengthOverruns(buffer, offset, remaining) {
-  return at("FILE_META_GROUP_LENGTH_OVERRUNS", buffer, offset, { n: remaining });
+function fileMetaGroupLengthOverruns(buffer, offset) {
+  return at("FILE_META_GROUP_LENGTH_OVERRUNS", buffer, offset);
 }
 function fileMetaTransferSyntaxMissing(buffer, offset) {
   return at("FILE_META_TRANSFER_SYNTAX_MISSING", buffer, offset);
@@ -11979,8 +11984,8 @@ function undefinedLengthOnNonSqExplicit(buffer, offset, vr) {
 function undefinedLengthOnNonSqImplicit(buffer, offset, vr) {
   return at("UNDEFINED_LENGTH_ON_NON_SQ_IMPLICIT", buffer, offset, { vr });
 }
-function elementLengthExceedsBuffer(buffer, offset, remaining) {
-  return at("ELEMENT_LENGTH_EXCEEDS_BUFFER", buffer, offset, { n: remaining });
+function elementLengthExceedsBuffer(buffer, offset) {
+  return at("ELEMENT_LENGTH_EXCEEDS_BUFFER", buffer, offset);
 }
 function unexpectedTagInsideSequence(buffer, offset) {
   return at("UNEXPECTED_TAG_INSIDE_SEQUENCE", buffer, offset);
@@ -12206,15 +12211,38 @@ var WARNING_MESSAGES = Object.freeze({
   DICOM_FILE_META_GROUP_LENGTH_MISSING: "(0002,0000) FileMetaInformationGroupLength missing; scanning forward to first non-(0002,xxxx) element.",
   DICOM_FILE_META_GROUP_LENGTH_MISMATCH: "(0002,0000) FileMetaInformationGroupLength declared {n} bytes; actual File Meta group size is {n2} bytes. Trusting actual.",
   DICOM_UNDEFINED_LENGTH_IN_EXPLICIT_VR: "Element ({tag}) uses undefined length (0xFFFFFFFF) under an Explicit VR transfer syntax.",
-  DICOM_ODD_LENGTH_VALUE_PADDED: "Element ({tag}) has odd declared length {n}; cursor advanced by one padding byte to maintain alignment.",
+  // The declared length is gone from this string and the reason is measured, not
+  // cautious: this code fires on ANY element header, including one a lying Value
+  // Length upstream composed out of somebody's value, and it then rendered four
+  // payload bytes as {tag} and four more as the decimal {n} - eight consecutive
+  // bytes of a name in one message. See `oddLengthValuePadded`.
+  DICOM_ODD_LENGTH_VALUE_PADDED: "Element ({tag}) has an odd declared length; cursor advanced by one padding byte to maintain alignment. The declared length is withheld; the byte offset identifies the element.",
   DICOM_VR_MISMATCH: "Element ({tag}) on-wire VR is {vr2}; dictionary lists {vr}. Trusting on-wire VR.",
-  DICOM_PRIVATE_TAG_NO_CREATOR: "Private element ({tag}) has no Private Creator registered for its block; treating as VR=UN.",
-  DICOM_GROUP_LENGTH_IN_DATASET: "Retired Group Length element ({tag}) encountered in dataset; preserved as-is.",
+  // No tag, and the reason is the one `nonzeroReservedBytes` states: this code's
+  // three siblings below fire only on an ODD group, and an odd group is the one
+  // class of tag no closed table this library holds can ever vouch for. See
+  // `privateTagNoCreator`.
+  DICOM_PRIVATE_TAG_NO_CREATOR: "A private element has no Private Creator registered for its block; treating as VR=UN. Its tag is withheld; the byte offset identifies the element.",
+  // No tag, and it is the membership bound in `renderTag` that made the slot
+  // dead rather than a judgement here: this code fires on a (gggg,0000), the
+  // element number is a constant of the code, and PS3.6 carries a literal row
+  // for exactly one such tag - (0002,0000), which is File Meta and never
+  // reaches this code. So every tag this slot could ever have rendered was one
+  // no closed table names, leaving the group number as sixteen free bits of a
+  // header that may itself be fabricated. See `groupLengthInDataset`.
+  DICOM_GROUP_LENGTH_IN_DATASET: "A retired Group Length element (gggg,0000) was encountered in the dataset; preserved as-is. Its group number is withheld; the byte offset identifies the element.",
   // The tag is deliberately absent, and this is the only *parser* message where
   // that is true. See `nonzeroReservedBytes`. Kept terse for the same reason the
   // de-identify messages are: it is emitted once per element, and element count
   // is attacker-chosen.
-  DICOM_NONZERO_RESERVED_BYTES: "Non-zero reserved bytes between VR and length (first byte {n}, second byte {n2}); ignoring. Tag withheld; the byte offset identifies the element.",
+  // 🩺 THE TWO BYTE VALUES ARE GONE FOR THE REASON THE TAG WAS ALREADY GONE, AND
+  // LEAVING THEM MADE THAT BOUND HALF A BOUND. This code's trigger is "these two
+  // bytes are not what PS3.5 7.1.2 says they must be", so the header may not be
+  // a header - and then the reserved pair is two bytes from inside some
+  // element's value, printed as two decimals that reverse with no work at all.
+  // Measured on a name-bearing payload across six under-declare deltas. See
+  // `nonzeroReservedBytes`.
+  DICOM_NONZERO_RESERVED_BYTES: "Non-zero reserved bytes between VR and length; ignoring. Their two values are withheld with the tag; the byte offset identifies the element.",
   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.",
@@ -12249,15 +12277,22 @@ var WARNING_MESSAGES = Object.freeze({
   // 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.",
+  // BOTH of the disagreeing length fields are deliberately absent, and the
+  // second one is the eighth instance of `DICOM-DIAGNOSTIC-PHI-RESIDUALS`: the
+  // remaining-bytes count this string used to carry was the enclosing sequence's
+  // declared Value Length less the bytes of that sequence already consumed. See
+  // `itemCrossesSequenceEnd`.
+  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. The file's two length fields disagree (PS3.5 7.5.1 and 7.5.2 govern them); the item's is used. Both declared lengths are withheld; the byte offset locates the item.",
+  // Declared but not emitted by this build. The declared length is bound out
+  // anyway: it is a raw 32-bit read off a header, so activating this code later
+  // with the slot still here would ship the leak this slice closed one code
+  // over. `{n2}` stays - it is the product this parser computed from the image
+  // description attributes, not a number it read. The tag is a constant.
+  DICOM_PIXEL_DATA_LENGTH_MISMATCH: "(7FE0,0010) PixelData declared length does not match the computed {n2} bytes. The declared length is withheld; the byte offset identifies the element.",
+  DICOM_IMPLICIT_VR_FOR_PRIVATE_TAG_WITHOUT_VR: "A private element under Implicit VR LE has no VR override; falling back to UN. Its tag is withheld; the byte offset identifies the element.",
+  DICOM_PRIVATE_CREATOR_UNKNOWN: "A private element 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. Its tag is withheld; the byte offset identifies the element.",
   DICOM_BURNED_IN_ANNOTATION_NOT_REMOVED: "Pixel Data is present and Burned In Annotation is not 'NO'; this metadata-only de-identifier cannot inspect or clean pixels. Recognizable text may remain burned into the image.",
-  DICOM_DEIDENT_EMBEDDED_ATTRIBUTE_REMOVED: "Element ({tag}) {vr} was kept by the action table, but its value ends with {n} whole Data Element(s) - an over-declared Value Length swallowed what followed it. Emptied rather than kept, because the action table cannot see an attribute encoded inside a value. Read report.embeddedAttributes for the tags that were hidden there.",
+  DICOM_DEIDENT_EMBEDDED_ATTRIBUTE_REMOVED: "Element ({tag}) {vr} was kept by the action table, but its value ends with {n} whole Data Element(s) - an over-declared Value Length swallowed what followed it. Emptied rather than kept, because the action table cannot see an attribute encoded inside a value. report.embeddedAttributes names the ones this run acts on that also have a literal Table E.1-1 row, which may be none of them.",
   // Deliberately short. One of these is raised per un-auditable element, so a
   // long message is multiplied by an element count the input controls; the
   // reasoning belongs in the docs, not in a string repeated thousands of times.
@@ -12265,19 +12300,31 @@ var WARNING_MESSAGES = Object.freeze({
   // its two producers is an element the profile declares a Sequence while the
   // wire says UN or OB, so naming a VR here would state a fact about the file
   // that the file contradicts - on the one channel this class designates.
-  DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE: "Element ({tag}) is a Sequence carrier with no parsed items, so its {n} recorded bytes could not be audited (PS3.15 E.1.1); emptied. See report.unauditableSequences.",
+  // The recorded byte count is gone from this string, and the reason is the same
+  // one that took the declared length out of `DICOM_ODD_LENGTH_VALUE_PADDED`:
+  // `Element.rawBytes.length` EQUALS the Value Length off the element header, so
+  // when that header is fabricated the decimal is four document bytes. See
+  // `sequenceNotAuditable`. `report.unauditableSequences[].byteLength` still
+  // carries it, on a type documented as not value-free.
+  DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE: "Element ({tag}) is a Sequence carrier with no parsed items, so its recorded bytes could not be audited (PS3.15 E.1.1); emptied. The byte count is withheld; see report.unauditableSequences.",
   // Deliberately short for the same reason as the code above: one per element,
   // and the element count is chosen by the input.
   //
-  // NEITHER THE TAG NOR THE VR IS ECHOED, and that is specific to this code
-  // rather than caution. Every other factory's {tag} is composed from a real
-  // Data Element header; the condition that raises THIS one is that the header
-  // was fabricated from bytes inside some element's value, so its four tag bytes
-  // and its two VR bytes are document content. `renderTag` shape-checks a tag
-  // and cannot refuse one, so the withholding has to happen at the call site.
+  // NEITHER THE TAG NOR THE VR NOR THE BYTE COUNT IS ECHOED, and that is
+  // specific to this code rather than caution. Every other factory's {tag} is
+  // composed from a real Data Element header; the condition that raises THIS one
+  // is that the header was fabricated from bytes inside some element's value, so
+  // its four tag bytes, its two VR bytes AND its four length bytes are document
+  // content. `renderTag` is a membership test against PS3.6's registry and would
+  // refuse this one - but a slot that has to rely on that is a slot a future
+  // call site can still be handed, so the withholding stays at the call site
+  // where it does not depend on a table. The length had no table to fall back on
+  // at all: the message withheld the two fields a renderer could check and then
+  // printed the one it could not, which is the shape this code was already
+  // written to refuse.
   // The byte offset locates the element instead, and is a position this parser
   // counted rather than anything the document said.
-  DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE: "An element at byte offset {n2} carries an on-wire VR that is not one of the 34 PS3.5 6.2 defines, so its {n} value bytes are not a Value Field this library decoded; emptied (PS3.15 E.1.1). Its tag and VR are withheld: an earlier under-declared length can make them fragments of some element's value. See report.undefinedVrElements.",
+  DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE: "An element at byte offset {n2} carries an on-wire VR that is not one of the 34 PS3.5 6.2 defines, so its value bytes are not a Value Field this library decoded; emptied (PS3.15 E.1.1). Its tag, VR and byte count are withheld: an earlier under-declared length can make them fragments of some element's value. See report.undefinedVrElements.",
   DICOM_BOM_IN_TEXT_VR: "Element ({tag}) {vr} value begins with a UTF-8 BOM; stripped on decode.",
   DICOM_TRAILING_NULL_IN_TEXT_VR: "Element ({tag}) {vr} value has a trailing NULL pad where SPACE is expected; trimmed.",
   DICOM_UI_TRAILING_SPACE: "Element ({tag}) UI value is SPACE-padded; UI requires NULL padding (PS3.5 \xA76.2). Trimmed.",
@@ -12288,10 +12335,6 @@ var WARNING_MESSAGES = Object.freeze({
   DICOM_UNSUPPORTED_CHARSET: "(0008,0005) Specific Character Set value {n} names a defined term this build does not support; decoding text as UTF-8 best-effort. The term is not reproduced here - read the element if you need it.",
   DICOM_CHARSET_AMBIGUOUS_SEPARATOR: "(0008,0005) Specific Character Set value {n} is ambiguous under the active code extensions; decoding text as UTF-8 best-effort."
 });
-var TAG_SHAPE = /^[0-9A-F]{8}$/u;
-function renderTag(tag) {
-  return tag !== void 0 && TAG_SHAPE.test(tag) ? tag : WITHHELD;
-}
 function build2(code, position, tokens = {}) {
   const message = WARNING_MESSAGES[code].replace("{tag}", renderTag(tokens.tag)).replace("{vr2}", renderVr(tokens.vr2)).replace("{vr}", renderVr(tokens.vr)).replace("{n2}", String(tokens.n2 ?? 0)).replace("{n}", String(tokens.n ?? 0));
   return { code, message, position };
@@ -12311,26 +12354,20 @@ function fileMetaGroupLengthMismatch(position, declared, actual) {
 function undefinedLengthInExplicitVR(position, tag) {
   return build2(WARNING_CODES.DICOM_UNDEFINED_LENGTH_IN_EXPLICIT_VR, position, { tag });
 }
-function oddLengthValuePadded(position, tag, declaredLength) {
-  return build2(WARNING_CODES.DICOM_ODD_LENGTH_VALUE_PADDED, position, {
-    tag,
-    n: declaredLength
-  });
+function oddLengthValuePadded(position, tag) {
+  return build2(WARNING_CODES.DICOM_ODD_LENGTH_VALUE_PADDED, position, { tag });
 }
 function vrMismatch(position, tag, dictVR, fileVR) {
   return build2(WARNING_CODES.DICOM_VR_MISMATCH, position, { tag, vr: dictVR, vr2: fileVR });
 }
-function privateTagNoCreator(position, tag) {
-  return build2(WARNING_CODES.DICOM_PRIVATE_TAG_NO_CREATOR, position, { tag });
+function privateTagNoCreator(position) {
+  return build2(WARNING_CODES.DICOM_PRIVATE_TAG_NO_CREATOR, position);
 }
-function groupLengthInDataset(position, tag) {
-  return build2(WARNING_CODES.DICOM_GROUP_LENGTH_IN_DATASET, position, { tag });
+function groupLengthInDataset(position) {
+  return build2(WARNING_CODES.DICOM_GROUP_LENGTH_IN_DATASET, position);
 }
-function nonzeroReservedBytes(position, first, second) {
-  return build2(WARNING_CODES.DICOM_NONZERO_RESERVED_BYTES, position, {
-    n: first,
-    n2: second
-  });
+function nonzeroReservedBytes(position) {
+  return build2(WARNING_CODES.DICOM_NONZERO_RESERVED_BYTES, position);
 }
 function unParsedAsSQ(position, tag) {
   return build2(WARNING_CODES.DICOM_UN_PARSED_AS_SQ, position, { tag });
@@ -12338,11 +12375,8 @@ function unParsedAsSQ(position, tag) {
 function sqNotDescended(position, tag) {
   return build2(WARNING_CODES.DICOM_SQ_NOT_DESCENDED, position, { tag });
 }
-function itemCrossesSequenceEnd(position, tag, availableLength) {
-  return build2(WARNING_CODES.DICOM_ITEM_CROSSES_SEQUENCE_END, position, {
-    tag,
-    n2: availableLength
-  });
+function itemCrossesSequenceEnd(position, tag) {
+  return build2(WARNING_CODES.DICOM_ITEM_CROSSES_SEQUENCE_END, position, { tag });
 }
 function emptyItemInSequence(position, tag) {
   return build2(WARNING_CODES.DICOM_EMPTY_ITEM_IN_SEQUENCE, position, { tag });
@@ -12353,11 +12387,11 @@ function duplicateTagInDataSet(position) {
 function duplicateFileMetaElement(position) {
   return build2(WARNING_CODES.DICOM_DUPLICATE_FILE_META_ELEMENT, position);
 }
-function implicitVRForPrivateTagWithoutVR(position, tag) {
-  return build2(WARNING_CODES.DICOM_IMPLICIT_VR_FOR_PRIVATE_TAG_WITHOUT_VR, position, { tag });
+function implicitVRForPrivateTagWithoutVR(position) {
+  return build2(WARNING_CODES.DICOM_IMPLICIT_VR_FOR_PRIVATE_TAG_WITHOUT_VR, position);
 }
-function privateCreatorUnknown(position, tag) {
-  return build2(WARNING_CODES.DICOM_PRIVATE_CREATOR_UNKNOWN, position, { tag });
+function privateCreatorUnknown(position) {
+  return build2(WARNING_CODES.DICOM_PRIVATE_CREATOR_UNKNOWN, position);
 }
 function burnedInAnnotationNotRemoved(position) {
   return build2(WARNING_CODES.DICOM_BURNED_IN_ANNOTATION_NOT_REMOVED, position);
@@ -12378,15 +12412,11 @@ function embeddedAttributeRemoved(position, tag, vr, count) {
     n: count
   });
 }
-function sequenceNotAuditable(position, tag, byteLength) {
-  return build2(WARNING_CODES.DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE, position, {
-    tag,
-    n: byteLength
-  });
+function sequenceNotAuditable(position, tag) {
+  return build2(WARNING_CODES.DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE, position, { tag });
 }
-function undefinedVrNotAuditable(position, byteLength) {
+function undefinedVrNotAuditable(position) {
   return build2(WARNING_CODES.DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE, position, {
-    n: byteLength,
     n2: position.byteOffset
   });
 }
@@ -12462,18 +12492,18 @@ function resolveImplicitVR(tag, ctx, emit, position) {
     }
     const creator = resolvePrivateCreator(tag, ctx);
     if (creator === void 0) {
-      emit(privateTagNoCreator(position, tag));
-      emit(implicitVRForPrivateTagWithoutVR(position, tag));
+      emit(privateTagNoCreator(position));
+      emit(implicitVRForPrivateTagWithoutVR(position));
       return "UN";
     }
     if (ctx.profile !== void 0) {
       const def = resolvePrivateTag(ctx.profile, tag, creator);
       if (def !== void 0) return def.vr;
       if (!ctx.profile.privateDictionary.has(creator)) {
-        emit(privateCreatorUnknown(position, tag));
+        emit(privateCreatorUnknown(position));
       }
     }
-    emit(implicitVRForPrivateTagWithoutVR(position, tag));
+    emit(implicitVRForPrivateTagWithoutVR(position));
     return "UN";
   }
   const direct = TAGS[tag];
@@ -12557,7 +12587,7 @@ function readExplicitElementHeader(cursor, _ctx, emit) {
     const reserved1 = cursor.buffer[cursor.position + 1];
     cursor.position += 2;
     if ((reserved0 ?? 0) !== 0 || (reserved1 ?? 0) !== 0) {
-      emit(nonzeroReservedBytes({ byteOffset: headerStart }, reserved0 ?? 0, reserved1 ?? 0));
+      emit(nonzeroReservedBytes({ byteOffset: headerStart }));
     }
     length = cursor.readUInt32();
     headerLength = 12;
@@ -12597,7 +12627,7 @@ function parseFileMeta(buffer$1, datasetStart, ctx, emit) {
   if (firstElement.tag === "00020000" && firstElement.vr === "UL" && firstElement.value.length === 4) {
     declaredFmLength = firstElement.value.readUInt32LE(0);
     if (cursor.position + declaredFmLength > buffer$1.length) {
-      throw fileMetaGroupLengthOverruns(buffer$1, fmStart, buffer$1.length - cursor.position);
+      throw fileMetaGroupLengthOverruns(buffer$1, fmStart);
     }
   } else {
     emit(fileMetaGroupLengthMissing({ byteOffset: fmStart, fileMeta: true }));
@@ -13236,13 +13266,7 @@ function parseSequence(buffer, valueStart, ctx, emit, opts) {
         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)
-            )
-          );
+          emit(itemCrossesSequenceEnd({ byteOffset: itemHeaderStart }, itemTag));
         }
         if (cursor.position + itemLength > buffer.length) {
           throw itemLengthExceedsBuffer(buffer, itemHeaderStart);
@@ -13440,7 +13464,7 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
       throw undefinedLengthOnNonSqImplicit(buffer, headerStart, vr);
     }
     if (cursor.position + length > buffer.length) {
-      throw elementLengthExceedsBuffer(buffer, headerStart, buffer.length - cursor.position);
+      throw elementLengthExceedsBuffer(buffer, headerStart);
     }
     const valueStart = cursor.position;
     const valueEnd = valueStart + length;
@@ -13477,7 +13501,7 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
       }
     }
     if (element === 0 && group !== 2) {
-      emit(groupLengthInDataset(position, tag));
+      emit(groupLengthInDataset(position));
     }
     if (group % 2 === 1 && element >= 16 && element <= 255) {
       registerPrivateCreator(tag, valueSlice, ctx);
@@ -13560,7 +13584,7 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
       }
     }
     if (length !== UNDEFINED_LENGTH2 && length % 2 === 1) {
-      emit(oddLengthValuePadded(position, tag, length));
+      emit(oddLengthValuePadded(position, tag));
     }
     if (vr === "SQ") {
       const valueStart2 = cursor.position;
@@ -13687,7 +13711,7 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
       throw undefinedLengthOnNonSqExplicit(buffer, headerStart, vr);
     }
     if (cursor.position + length > buffer.length) {
-      throw elementLengthExceedsBuffer(buffer, headerStart, buffer.length - cursor.position);
+      throw elementLengthExceedsBuffer(buffer, headerStart);
     }
     const valueStart = cursor.position;
     const valueEnd = valueStart + length;
@@ -13695,7 +13719,7 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
     cursor.position = valueEnd;
     const elementHexNum = parseInt(tag.slice(4, 8), 16);
     if (elementHexNum === 0 && groupNum !== 2) {
-      emit(groupLengthInDataset(position, tag));
+      emit(groupLengthInDataset(position));
     }
     if (groupNum % 2 === 1 && elementHexNum >= 16 && elementHexNum <= 255) {
       registerPrivateCreator(tag, valueSlice, ctx);
@@ -15225,6 +15249,10 @@ function hasByteOutsideRepertoire(region, carrierVr) {
   }
   return false;
 }
+function isTableBound(tag) {
+  const action = annexE(tag);
+  return action !== void 0 && action.repeatingGroup === void 0;
+}
 function findEmbeddedAttributes(value, carrierVr, encoding, isActionable) {
   if (!isScannableCarrier(carrierVr)) return void 0;
   if (value.length < MIN_HEADER) return void 0;
@@ -15248,15 +15276,19 @@ function findEmbeddedAttributes(value, carrierVr, encoding, isActionable) {
   for (let off = 0; off + MIN_HEADER <= n; off += 2) {
     if (hit[off >> 1] !== 1) continue;
     if (!hasByteOutsideRepertoire(window.subarray(off), carrierVr)) return void 0;
-    const tags = [];
+    const hidden = [];
+    let elementCount = 0;
     let pos = off;
     while (pos < n) {
       const decoded = decodeAt(window, pos, encoding);
       if (decoded === void 0) break;
-      if (decoded.tag !== void 0) tags.push(decoded.tag);
+      if (decoded.tag !== void 0) {
+        elementCount += 1;
+        if (isActionable(decoded.tag) && isTableBound(decoded.tag)) hidden.push(decoded.tag);
+      }
       pos = decoded.next;
     }
-    return tags;
+    return { hidden, elementCount };
   }
   return void 0;
 }
@@ -15461,8 +15493,8 @@ function keepOrEmpty(el, ctx, contextPath, out) {
     emptyUndefinedVrElement(el, ctx, contextPath, out);
     return false;
   }
-  const hidden = findEmbeddedAttributes(el.rawBytes, el.vr, ctx.encoding, (t) => actsOnTag(t, ctx));
-  if (hidden === void 0) {
+  const run = findEmbeddedAttributes(el.rawBytes, el.vr, ctx.encoding, (t) => actsOnTag(t, ctx));
+  if (run === void 0) {
     out.elements.set(el.tag, el);
     return true;
   }
@@ -15470,11 +15502,11 @@ function keepOrEmpty(el, ctx, contextPath, out) {
   out.embeddedAttributes.push({
     tag: el.tag,
     vr: el.vr,
-    hidden,
+    hidden: run.hidden,
     ...contextPath.length > 0 ? { contextPath: [...contextPath] } : {}
   });
   out.warnings.push(
-    embeddedAttributeRemoved({ byteOffset: el.byteOffset }, el.tag, el.vr, hidden.length)
+    embeddedAttributeRemoved({ byteOffset: el.byteOffset }, el.tag, el.vr, run.elementCount)
   );
   return false;
 }
@@ -15487,7 +15519,7 @@ function emptyUndefinedVrElement(el, ctx, contextPath, out) {
     byteLength: el.rawBytes.length,
     ...contextPath.length > 0 ? { contextPath: [...contextPath] } : {}
   });
-  out.warnings.push(undefinedVrNotAuditable({ byteOffset: el.byteOffset }, el.rawBytes.length));
+  out.warnings.push(undefinedVrNotAuditable({ byteOffset: el.byteOffset }));
 }
 function isUnauditableSequence(el) {
   return el.vr === "SQ" && el.items === void 0;
@@ -15504,9 +15536,7 @@ function emptyUnauditableCarrier(el, ctx, contextPath, out, replacement) {
     byteLength: el.rawBytes.length,
     ...contextPath.length > 0 ? { contextPath: [...contextPath] } : {}
   });
-  out.warnings.push(
-    sequenceNotAuditable({ byteOffset: el.byteOffset }, el.tag, el.rawBytes.length)
-  );
+  out.warnings.push(sequenceNotAuditable({ byteOffset: el.byteOffset }, el.tag));
 }
 function creatorsInScope(source) {
   const byBlock = /* @__PURE__ */ new Map();