@cosyte/dicom 0.0.13 → 0.0.14

package/dist/index.d.cts

@@ -114,6 +114,18 @@ interface UidEntry {
  * throw `TypeError` in strict mode (which all of `@cosyte/dicom`'s emitted code
  * runs under, given `"use strict"` is implicit for ES modules).
  *
+ * @example
+ * ```ts
+ * import { Dictionary } from "@cosyte/dicom";
+ *
+ * // Tag or keyword, either way round, and `undefined` rather than a throw on a miss.
+ * Dictionary.lookup("00100020")?.name; // "Patient ID"
+ * Dictionary.byKeyword("Modality")?.tag; // "00080060"
+ *
+ * // UIDs resolve to their registered name, so nobody hard-codes a SOP Class table.
+ * Dictionary.uid("1.2.840.10008.5.1.4.1.1.2")?.name; // "CT Image Storage"
+ * ```
+ *
  * @module
  */
 
@@ -317,8 +329,13 @@ interface ParseOptions {
      *
      * 🛑 **THE ESCALATED DIAGNOSTIC CARRIES SOURCE BYTES THAT THE WARNING DOES
      * NOT.** A `DicomParseWarning.message` is a frozen registry string with only
-     * structural tokens filled in, so it is safe to log whole; the
-     * `DicomParseError` this option raises in its place also carries `snippet`,
+     * structural tokens filled in, so it is safe to log whole **on a well-formed
+     * file, and it is not unconditionally safe**: the `{tag}` slot is filled by a
+     * shape check, which cannot refuse a tag a lying Value Length composed out of
+     * somebody's value (measured, `PRE-EXISTING`, disclosed rather than guarded
+     * because withholding the tag would take it off every private element in every
+     * conformant file). The `DicomParseError` this option raises in its place is a
+     * different and larger surface: it also carries `snippet`,
      * **16 raw bytes, unredacted** (D-10), read at the warning's own `byteOffset`.
      * A message-only PHI review of the lenient path therefore does not transfer to
      * the strict one. Log `err.code`, `err.byteOffset` and `err.message`; treat
@@ -921,6 +938,21 @@ declare class Element {
  * `(0002,0102)` Private Information - is captured here as raw bytes (the
  * on-wire value, even-length per PS3.5 §6.2) rather than dropped. `value` is a
  * defensive copy, so the view never aliases the parsed input buffer.
+ *
+ * @example
+ * ```ts
+ * import { parseDicom } from "@cosyte/dicom";
+ * const ds = parseDicom(buf);
+ * // Anything the typed FileMeta fields do not model, in ascending tag order.
+ * for (const raw of ds.fileMeta?.extraElements ?? []) {
+ *   raw.tag; // e.g. "00020017" Sending Application Entity Title
+ *   raw.vr; // the VR the source wrote (File Meta is always Explicit VR LE)
+ *   raw.value.length; // even, per PS3.5 2026c section 7.1.1
+ * }
+ * ```
+ *
+ * `(0002,0016)` Source Application Entity Title is deliberately NOT the example: it is one of the
+ * typed fields, so it never reaches this array.
  */
 interface FileMetaRawElement {
     /** 8-char uppercase hex tag, e.g. `"00020100"`. */
@@ -2448,15 +2480,29 @@ interface DeidentifiedAttribute {
  * (PS3.15 §E.1 "all instances"; §E.3.5 is the standard's own precedent for
  * removing identifying information embedded inside a string attribute).
  *
- * `tag` and `vr` are the carrier's own and are structural. **`hidden` is not,
- * and calling this finding "safe to log" was wrong.** Each entry is composed
- * from four bytes that were sitting *inside* the carrier's value - that is the
- * whole reason the field exists - so on any file that populates it those bytes
- * are document content. Measured: a `CS` carrier over-declaring over the bytes
- * `"SABC"` reports `hidden: ["41534342"]`, which is `"SABC"` in wire order.
- * `PRE-EXISTING` and identical on every release that has shipped the field.
- * Treat `hidden` at the sensitivity of the file, and see
- * {@link DeidentifyReport} for the other fields in this class.
+ * `tag` and `vr` are the carrier's own and are structural. **`hidden` was not,
+ * and it is bound now.** Every tag in an embedded run is composed from four
+ * bytes that were sitting *inside* the carrier's value - that is the whole
+ * reason this type exists - and a run needs only ONE actionable attribute to be
+ * reported, so through `0.0.13` the rest of the run was listed beside it.
+ * Measured: a `CS` carrier over-declaring across a fabricated `"SMIT"` header
+ * beside a genuine `(0010,0020)` reported `hidden: ["4D535449", "00100020"]`,
+ * and `4D535449` is `"SMIT"` in wire order.
+ *
+ * **An entry is now one of the 652 literal rows of PS3.15 Table E.1-1 that this
+ * run's options left actionable.** That is a **membership** bound rather than a
+ * shape one - the posture this package already takes for a VR and for a Private
+ * Creator - so what survives names a published table entry rather than a
+ * document byte, the same trade rendering a VR makes with the 34. **A
+ * repeating-group mask hit is NOT in that set and is excluded**: `(50xx,xxxx)`
+ * Curve Data leaves the whole 16-bit element number free, so a mask match proves
+ * a rule exists without making the membership finite. A graded pass caught a
+ * draft of this filter that admitted it.
+ *
+ * **🛑 THAT IS NOT AN ALL-CLEAR OVER THIS TYPE.** `contextPath` below is
+ * unbound and unchanged, `hidden` is uncapped, and
+ * {@link DeidentifyReport} names the report's other value-bearing fields. A
+ * `DeidentifyReport` is still not safe to log whole.
  *
  * @example
  * ```ts
@@ -2472,7 +2518,18 @@ interface EmbeddedAttributeFinding {
     readonly tag: Tag;
     /** The carrier's VR. Always one of the string VRs; binary VRs are not scanned. */
     readonly vr: VR;
-    /** The tags of the Data Elements found inside the carrier's value, in wire order. */
+    /**
+     * The tags found inside the carrier's value **that this run acts on and that a
+     * published table names**, in wire order. **Not every tag in the run** - see
+     * this type's own remarks.
+     *
+     * **🩺 IT MAY BE EMPTY, AND EMPTY DOES NOT MEAN "NOTHING WAS HIDDEN HERE".**
+     * A run whose only actionable members are private attributes, Curve Data or
+     * Overlay elements reports a finding with no tags: the carrier was still
+     * emptied, and the accompanying `DICOM_DEIDENT_EMBEDDED_ATTRIBUTE_REMOVED`
+     * warning still counts the whole run. The presence of the finding is the fact;
+     * this list is the part of it that can be named.
+     */
     readonly hidden: readonly Tag[];
     /**
      * Tag/index chain when the carrier is inside a sequence item; omitted at the
@@ -2697,13 +2754,6 @@ interface UndefinedVrFinding {
  *   and still answers it whenever the fabricated VR is outside the 34 PS3.5
  *   §6.2 defines. It cannot when the fabricated VR is one of them, because those
  *   two files are byte-identical.
- * - **`embeddedAttributes[].hidden`** - see {@link EmbeddedAttributeFinding}.
- *   Each entry is a tag composed from four bytes that were sitting **inside**
- *   a value, which is the position this type exists to distrust, so on a file
- *   that populates the field at all they are document content by
- *   construction. `PRE-EXISTING` and identical on every release that has
- *   shipped the field; it is disclosed here and its remedy is its own slice,
- *   alongside the cap that field is also missing.
  * - **`contextPath`, on all four findings that carry one** - see
  *   {@link DeidentifiedAttribute.contextPath}, which holds the measurement. The
  *   segment tags come off the wire with no table behind them, so a fabricated
@@ -2714,8 +2764,18 @@ interface UndefinedVrFinding {
  *   same file the de-identified object itself re-emits the fabricated header, so
  *   redacting this field does not make the object safe.**
  *
+ * `embeddedAttributes[].hidden` **left that list** in
+ * `DICOM-DIAGNOSTIC-PHI-RESIDUALS` - an entry is now a literal PS3.15 Table
+ * E.1-1 row, so it is not value-bearing. Its own disclosure had been reworded
+ * twice by then, and this repo deletes a disclosure at that point rather than
+ * writing a third; what is true of the field is stated once, on
+ * {@link EmbeddedAttributeFinding}. The field is **still uncapped**.
+ *
  * So "the report is safe to log apart from `uidMap`" is **not** an accurate
  * description of this type, and was corrected rather than kept convenient.
+ * **This is the only copy of that list.** Two others lived in module docstrings,
+ * still naming `hidden` after it left and never naming `contextPath` at all; a
+ * graded pass found them and they were deleted rather than resynced.
  *
  * @example
  * ```ts
@@ -2994,9 +3054,8 @@ declare class DeidentifyError extends Error {
  * action map ({@link annexE}). It is a **pure** function: the input {@link Dataset}
  * is never mutated; a fresh `Dataset` (with a rebuilt element map and File Meta)
  * is returned alongside a {@link DeidentifyReport} whose non-value-free fields
- * are named on that type: `uidMap`, `removedPrivateTags`,
- * `unauditableSequences[].tag` and `embeddedAttributes[].hidden`. Read the list
- * there, never a count quoted elsewhere.
+ * are named on that type. **The list is deliberately not copied here** - see
+ * `./index.ts` for what a third copy of it cost.
  *
  * **What it does**
  * - Resolves each attribute's action (basic profile, overridden by an active

package/dist/index.d.ts

@@ -114,6 +114,18 @@ interface UidEntry {
  * throw `TypeError` in strict mode (which all of `@cosyte/dicom`'s emitted code
  * runs under, given `"use strict"` is implicit for ES modules).
  *
+ * @example
+ * ```ts
+ * import { Dictionary } from "@cosyte/dicom";
+ *
+ * // Tag or keyword, either way round, and `undefined` rather than a throw on a miss.
+ * Dictionary.lookup("00100020")?.name; // "Patient ID"
+ * Dictionary.byKeyword("Modality")?.tag; // "00080060"
+ *
+ * // UIDs resolve to their registered name, so nobody hard-codes a SOP Class table.
+ * Dictionary.uid("1.2.840.10008.5.1.4.1.1.2")?.name; // "CT Image Storage"
+ * ```
+ *
  * @module
  */
 
@@ -317,8 +329,13 @@ interface ParseOptions {
      *
      * 🛑 **THE ESCALATED DIAGNOSTIC CARRIES SOURCE BYTES THAT THE WARNING DOES
      * NOT.** A `DicomParseWarning.message` is a frozen registry string with only
-     * structural tokens filled in, so it is safe to log whole; the
-     * `DicomParseError` this option raises in its place also carries `snippet`,
+     * structural tokens filled in, so it is safe to log whole **on a well-formed
+     * file, and it is not unconditionally safe**: the `{tag}` slot is filled by a
+     * shape check, which cannot refuse a tag a lying Value Length composed out of
+     * somebody's value (measured, `PRE-EXISTING`, disclosed rather than guarded
+     * because withholding the tag would take it off every private element in every
+     * conformant file). The `DicomParseError` this option raises in its place is a
+     * different and larger surface: it also carries `snippet`,
      * **16 raw bytes, unredacted** (D-10), read at the warning's own `byteOffset`.
      * A message-only PHI review of the lenient path therefore does not transfer to
      * the strict one. Log `err.code`, `err.byteOffset` and `err.message`; treat
@@ -921,6 +938,21 @@ declare class Element {
  * `(0002,0102)` Private Information - is captured here as raw bytes (the
  * on-wire value, even-length per PS3.5 §6.2) rather than dropped. `value` is a
  * defensive copy, so the view never aliases the parsed input buffer.
+ *
+ * @example
+ * ```ts
+ * import { parseDicom } from "@cosyte/dicom";
+ * const ds = parseDicom(buf);
+ * // Anything the typed FileMeta fields do not model, in ascending tag order.
+ * for (const raw of ds.fileMeta?.extraElements ?? []) {
+ *   raw.tag; // e.g. "00020017" Sending Application Entity Title
+ *   raw.vr; // the VR the source wrote (File Meta is always Explicit VR LE)
+ *   raw.value.length; // even, per PS3.5 2026c section 7.1.1
+ * }
+ * ```
+ *
+ * `(0002,0016)` Source Application Entity Title is deliberately NOT the example: it is one of the
+ * typed fields, so it never reaches this array.
  */
 interface FileMetaRawElement {
     /** 8-char uppercase hex tag, e.g. `"00020100"`. */
@@ -2448,15 +2480,29 @@ interface DeidentifiedAttribute {
  * (PS3.15 §E.1 "all instances"; §E.3.5 is the standard's own precedent for
  * removing identifying information embedded inside a string attribute).
  *
- * `tag` and `vr` are the carrier's own and are structural. **`hidden` is not,
- * and calling this finding "safe to log" was wrong.** Each entry is composed
- * from four bytes that were sitting *inside* the carrier's value - that is the
- * whole reason the field exists - so on any file that populates it those bytes
- * are document content. Measured: a `CS` carrier over-declaring over the bytes
- * `"SABC"` reports `hidden: ["41534342"]`, which is `"SABC"` in wire order.
- * `PRE-EXISTING` and identical on every release that has shipped the field.
- * Treat `hidden` at the sensitivity of the file, and see
- * {@link DeidentifyReport} for the other fields in this class.
+ * `tag` and `vr` are the carrier's own and are structural. **`hidden` was not,
+ * and it is bound now.** Every tag in an embedded run is composed from four
+ * bytes that were sitting *inside* the carrier's value - that is the whole
+ * reason this type exists - and a run needs only ONE actionable attribute to be
+ * reported, so through `0.0.13` the rest of the run was listed beside it.
+ * Measured: a `CS` carrier over-declaring across a fabricated `"SMIT"` header
+ * beside a genuine `(0010,0020)` reported `hidden: ["4D535449", "00100020"]`,
+ * and `4D535449` is `"SMIT"` in wire order.
+ *
+ * **An entry is now one of the 652 literal rows of PS3.15 Table E.1-1 that this
+ * run's options left actionable.** That is a **membership** bound rather than a
+ * shape one - the posture this package already takes for a VR and for a Private
+ * Creator - so what survives names a published table entry rather than a
+ * document byte, the same trade rendering a VR makes with the 34. **A
+ * repeating-group mask hit is NOT in that set and is excluded**: `(50xx,xxxx)`
+ * Curve Data leaves the whole 16-bit element number free, so a mask match proves
+ * a rule exists without making the membership finite. A graded pass caught a
+ * draft of this filter that admitted it.
+ *
+ * **🛑 THAT IS NOT AN ALL-CLEAR OVER THIS TYPE.** `contextPath` below is
+ * unbound and unchanged, `hidden` is uncapped, and
+ * {@link DeidentifyReport} names the report's other value-bearing fields. A
+ * `DeidentifyReport` is still not safe to log whole.
  *
  * @example
  * ```ts
@@ -2472,7 +2518,18 @@ interface EmbeddedAttributeFinding {
     readonly tag: Tag;
     /** The carrier's VR. Always one of the string VRs; binary VRs are not scanned. */
     readonly vr: VR;
-    /** The tags of the Data Elements found inside the carrier's value, in wire order. */
+    /**
+     * The tags found inside the carrier's value **that this run acts on and that a
+     * published table names**, in wire order. **Not every tag in the run** - see
+     * this type's own remarks.
+     *
+     * **🩺 IT MAY BE EMPTY, AND EMPTY DOES NOT MEAN "NOTHING WAS HIDDEN HERE".**
+     * A run whose only actionable members are private attributes, Curve Data or
+     * Overlay elements reports a finding with no tags: the carrier was still
+     * emptied, and the accompanying `DICOM_DEIDENT_EMBEDDED_ATTRIBUTE_REMOVED`
+     * warning still counts the whole run. The presence of the finding is the fact;
+     * this list is the part of it that can be named.
+     */
     readonly hidden: readonly Tag[];
     /**
      * Tag/index chain when the carrier is inside a sequence item; omitted at the
@@ -2697,13 +2754,6 @@ interface UndefinedVrFinding {
  *   and still answers it whenever the fabricated VR is outside the 34 PS3.5
  *   §6.2 defines. It cannot when the fabricated VR is one of them, because those
  *   two files are byte-identical.
- * - **`embeddedAttributes[].hidden`** - see {@link EmbeddedAttributeFinding}.
- *   Each entry is a tag composed from four bytes that were sitting **inside**
- *   a value, which is the position this type exists to distrust, so on a file
- *   that populates the field at all they are document content by
- *   construction. `PRE-EXISTING` and identical on every release that has
- *   shipped the field; it is disclosed here and its remedy is its own slice,
- *   alongside the cap that field is also missing.
  * - **`contextPath`, on all four findings that carry one** - see
  *   {@link DeidentifiedAttribute.contextPath}, which holds the measurement. The
  *   segment tags come off the wire with no table behind them, so a fabricated
@@ -2714,8 +2764,18 @@ interface UndefinedVrFinding {
  *   same file the de-identified object itself re-emits the fabricated header, so
  *   redacting this field does not make the object safe.**
  *
+ * `embeddedAttributes[].hidden` **left that list** in
+ * `DICOM-DIAGNOSTIC-PHI-RESIDUALS` - an entry is now a literal PS3.15 Table
+ * E.1-1 row, so it is not value-bearing. Its own disclosure had been reworded
+ * twice by then, and this repo deletes a disclosure at that point rather than
+ * writing a third; what is true of the field is stated once, on
+ * {@link EmbeddedAttributeFinding}. The field is **still uncapped**.
+ *
  * So "the report is safe to log apart from `uidMap`" is **not** an accurate
  * description of this type, and was corrected rather than kept convenient.
+ * **This is the only copy of that list.** Two others lived in module docstrings,
+ * still naming `hidden` after it left and never naming `contextPath` at all; a
+ * graded pass found them and they were deleted rather than resynced.
  *
  * @example
  * ```ts
@@ -2994,9 +3054,8 @@ declare class DeidentifyError extends Error {
  * action map ({@link annexE}). It is a **pure** function: the input {@link Dataset}
  * is never mutated; a fresh `Dataset` (with a rebuilt element map and File Meta)
  * is returned alongside a {@link DeidentifyReport} whose non-value-free fields
- * are named on that type: `uidMap`, `removedPrivateTags`,
- * `unauditableSequences[].tag` and `embeddedAttributes[].hidden`. Read the list
- * there, never a count quoted elsewhere.
+ * are named on that type. **The list is deliberately not copied here** - see
+ * `./index.ts` for what a third copy of it cost.
  *
  * **What it does**
  * - Resolves each attribute's action (basic profile, overridden by an active

package/dist/index.mjs

@@ -9,7 +9,7 @@ var __export = (target, all) => {
 };
 
 // src/version.ts
-var VERSION = "0.0.13";
+var VERSION = "0.0.14";
 
 // src/dictionary/index.ts
 var dictionary_exports = {};
@@ -12206,7 +12206,11 @@ var WARNING_MESSAGES = Object.freeze({
   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.",
   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.",
+  // 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.",
   DICOM_GROUP_LENGTH_IN_DATASET: "Retired Group Length element ({tag}) encountered in dataset; preserved as-is.",
   // 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
@@ -12252,10 +12256,10 @@ var WARNING_MESSAGES = Object.freeze({
   // `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.",
+  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.
@@ -12318,8 +12322,8 @@ function oddLengthValuePadded(position, tag, declaredLength) {
 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 });
@@ -12351,11 +12355,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);
@@ -12460,18 +12464,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];
@@ -15223,6 +15227,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;
@@ -15246,15 +15254,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;
 }
@@ -15459,8 +15471,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;
   }
@@ -15468,11 +15480,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;
 }