@cornerstonejs/metadata 5.0.0

package/dist/esm/utilities/metadataProvider/pixelDataUpdate.js

@@ -0,0 +1,133 @@
+import { MetadataModules } from '../../enums';
+import { addTypedProvider } from '../../metaData';
+import { getSingleBufferFromArray } from '../bulkDataFromArray';
+function normalizePaletteLUT(raw) {
+    if (raw instanceof ArrayBuffer) {
+        const len = raw.byteLength;
+        return {
+            view: len <= 256 ? new Uint8Array(raw) : new Uint16Array(raw),
+            byteLength: len,
+        };
+    }
+    if (ArrayBuffer.isView(raw)) {
+        const v = raw;
+        return { view: v, byteLength: v.byteLength };
+    }
+    if (Array.isArray(raw)) {
+        const view = getSingleBufferFromArray(raw);
+        if (view) {
+            return {
+                view: view,
+                byteLength: view.byteLength,
+            };
+        }
+    }
+    const inline = raw != null &&
+        typeof raw === 'object' &&
+        'InlineBinary' in raw &&
+        typeof raw.InlineBinary === 'string';
+    if (inline) {
+        const b64 = raw.InlineBinary;
+        const binary = atob(b64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return {
+            view: bytes,
+            byteLength: bytes.byteLength,
+        };
+    }
+    const desc = describeValue(raw);
+    throw new Error('Palette color lookup table data could not be normalized: expected ArrayBuffer, ArrayBufferView, or object with InlineBinary string. ' +
+        desc);
+}
+function normalizePaletteLUTToFinal(raw, descriptor, color) {
+    descriptor[0] ||= 65536;
+    const tableLen = descriptor[0];
+    const bits = descriptor[2] ?? 16;
+    const { view, byteLength } = normalizePaletteLUT(raw);
+    const expectedByteLengths = [tableLen, tableLen * 2];
+    if (!expectedByteLengths.includes(byteLength)) {
+        const actualEntries = byteLength === tableLen ? view.length : Math.floor(byteLength / 2);
+        throw new Error(`Palette color lookup table length mismatch (${color}): descriptor has ${tableLen} entries (expected byteLength ${tableLen} or ${tableLen * 2}), but got ${byteLength} bytes (${actualEntries} effective entries). This may indicate duplicated or concatenated buffer data from the natural filter.`);
+    }
+    const use8 = tableLen === byteLength;
+    if (use8) {
+        return view instanceof Uint8Array ? view : new Uint8Array(view);
+    }
+    return view instanceof Uint16Array
+        ? view
+        : new Uint16Array(view.buffer, view.byteOffset, view.byteLength / 2);
+}
+function describeValue(raw) {
+    if (raw === null)
+        return 'Got null.';
+    if (raw === undefined)
+        return 'Got undefined.';
+    if (typeof raw !== 'object')
+        return `Got primitive: ${typeof raw}.`;
+    const obj = raw;
+    const constructorName = obj.constructor != null && typeof obj.constructor === 'function'
+        ? obj.constructor.name
+        : 'unknown';
+    const keys = Object.keys(obj);
+    const preview = {};
+    for (const k of keys) {
+        const v = obj[k];
+        if (v === null)
+            preview[k] = 'null';
+        else if (v === undefined)
+            preview[k] = 'undefined';
+        else if (typeof v === 'string')
+            preview[k] =
+                v.length > 80
+                    ? `"${v.slice(0, 80)}..." (len=${v.length})`
+                    : JSON.stringify(v);
+        else if (Array.isArray(v))
+            preview[k] =
+                `Array(${v.length})${v.length > 0 ? ` e.g. ${JSON.stringify(v[0])}` : ''}`;
+        else if (v instanceof ArrayBuffer)
+            preview[k] = `ArrayBuffer(${v.byteLength})`;
+        else if (ArrayBuffer.isView(v))
+            preview[k] =
+                `${v.constructor?.name ?? 'ArrayBufferView'}(${v.byteLength})`;
+        else
+            preview[k] = typeof v;
+    }
+    return `Got object: constructor=${constructorName}, keys=[${keys.join(', ')}], preview=${JSON.stringify(preview)}.`;
+}
+export function pixelDataUpdate(next, query, data, options) {
+    const basePixelData = next(query, data, options);
+    if (!basePixelData) {
+        return basePixelData;
+    }
+    const result = { ...basePixelData };
+    const { redPaletteColorLookupTableData, greenPaletteColorLookupTableData, bluePaletteColorLookupTableData, pixelPaddingValue, pixelPaddingRangeLimit, pixelRepresentation, } = basePixelData;
+    if (redPaletteColorLookupTableData != null &&
+        greenPaletteColorLookupTableData != null &&
+        bluePaletteColorLookupTableData != null) {
+        result.redPaletteColorLookupTableData = normalizePaletteLUTToFinal(redPaletteColorLookupTableData, result.redPaletteColorLookupTableDescriptor, 'red');
+        result.greenPaletteColorLookupTableData = normalizePaletteLUTToFinal(greenPaletteColorLookupTableData, result.greenPaletteColorLookupTableDescriptor, 'green');
+        result.bluePaletteColorLookupTableData = normalizePaletteLUTToFinal(bluePaletteColorLookupTableData, result.bluePaletteColorLookupTableDescriptor, 'blue');
+    }
+    if (pixelRepresentation == 1) {
+        if (pixelPaddingValue < 0) {
+            result.pixelPaddingValue = pixelPaddingValue & 0xffff;
+        }
+        if (pixelPaddingRangeLimit < 0) {
+            result.pixelPaddingValue = pixelPaddingRangeLimit & 0xffff;
+        }
+        const { smallestPixelValue, largestPixelValue } = result;
+        if (smallestPixelValue < 0) {
+            result.smallestPixelValue = smallestPixelValue & 0xffff;
+        }
+        if (largestPixelValue < 0) {
+            result.largestPixelValue = largestPixelValue & 0xffff;
+        }
+    }
+    return result;
+}
+export function registerPixelDataUpdate() {
+    addTypedProvider(MetadataModules.IMAGE_PIXEL, pixelDataUpdate);
+}

package/dist/esm/utilities/metadataProvider/scalingFromInstance.d.ts

@@ -0,0 +1 @@
+export declare function registerScalingFromInstanceProvider(): void;

package/dist/esm/utilities/metadataProvider/scalingFromInstance.js

@@ -0,0 +1,148 @@
+import { addTypedProvider } from '../../metaData';
+import { MetadataModules } from '../../enums';
+import { calculateSUVScalingFactors } from '@cornerstonejs/calculate-suv';
+function timeToString(v) {
+    if (typeof v === 'string')
+        return v;
+    if (v && typeof v === 'object' && !Array.isArray(v)) {
+        const t = v;
+        const hours = `${t?.hours ?? '00'}`.padStart(2, '0');
+        const minutes = `${t?.minutes ?? '00'}`.padStart(2, '0');
+        const seconds = `${t?.seconds ?? '00'}`.padStart(2, '0');
+        const fractionalSeconds = `${t?.fractionalSeconds ?? '000000'}`.padEnd(6, '0');
+        return `${hours}${minutes}${seconds}.${fractionalSeconds}`;
+    }
+    return v;
+}
+function dateToString(v) {
+    if (typeof v === 'string')
+        return v;
+    if (v && typeof v === 'object' && !Array.isArray(v) && 'year' in v) {
+        const d = v;
+        const month = `${d.month}`.padStart(2, '0');
+        const day = `${d.day}`.padStart(2, '0');
+        return `${d.year}${month}${day}`;
+    }
+    return v;
+}
+function parseNumber(v) {
+    if (typeof v === 'number' && !Number.isNaN(v))
+        return v;
+    if (typeof v === 'string') {
+        const n = Number(v);
+        return Number.isNaN(n) ? undefined : n;
+    }
+    return undefined;
+}
+function getRadiopharmaceuticalInfo(data) {
+    const ri = data.RadiopharmaceuticalInfo;
+    if (ri == null || typeof ri !== 'object')
+        return undefined;
+    const first = Array.isArray(ri)
+        ? ri[0]
+        : (ri[0] ?? ri);
+    return first && typeof first === 'object' && !Array.isArray(first)
+        ? first
+        : undefined;
+}
+function buildPTInstanceMetadataFromData(data) {
+    if (data.Modality !== 'PT')
+        return null;
+    const { SeriesDate: seriesDate, SeriesTime: seriesTime, AcquisitionDate: acquisitionDate, AcquisitionTime: acquisitionTime, PatientWeight: patientWeight, CorrectedImage: correctedImage, Units: units, DecayCorrection: decayCorrection, } = data;
+    const ri = getRadiopharmaceuticalInfo(data);
+    if (!ri)
+        return null;
+    const radionuclideTotalDose = parseNumber(ri.RadionuclideTotalDose);
+    const radionuclideHalfLife = parseNumber(ri.RadionuclideHalfLife);
+    const radiopharmaceuticalStartDateTime = ri.RadiopharmaceuticalStartDateTime;
+    const radiopharmaceuticalStartTime = ri.RadiopharmaceuticalStartTime;
+    const patientWeightNum = parseNumber(patientWeight);
+    if (seriesDate === undefined ||
+        seriesTime === undefined ||
+        patientWeightNum === undefined ||
+        acquisitionDate === undefined ||
+        acquisitionTime === undefined ||
+        correctedImage === undefined ||
+        units === undefined ||
+        decayCorrection === undefined ||
+        radionuclideTotalDose === undefined ||
+        radionuclideHalfLife === undefined) {
+        return null;
+    }
+    const toDate = (v) => typeof v === 'string'
+        ? v
+        : v && typeof v === 'object' && 'year' in v
+            ? dateToString(v)
+            : v;
+    const toTime = (v) => typeof v === 'string'
+        ? v
+        : v && typeof v === 'object'
+            ? timeToString(v)
+            : v;
+    const correctedImageValue = typeof correctedImage === 'string'
+        ? correctedImage.split('\\')
+        : Array.isArray(correctedImage)
+            ? correctedImage
+            : correctedImage;
+    const instanceMetadata = {
+        CorrectedImage: correctedImageValue,
+        Units: units,
+        RadionuclideHalfLife: radionuclideHalfLife,
+        RadionuclideTotalDose: radionuclideTotalDose,
+        DecayCorrection: decayCorrection,
+        PatientWeight: patientWeightNum,
+        SeriesDate: dateToString(seriesDate),
+        SeriesTime: timeToString(seriesTime),
+        AcquisitionDate: dateToString(acquisitionDate),
+        AcquisitionTime: timeToString(acquisitionTime),
+    };
+    if (radiopharmaceuticalStartDateTime !== undefined) {
+        instanceMetadata.RadiopharmaceuticalStartDateTime = dateToString(radiopharmaceuticalStartDateTime);
+    }
+    if (radiopharmaceuticalStartTime !== undefined) {
+        instanceMetadata.RadiopharmaceuticalStartTime = timeToString(radiopharmaceuticalStartTime);
+    }
+    if (data.PatientSex !== undefined)
+        instanceMetadata.PatientSex = data.PatientSex;
+    if (data.PatientSize !== undefined)
+        instanceMetadata.PatientSize = data.PatientSize;
+    return instanceMetadata;
+}
+function scalingFromInstanceProvider(next, query, data, options) {
+    if (data == null || typeof data !== 'object') {
+        return next(query, data, options);
+    }
+    const d = data;
+    if (d.Modality === 'RTDOSE') {
+        const doseGridScaling = parseNumber(d.DoseGridScaling);
+        const { DoseSummation, DoseType, DoseUnit } = d;
+        if (doseGridScaling !== undefined ||
+            DoseSummation !== undefined ||
+            DoseType !== undefined ||
+            DoseUnit !== undefined) {
+            return {
+                DoseGridScaling: doseGridScaling,
+                DoseSummation,
+                DoseType,
+                DoseUnit,
+            };
+        }
+    }
+    if (d.Modality === 'PT') {
+        const instanceMetadata = buildPTInstanceMetadataFromData(d);
+        if (!instanceMetadata) {
+            return next(query, undefined, options);
+        }
+        try {
+            const factors = calculateSUVScalingFactors([instanceMetadata]);
+            return factors[0] ?? next(query, undefined, options);
+        }
+        catch {
+            return next(query, undefined, options);
+        }
+    }
+    return next(query, undefined, options);
+}
+export function registerScalingFromInstanceProvider() {
+    addTypedProvider(MetadataModules.SCALING, scalingFromInstanceProvider, { priority: 0, isDefault: true });
+}

package/dist/esm/utilities/metadataProvider/tagModules.d.ts

@@ -0,0 +1,7 @@
+import { type TypedProvider } from '../../metaData';
+export declare function clearTagModules(): void;
+export declare function tagModules(module: string, dataLookupName?: string): TypedProvider;
+export declare const MODULE_PRIORITY: {
+    priority: number;
+};
+export declare function registerTagModules(): void;

package/dist/esm/utilities/metadataProvider/tagModules.js

@@ -0,0 +1,62 @@
+import { addTypedProvider } from '../../metaData';
+import { mapModuleTags } from '../Tags';
+import { dataLookup, DATA_PRIORITY, instanceLookup } from './dataLookup';
+import { makeArrayLike } from './makeArrayLike';
+import { metadataLog } from '../logging';
+const log = metadataLog.getLogger('tagModules');
+const mapModules = new Map();
+export function clearTagModules() {
+    mapModules.clear();
+}
+export function tagModules(module, dataLookupName = 'instance') {
+    if (!mapModuleTags.has(module)) {
+        throw new Error(`No module found: ${module}`);
+    }
+    if (mapModules.has(module)) {
+        return mapModules.get(module);
+    }
+    if (dataLookupName === 'instance') {
+        addTypedProvider(module, instanceLookup, { priority: 25_000 });
+    }
+    else if (dataLookupName) {
+        addTypedProvider(module, dataLookup(dataLookupName), { priority: 25_000 });
+    }
+    const moduleProvider = (next, query, data, options) => {
+        const keys = mapModuleTags.get(module);
+        const destName = options?.destName || 'lowerName';
+        if (!data) {
+            return next(query, data, options);
+        }
+        const result = {};
+        for (const key of keys) {
+            let value = data[key.name];
+            if (value !== undefined) {
+                if (mapModules.has(key.name)) {
+                    log.debug('Getting nested module', key.name);
+                    const newValue = [];
+                    for (const entry of value) {
+                        if (!entry) {
+                            continue;
+                        }
+                        newValue.push(mapModules.get(key.name)(null, query, entry, options?.[key.name]));
+                    }
+                    value = newValue.length === 1 ? makeArrayLike(newValue[0]) : newValue;
+                }
+                result[key[destName]] = value;
+            }
+        }
+        return result;
+    };
+    mapModules.set(module, moduleProvider);
+    return moduleProvider;
+}
+export const MODULE_PRIORITY = { priority: -1_000 };
+export function registerTagModules() {
+    for (const module of mapModuleTags.keys()) {
+        const providerFn = tagModules(module);
+        if (providerFn) {
+            addTypedProvider(module, providerFn, MODULE_PRIORITY);
+        }
+        addTypedProvider(module, instanceLookup, DATA_PRIORITY);
+    }
+}

package/dist/esm/utilities/metadataProvider/transferSyntaxProvider.d.ts

@@ -0,0 +1,2 @@
+export declare function transferSyntaxProvider(next: any, query: any, data: any, options: any): any;
+export declare function registerTransferSyntaxProvider(): void;

package/dist/esm/utilities/metadataProvider/transferSyntaxProvider.js

@@ -0,0 +1,20 @@
+import { MetadataModules } from '../../enums';
+import { addTypedProvider } from '../../metaData';
+import isVideoTransferSyntax from '../isVideoTransferSyntax';
+export function transferSyntaxProvider(next, query, data, options) {
+    const fmiBase = next(query, data, options);
+    if (fmiBase) {
+        const transferSyntaxUID = fmiBase.transferSyntaxUID || fmiBase.availableTransferSyntaxUID;
+        const isVideo = isVideoTransferSyntax(transferSyntaxUID);
+        return {
+            ...fmiBase,
+            transferSyntaxUID: Array.isArray(transferSyntaxUID)
+                ? transferSyntaxUID[0]
+                : transferSyntaxUID,
+            isVideo,
+        };
+    }
+}
+export function registerTransferSyntaxProvider() {
+    addTypedProvider(MetadataModules.TRANSFER_SYNTAX, transferSyntaxProvider);
+}

package/dist/esm/utilities/metadataProvider/uriModule.d.ts

@@ -0,0 +1,19 @@
+export interface UriModule {
+    baseImageId: string;
+    frameNumber?: number;
+    framesString?: string;
+    remaining?: string;
+    sopInstanceUID?: string;
+    seriesInstanceUID?: string;
+    studyInstanceUID?: string;
+}
+export declare const frameRangeExtractor: RegExp;
+export declare function getUriModule(imageId: any): {
+    baseImageId: any;
+    frameNumber: number;
+    framesString: any;
+    remaining: any;
+};
+export declare function uriModuleProvider(next: any, imageId: any, data: any, options: any): any;
+export declare function registerUriModule(): void;
+export default getUriModule;

package/dist/esm/utilities/metadataProvider/uriModule.js

@@ -0,0 +1,26 @@
+import { MetadataModules } from '../../enums';
+import { addTypedProvider } from '../../metaData';
+export const frameRangeExtractor = /(\/frames\/|[&?]frameNumber=|[&?]frame=)([^/&?]*)(.*)/i;
+export function getUriModule(imageId) {
+    const framesMatch = imageId.match(frameRangeExtractor);
+    if (!framesMatch) {
+        return;
+    }
+    const baseImageId = imageId.substring(0, framesMatch.index);
+    const framesString = framesMatch[2];
+    const frameNumber = parseFloat(framesString);
+    const remaining = framesMatch[3];
+    return {
+        baseImageId,
+        frameNumber,
+        framesString,
+        remaining,
+    };
+}
+export function uriModuleProvider(next, imageId, data, options) {
+    return getUriModule(imageId) || next(imageId, data, options);
+}
+export function registerUriModule() {
+    addTypedProvider(MetadataModules.URI_MODULE, uriModuleProvider);
+}
+export default getUriModule;

package/dist/esm/utilities/modules/cine.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/cine.js

@@ -0,0 +1,4 @@
+export const tags = [
+    'FrameTime',
+    'RecommendedDisplayFrameRate',
+];

package/dist/esm/utilities/modules/clinicalTrial.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/clinicalTrial.js

@@ -0,0 +1,6 @@
+export const tags = [
+    'ClinicalTrialSponsorName',
+    'ClinicalTrialSiteID',
+    'ClinicalTrialSiteName',
+    'ClinicalTrialSubjectID',
+];

package/dist/esm/utilities/modules/ecg.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/ecg.js

@@ -0,0 +1,11 @@
+export const tags = [
+    'StudyInstanceUID',
+    'SeriesInstanceUID',
+    'SeriesDescription',
+    'SeriesNumber',
+    'SeriesDate',
+    'SeriesTime',
+    'Modality',
+    'SOPInstanceUID',
+    'SOPClassUID',
+];

package/dist/esm/utilities/modules/generalImage.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/generalImage.js

@@ -0,0 +1,14 @@
+export const tags = [
+    'SOPInstanceUID',
+    'SOPClassUID',
+    'InstanceNumber',
+    'InstanceCreationDate',
+    'InstanceCreationTime',
+    'ContentTime',
+    'LossyImageCompression',
+    'LossyImageCompressionRatio',
+    'LossyImageCompressionMethod',
+    'FrameOfReferenceUID',
+    'NumberOfFrames',
+    'PixelSpacing',
+];

package/dist/esm/utilities/modules/generalSeries.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/generalSeries.js

@@ -0,0 +1,11 @@
+export const tags = [
+    'StudyInstanceUID',
+    'SeriesInstanceUID',
+    'Modality',
+    'SeriesDescription',
+    'SeriesNumber',
+    'SeriesDate',
+    'SeriesTime',
+    'AcquisitionDate',
+    'AcquisitionTime',
+];

package/dist/esm/utilities/modules/generalStudy.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/generalStudy.js

@@ -0,0 +1,7 @@
+export const tags = [
+    'StudyInstanceUID',
+    'StudyDescription',
+    'StudyDate',
+    'StudyTime',
+    'AccessionNumber',
+];

package/dist/esm/utilities/modules/imagePixel.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/imagePixel.js

@@ -0,0 +1,31 @@
+export const tags = [
+    'SamplesPerPixel',
+    'PhotometricInterpretation',
+    'PlanarConfiguration',
+    'Rows',
+    'Columns',
+    'BitsAllocated',
+    'BitsStored',
+    'HighBit',
+    'PixelRepresentation',
+    ['SmallestPixelValue', '00280106'],
+    ['LargestPixelValue', '00280107'],
+    'PixelPaddingValue',
+    'PixelPaddingRangeLimit',
+    'RedPaletteColorLookupTableDescriptor',
+    'GreenPaletteColorLookupTableDescriptor',
+    'BluePaletteColorLookupTableDescriptor',
+    'AlphaPaletteColorLookupTableDescriptor',
+    'RedPaletteColorLookupTableData',
+    'GreenPaletteColorLookupTableData',
+    'BluePaletteColorLookupTableData',
+    'AlphaPaletteColorLookupTableData',
+    'PaletteColorLookupTableUID',
+    'DistanceSourceToDetector',
+    'DistanceSourceToPatient',
+    'EstimatedRadiographicMagnificationFactor',
+    'DistanceSourceToEntrance',
+    'PixelSpacingCalibrationType',
+    'PixelSpacingCalibrationDescription',
+    'SequenceOfUltrasoundRegions',
+];

package/dist/esm/utilities/modules/imagePlane.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/imagePlane.js

@@ -0,0 +1,8 @@
+export const tags = [
+    'ImagerPixelSpacing',
+    'ImageOrientationPatient',
+    'ImagePositionPatient',
+    'SpacingBetweenSlices',
+    'SliceThickness',
+    'SliceLocation',
+];

package/dist/esm/utilities/modules/index.d.ts

@@ -0,0 +1,5 @@
+export declare const USRegionChild = "usRegionChild";
+export declare const CLINICAL_TRIAL = "clinicalTrialModule";
+export declare const RadiopharmaceuticalInfoModule = "RadiopharmaceuticalInfo";
+export type ModuleTagEntry = string | [name: string, hexOverride: string];
+export declare const moduleDefinitions: [string | null, ModuleTagEntry[]][];

package/dist/esm/utilities/modules/index.js

@@ -0,0 +1,48 @@
+import { MetadataModules } from '../../enums';
+import { tags as transferSyntaxTags } from './transferSyntax';
+import { tags as cineTags } from './cine';
+import { tags as ptIsotopeTags } from './ptIsotope';
+import { tags as radiopharmaceuticalInfoTags } from './radiopharmaceuticalInfo';
+import { tags as ptImageTags } from './ptImage';
+import { tags as ptSeriesTags } from './ptSeries';
+import { tags as patientTags } from './patient';
+import { tags as patientStudyTags } from './patientStudy';
+import { tags as generalStudyTags } from './generalStudy';
+import { tags as generalSeriesTags } from './generalSeries';
+import { tags as clinicalTrialTags } from './clinicalTrial';
+import { tags as sopCommonTags } from './sopCommon';
+import { tags as ecgTags } from './ecg';
+import { tags as generalImageTags } from './generalImage';
+import { tags as imagePlaneTags } from './imagePlane';
+import { tags as imagePixelTags } from './imagePixel';
+import { tags as voiLutTags } from './voiLut';
+import { tags as modalityLutTags } from './modalityLut';
+import { tags as ultrasoundEnhancedRegionTags } from './ultrasoundEnhancedRegion';
+import { tags as usRegionChildTags } from './usRegionChild';
+import { tags as unassignedTags } from './unassigned';
+export const USRegionChild = 'usRegionChild';
+export const CLINICAL_TRIAL = 'clinicalTrialModule';
+export const RadiopharmaceuticalInfoModule = 'RadiopharmaceuticalInfo';
+export const moduleDefinitions = [
+    [MetadataModules.TRANSFER_SYNTAX, transferSyntaxTags],
+    [MetadataModules.CINE, cineTags],
+    [MetadataModules.PET_ISOTOPE, ptIsotopeTags],
+    [RadiopharmaceuticalInfoModule, radiopharmaceuticalInfoTags],
+    [MetadataModules.PET_IMAGE, ptImageTags],
+    [MetadataModules.PET_SERIES, ptSeriesTags],
+    [MetadataModules.PATIENT, patientTags],
+    [MetadataModules.PATIENT_STUDY, patientStudyTags],
+    [MetadataModules.GENERAL_STUDY, generalStudyTags],
+    [MetadataModules.GENERAL_SERIES, generalSeriesTags],
+    [CLINICAL_TRIAL, clinicalTrialTags],
+    [MetadataModules.SOP_COMMON, sopCommonTags],
+    [MetadataModules.ECG, ecgTags],
+    [MetadataModules.GENERAL_IMAGE, generalImageTags],
+    [MetadataModules.IMAGE_PLANE, imagePlaneTags],
+    [MetadataModules.IMAGE_PIXEL, imagePixelTags],
+    [MetadataModules.VOI_LUT, voiLutTags],
+    [MetadataModules.MODALITY_LUT, modalityLutTags],
+    [MetadataModules.ULTRASOUND_ENHANCED_REGION, ultrasoundEnhancedRegionTags],
+    [USRegionChild, usRegionChildTags],
+    [null, unassignedTags],
+];

package/dist/esm/utilities/modules/modalityLut.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/modalityLut.js

@@ -0,0 +1,5 @@
+export const tags = [
+    'RescaleIntercept',
+    'RescaleSlope',
+    'RescaleType',
+];

package/dist/esm/utilities/modules/patient.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/patient.js

@@ -0,0 +1,6 @@
+export const tags = [
+    'PatientID',
+    'PatientName',
+    'PatientBirthDate',
+    'PatientBirthTime',
+];

package/dist/esm/utilities/modules/patientStudy.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/patientStudy.js

@@ -0,0 +1,6 @@
+export const tags = [
+    'PatientAge',
+    'PatientSize',
+    'PatientSex',
+    'PatientWeight',
+];