@cornerstonejs/metadata 5.0.0

package/dist/esm/utilities/Tags.js

@@ -0,0 +1,112 @@
+import * as metaData from '../metaData';
+import dcmjs from 'dcmjs';
+import { moduleDefinitions, USRegionChild, CLINICAL_TRIAL, RadiopharmaceuticalInfoModule, } from './modules';
+const dicomDictionary = dcmjs.data.DicomMetaDictionary.dictionary;
+const nameMap = dcmjs.data.DicomMetaDictionary.nameMap;
+export { USRegionChild, CLINICAL_TRIAL, RadiopharmaceuticalInfoModule };
+export function createTagEntry(hexTag, ...groups) {
+    return {
+        tag: hexTag,
+        groups,
+        xTag: null,
+        primaryGroup: null,
+        name: null,
+        lowerName: null,
+        vr: null,
+        vm: null,
+    };
+}
+export function parseVm(vm) {
+    if (vm === undefined || vm === null) {
+        return null;
+    }
+    if (typeof vm === 'number') {
+        return vm;
+    }
+    const n = parseInt(vm, 10);
+    if (String(n) === vm) {
+        return n;
+    }
+    return 0;
+}
+export function dictionaryLookup(hexTag) {
+    return dicomDictionary[hexTag.toUpperCase()];
+}
+export function getTagCodeByName(name) {
+    return mapTagInfo.get(name)?.tag;
+}
+export const mapModuleTags = new Map();
+export const mapTagInfo = new Map();
+export function addTag(name, value) {
+    if (name && value.name && name !== value.name) {
+        throw new Error(`Tag name provided and value don't match: ${name} !== ${value.name}`);
+    }
+    value.name ||= name;
+    value.lowerName ||= metaData.toLowerCamelTag(name);
+    Tags[name] = value;
+    const { tag: hexTag } = value;
+    value.primaryGroup ||= value.groups?.[0];
+    const { groups } = value;
+    mapTagInfo.set(name, value);
+    if (hexTag) {
+        value.xTag = `x${hexTag.toLowerCase()}`;
+        value.tag = hexTag.toUpperCase();
+        mapTagInfo.set(value.xTag, value);
+        mapTagInfo.set(value.tag, value);
+        if (!value.vr) {
+            const dictEntry = dicomDictionary[value.tag];
+            if (dictEntry) {
+                value.vr = dictEntry.vr;
+                value.vm = parseVm(dictEntry.vm);
+            }
+        }
+    }
+    if (groups?.length) {
+        for (const group of groups) {
+            let moduleEntries = mapModuleTags.get(group);
+            if (!moduleEntries) {
+                moduleEntries = [value];
+                mapModuleTags.set(group, moduleEntries);
+                return;
+            }
+            const foundIndex = moduleEntries.findIndex((it) => it.name === name);
+            if (foundIndex === -1) {
+                moduleEntries.push(value);
+            }
+            else {
+                moduleEntries[foundIndex] = value;
+            }
+        }
+    }
+}
+export function resolveHexFromKeyword(keyword) {
+    const entry = nameMap[keyword];
+    if (!entry) {
+        return undefined;
+    }
+    return entry.tag.substring(1, 5) + entry.tag.substring(6, 10);
+}
+export const Tags = {};
+const tagGroups = new Map();
+for (const [moduleName, keywords] of moduleDefinitions) {
+    for (const entry of keywords) {
+        const keyword = typeof entry === 'string' ? entry : entry[0];
+        const hexOverride = typeof entry === 'string' ? undefined : entry[1];
+        let data = tagGroups.get(keyword);
+        if (!data) {
+            const hex = hexOverride ?? resolveHexFromKeyword(keyword);
+            data = { hex, groups: [] };
+            tagGroups.set(keyword, data);
+        }
+        if (moduleName !== null) {
+            data.groups.push(moduleName);
+        }
+    }
+}
+for (const [keyword, { hex, groups }] of tagGroups) {
+    if (!hex) {
+        console.warn(`Tags: keyword "${keyword}" not found in dcmjs nameMap`);
+        continue;
+    }
+    addTag(keyword, createTagEntry(hex, ...groups));
+}

package/dist/esm/utilities/bulkDataFromArray.d.ts

@@ -0,0 +1 @@
+export declare function getSingleBufferFromArray(raw: unknown): ArrayBufferView | undefined;

package/dist/esm/utilities/bulkDataFromArray.js

@@ -0,0 +1,38 @@
+function asView(buf) {
+    if (buf instanceof ArrayBuffer) {
+        return new Uint8Array(buf);
+    }
+    return buf;
+}
+export function getSingleBufferFromArray(raw) {
+    if (raw instanceof ArrayBuffer || ArrayBuffer.isView(raw)) {
+        return asView(raw);
+    }
+    if (!Array.isArray(raw) || raw.length === 0) {
+        return undefined;
+    }
+    const first = raw[0];
+    if (first === undefined ||
+        first === null ||
+        (!(first instanceof ArrayBuffer) && !ArrayBuffer.isView(first))) {
+        return undefined;
+    }
+    if (raw.length === 1) {
+        return asView(first);
+    }
+    const views = raw.filter((item) => item != null && (item instanceof ArrayBuffer || ArrayBuffer.isView(item)));
+    if (views.length === 0)
+        return undefined;
+    const totalLength = views.reduce((sum, v) => sum +
+        (v instanceof ArrayBuffer
+            ? v.byteLength
+            : v.byteLength), 0);
+    const out = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const v of views) {
+        const view = asView(v);
+        out.set(new Uint8Array(view.buffer, view.byteOffset, view.byteLength), offset);
+        offset += view.byteLength;
+    }
+    return out;
+}

package/dist/esm/utilities/calibratedPixelSpacingMetadataProvider.d.ts

@@ -0,0 +1,7 @@
+import type { IImageCalibration } from '../types/IImageCalibration';
+declare const metadataProvider: {
+    add: (imageId: string, payload: IImageCalibration) => void;
+    get: (type: string, imageId: string) => IImageCalibration;
+    clear: () => void;
+};
+export default metadataProvider;

package/dist/esm/utilities/calibratedPixelSpacingMetadataProvider.js

@@ -0,0 +1,21 @@
+import imageIdToURI from './imageIdToURI';
+import { MetadataModules } from '../enums';
+import { clearQuery } from '../metaData';
+const state = new Map();
+const metadataProvider = {
+    add: (imageId, payload) => {
+        const imageURI = imageIdToURI(imageId);
+        state.set(imageURI, payload);
+        clearQuery(MetadataModules.IMAGE_PLANE, imageId);
+    },
+    get: (type, imageId) => {
+        if (type === 'calibratedPixelSpacing') {
+            const imageURI = imageIdToURI(imageId);
+            return state.get(imageURI);
+        }
+    },
+    clear: () => {
+        state.clear();
+    },
+};
+export default metadataProvider;

package/dist/esm/utilities/dicomStream/MetaDataIterator.d.ts

@@ -0,0 +1,11 @@
+export declare class MetaDataIterator {
+    metadata: any;
+    constructor(metadata: any);
+    syncIterator(listener: any, object?: any): void;
+}
+export type MetadataValue = {
+    Value?: unknown[];
+    vr: string;
+    BulkDataURI?: string;
+    InlineBinary?: string;
+};

package/dist/esm/utilities/dicomStream/MetaDataIterator.js

@@ -0,0 +1,58 @@
+import { dictionaryLookup, mapTagInfo } from '../Tags';
+export class MetaDataIterator {
+    constructor(metadata) {
+        this.metadata = metadata;
+    }
+    syncIterator(listener, object = this.metadata) {
+        for (const [key, value] of Object.entries(object)) {
+            if (key === '_vrMap' || value === undefined) {
+                continue;
+            }
+            if (value === null) {
+                listener.addTag(key, { length: 0 });
+                listener.pop();
+                continue;
+            }
+            const vr = value.vr;
+            const tagData = mapTagInfo.get(key);
+            const dictEntry = !tagData ? dictionaryLookup(key) : undefined;
+            const hasBulk = !value.Value &&
+                (value.BulkDataURI ??
+                    value.InlineBinary);
+            if (!value.Value && !hasBulk) {
+                continue;
+            }
+            listener.addTag(key, {
+                vr,
+                name: tagData?.name || dictEntry?.name,
+                vm: tagData?.vm ?? dictEntry?.vm,
+            });
+            if (vr === 'SQ') {
+                for (const v of value.Value) {
+                    listener.startObject();
+                    this.syncIterator(listener, v);
+                    listener.pop();
+                }
+                listener.pop();
+                continue;
+            }
+            if (hasBulk) {
+                listener.value({
+                    BulkDataURI: value.BulkDataURI,
+                    InlineBinary: value.InlineBinary,
+                });
+                listener.pop();
+                continue;
+            }
+            if (value.vr === 'CS' &&
+                value.Value.length === 1 &&
+                String(value.Value[0]).indexOf('\\') !== -1) {
+                value.Value = String(value.Value[0]).split('\\');
+            }
+            for (const v of value.Value) {
+                listener.value(v);
+            }
+            listener.pop();
+        }
+    }
+}

package/dist/esm/utilities/dicomStream/NaturalTagListener.d.ts

@@ -0,0 +1,22 @@
+import type { IListenerInfo } from '../../types';
+export type ListenerContext = {
+    natural?: {
+        name: string;
+        singleVm: boolean | null;
+        tag: string;
+    };
+    parent?: {
+        dest: Record<string, unknown>;
+    };
+    dest?: Record<string, unknown>;
+};
+export declare class NaturalTagListener {
+    constructor(_options?: {
+        nameKey?: string;
+    });
+    static createMetadataListener(options?: {
+        nameKey?: string;
+    }): any;
+    addTag(next: (tag: string, tagInfo?: IListenerInfo) => void, tag: string, tagInfo?: IListenerInfo): void;
+    pop(next: () => unknown): unknown;
+}

package/dist/esm/utilities/dicomStream/NaturalTagListener.js

@@ -0,0 +1,106 @@
+import dcmjs from 'dcmjs';
+import { makeArrayLike } from '../metadataProvider/makeArrayLike';
+import { dictionaryLookup, mapTagInfo, parseVm } from '../Tags';
+const { DicomMetadataListener } = dcmjs.utilities;
+function resolveSingleVm(tagData, dictEntry, tagInfo) {
+    if (tagData && tagData.vm !== undefined && tagData.vm !== null) {
+        return tagData.vm === 1;
+    }
+    const vm = tagInfo?.vm ?? dictEntry?.vm;
+    if (vm !== undefined && vm !== null) {
+        const parsed = parseVm(vm);
+        if (parsed !== null) {
+            return parsed === 1;
+        }
+    }
+    return null;
+}
+function isBulkDataValue(val) {
+    if (!Array.isArray(val) || val.length === 0) {
+        return false;
+    }
+    const first = val[0];
+    if (first instanceof ArrayBuffer || ArrayBuffer.isView(first)) {
+        return true;
+    }
+    if (Array.isArray(first)) {
+        return val.every((item) => Array.isArray(item) &&
+            item.every((f) => f instanceof ArrayBuffer || ArrayBuffer.isView(f)));
+    }
+    return false;
+}
+const DEFAULT_NAME_KEY = 'name';
+export class NaturalTagListener {
+    constructor(_options) {
+    }
+    static createMetadataListener(options) {
+        return new DicomMetadataListener({}, new NaturalTagListener(options));
+    }
+    addTag(next, tag, tagInfo) {
+        const tagData = mapTagInfo.get(tag);
+        const dictEntry = !tagData ? dictionaryLookup(tag) : undefined;
+        const name = tagInfo?.name || tagData?.[DEFAULT_NAME_KEY] || dictEntry?.name || tag;
+        const singleVm = resolveSingleVm(tagData, dictEntry, tagInfo);
+        next(tag, tagInfo);
+        this.current.natural = {
+            name,
+            singleVm,
+            tag,
+        };
+    }
+    pop(next) {
+        const listener = this;
+        const nat = listener.current?.natural;
+        const parentContext = listener.current?.parent;
+        if (!nat || !parentContext?.dest) {
+            return next();
+        }
+        const result = next();
+        const parent = parentContext;
+        const raw = parent.dest[nat.tag];
+        if (raw === undefined) {
+            return result;
+        }
+        let val = raw.Value ?? raw;
+        if (Array.isArray(val) && val.length === 1 && val[0] === undefined) {
+            val = [];
+        }
+        if (isBulkDataValue(val)) {
+            parent.dest[nat.name] = val;
+            if (nat.name !== nat.tag)
+                delete parent.dest[nat.tag];
+            return result;
+        }
+        if (nat.singleVm === true && Array.isArray(val) && val.length === 1) {
+            const one = val[0];
+            if (typeof one === 'object' &&
+                one !== null &&
+                !(one instanceof ArrayBuffer) &&
+                !ArrayBuffer.isView(one)) {
+                parent.dest[nat.name] = makeArrayLike(one);
+            }
+            else {
+                parent.dest[nat.name] = one;
+            }
+            if (nat.name !== nat.tag)
+                delete parent.dest[nat.tag];
+            return result;
+        }
+        if (nat.singleVm === null &&
+            Array.isArray(val) &&
+            val.length === 1 &&
+            typeof val[0] === 'object' &&
+            val[0] !== null &&
+            !(val[0] instanceof ArrayBuffer) &&
+            !ArrayBuffer.isView(val[0])) {
+            parent.dest[nat.name] = makeArrayLike(val[0]);
+        }
+        else {
+            parent.dest[nat.name] = val;
+        }
+        if (nat.name !== nat.tag) {
+            delete parent.dest[nat.tag];
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from './MetaDataIterator';
+export * from './NaturalTagListener';
+export type { IListenerInfo, MetadataType, MetadataValueType, } from '../../types';

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

@@ -0,0 +1,2 @@
+export * from './MetaDataIterator';
+export * from './NaturalTagListener';

package/dist/esm/utilities/getNaturalizedField.d.ts

@@ -0,0 +1,3 @@
+export declare function getNaturalizedField<T = unknown>(naturalized: Record<string, unknown> | null | undefined, fieldName: string, defaultValue?: T | undefined, index?: number): unknown | T | undefined;
+export declare function getNaturalizedString(naturalized: Record<string, unknown> | null | undefined, fieldName: string, defaultValue?: string | undefined, index?: number): string | undefined;
+export declare function getNaturalizedNumber(naturalized: Record<string, unknown> | null | undefined, fieldName: string, defaultValue?: number | undefined, index?: number): number | undefined;

package/dist/esm/utilities/getNaturalizedField.js

@@ -0,0 +1,34 @@
+export function getNaturalizedField(naturalized, fieldName, defaultValue = undefined, index = 0) {
+    if (!naturalized) {
+        return defaultValue;
+    }
+    const value = naturalized[fieldName];
+    if (value === undefined || value === null) {
+        return defaultValue;
+    }
+    if (Array.isArray(value)) {
+        const indexedValue = value[index];
+        return indexedValue === undefined || indexedValue === null
+            ? defaultValue
+            : indexedValue;
+    }
+    if (index !== 0) {
+        return defaultValue;
+    }
+    return value;
+}
+export function getNaturalizedString(naturalized, fieldName, defaultValue = undefined, index = 0) {
+    const value = getNaturalizedField(naturalized, fieldName, defaultValue, index);
+    if (value === null || value === undefined) {
+        return defaultValue;
+    }
+    return String(value);
+}
+export function getNaturalizedNumber(naturalized, fieldName, defaultValue = undefined, index = 0) {
+    const value = getNaturalizedField(naturalized, fieldName, defaultValue, index);
+    if (value === null || value === undefined) {
+        return defaultValue;
+    }
+    const parsedValue = Number(value);
+    return Number.isFinite(parsedValue) ? parsedValue : defaultValue;
+}

package/dist/esm/utilities/getPixelSpacingInformation.d.ts

@@ -0,0 +1,13 @@
+import { CalibrationTypes } from '../enums';
+export declare function getERMF(instance: any): any;
+export declare function calculateRadiographicPixelSpacing(instance: any): {
+    PixelSpacing: any;
+    type: CalibrationTypes;
+    isProjection: boolean;
+};
+export declare function getPixelSpacingInformation(instance: any): {
+    PixelSpacing: any;
+    type: CalibrationTypes;
+    isProjection: boolean;
+};
+export default getPixelSpacingInformation;

package/dist/esm/utilities/getPixelSpacingInformation.js

@@ -0,0 +1,93 @@
+import { isEqual } from './isEqual';
+import { CalibrationTypes } from '../enums';
+const projectionRadiographSOPClassUIDs = new Set([
+    '1.2.840.10008.5.1.4.1.1.1',
+    '1.2.840.10008.5.1.4.1.1.1.1',
+    '1.2.840.10008.5.1.4.1.1.1.1.1',
+    '1.2.840.10008.5.1.4.1.1.1.2',
+    '1.2.840.10008.5.1.4.1.1.1.2.1',
+    '1.2.840.10008.5.1.4.1.1.1.3',
+    '1.2.840.10008.5.1.4.1.1.1.3.1',
+    '1.2.840.10008.5.1.4.1.1.12.1',
+    '1.2.840.10008.5.1.4.1.1.12.1.1',
+    '1.2.840.10008.5.1.4.1.1.12.2',
+    '1.2.840.10008.5.1.4.1.1.12.2.1',
+    '1.2.840.10008.5.1.4.1.1.12.3',
+]);
+export function getERMF(instance) {
+    const { PixelSpacing, ImagerPixelSpacing, EstimatedRadiographicMagnificationFactor: ermf, DistanceSourceToDetector: sid, DistanceSourceToEntrance: soe, DistanceSourceToPatient: sod = soe, } = instance;
+    if (ermf > 1) {
+        return ermf;
+    }
+    if (sod < sid) {
+        return sid / sod;
+    }
+    if (ImagerPixelSpacing?.[0] > PixelSpacing?.[0]) {
+        return true;
+    }
+}
+export function calculateRadiographicPixelSpacing(instance) {
+    const { PixelSpacing, ImagerPixelSpacing, PixelSpacingCalibrationType } = instance;
+    const isProjection = true;
+    if (PixelSpacing && PixelSpacingCalibrationType === 'GEOMETRY') {
+        if (isEqual(PixelSpacing, ImagerPixelSpacing)) {
+            console.warn('Calibration type is geometry, but pixel spacing and imager pixel spacing identical', PixelSpacing, ImagerPixelSpacing);
+        }
+        return {
+            PixelSpacing,
+            type: CalibrationTypes.ERMF,
+            isProjection,
+        };
+    }
+    if (PixelSpacing && PixelSpacingCalibrationType === 'FIDUCIAL') {
+        return {
+            PixelSpacing,
+            type: CalibrationTypes.CALIBRATED,
+            isProjection,
+        };
+    }
+    if (ImagerPixelSpacing) {
+        const ermf = getERMF(instance);
+        if (ermf > 1) {
+            const correctedPixelSpacing = ImagerPixelSpacing.map((pixelSpacing) => pixelSpacing / ermf);
+            return {
+                PixelSpacing: correctedPixelSpacing,
+                type: CalibrationTypes.ERMF,
+                isProjection,
+            };
+        }
+        if (ermf === true) {
+            return {
+                PixelSpacing,
+                type: CalibrationTypes.ERMF,
+                isProjection,
+            };
+        }
+        if (ermf) {
+            console.error('Illegal ERMF value:', ermf);
+        }
+        return {
+            PixelSpacing: PixelSpacing || ImagerPixelSpacing,
+            type: CalibrationTypes.PROJECTION,
+            isProjection,
+        };
+    }
+    return {
+        PixelSpacing,
+        type: CalibrationTypes.UNKNOWN,
+        isProjection,
+    };
+}
+export function getPixelSpacingInformation(instance) {
+    const { PixelSpacing, SOPClassUID } = instance;
+    const isProjection = projectionRadiographSOPClassUIDs.has(SOPClassUID);
+    if (isProjection) {
+        return calculateRadiographicPixelSpacing(instance);
+    }
+    return {
+        PixelSpacing,
+        type: CalibrationTypes.NOT_APPLICABLE,
+        isProjection: false,
+    };
+}
+export default getPixelSpacingInformation;

package/dist/esm/utilities/imageIdToURI.d.ts

@@ -0,0 +1 @@
+export default function imageIdToURI(imageId: string): string;

package/dist/esm/utilities/imageIdToURI.js

@@ -0,0 +1,15 @@
+const schemePrefixPattern = /^[a-zA-Z]+:/;
+export default function imageIdToURI(imageId) {
+    if (!imageId) {
+        return '';
+    }
+    const firstPrefixMatch = imageId.match(schemePrefixPattern);
+    if (!firstPrefixMatch) {
+        return imageId;
+    }
+    const remainder = imageId.substring(firstPrefixMatch[0].length);
+    if (!schemePrefixPattern.test(remainder)) {
+        return imageId;
+    }
+    return remainder;
+}

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

@@ -0,0 +1,15 @@
+export { getSingleBufferFromArray } from './bulkDataFromArray';
+export { toNumber, toFiniteNumber } from './toNumber';
+export { default as toNumberDefault } from './toNumber';
+export { default as isVideoTransferSyntax, videoUIDs, } from './isVideoTransferSyntax';
+export { default as imageIdToURI } from './imageIdToURI';
+export { isEqual, isEqualNegative, isEqualAbs, isNumber } from './isEqual';
+export { getPixelSpacingInformation, calculateRadiographicPixelSpacing, getERMF, } from './getPixelSpacingInformation';
+export { default as calibratedPixelSpacingMetadataProvider } from './calibratedPixelSpacingMetadataProvider';
+export * from './getNaturalizedField';
+export { default as splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId, } from './splitImageIdsBy4DTags';
+export * as Tags from './Tags';
+export * as DicomStream from './dicomStream';
+export * from './logging';
+export * from './metadataProvider';
+export * as typedMetadataProviders from './metadataProvider';

package/dist/esm/utilities/index.js

@@ -0,0 +1,15 @@
+export { getSingleBufferFromArray } from './bulkDataFromArray';
+export { toNumber, toFiniteNumber } from './toNumber';
+export { default as toNumberDefault } from './toNumber';
+export { default as isVideoTransferSyntax, videoUIDs, } from './isVideoTransferSyntax';
+export { default as imageIdToURI } from './imageIdToURI';
+export { isEqual, isEqualNegative, isEqualAbs, isNumber } from './isEqual';
+export { getPixelSpacingInformation, calculateRadiographicPixelSpacing, getERMF, } from './getPixelSpacingInformation';
+export { default as calibratedPixelSpacingMetadataProvider } from './calibratedPixelSpacingMetadataProvider';
+export * from './getNaturalizedField';
+export { default as splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId, } from './splitImageIdsBy4DTags';
+export * as Tags from './Tags';
+export * as DicomStream from './dicomStream';
+export * from './logging';
+export * from './metadataProvider';
+export * as typedMetadataProviders from './metadataProvider';

package/dist/esm/utilities/isEqual.d.ts

@@ -0,0 +1,2 @@
+export { DEFAULT_EPSILON, areNumbersEqualWithTolerance, isEqual, isEqualNegative, isEqualAbs, isNumber, } from '@cornerstonejs/utils';
+export { isEqual as default } from '@cornerstonejs/utils';

package/dist/esm/utilities/isEqual.js

@@ -0,0 +1,2 @@
+export { DEFAULT_EPSILON, areNumbersEqualWithTolerance, isEqual, isEqualNegative, isEqualAbs, isNumber, } from '@cornerstonejs/utils';
+export { isEqual as default } from '@cornerstonejs/utils';

package/dist/esm/utilities/isVideoTransferSyntax.d.ts

@@ -0,0 +1,2 @@
+export declare const videoUIDs: Set<string>;
+export default function isVideoTransferSyntax(uidOrUids: string | string[]): string | false;

package/dist/esm/utilities/isVideoTransferSyntax.js

@@ -0,0 +1,25 @@
+export const videoUIDs = new Set([
+    '1.2.840.10008.1.2.4.100',
+    '1.2.840.10008.1.2.4.100.1',
+    '1.2.840.10008.1.2.4.101',
+    '1.2.840.10008.1.2.4.101.1',
+    '1.2.840.10008.1.2.4.102',
+    '1.2.840.10008.1.2.4.102.1',
+    '1.2.840.10008.1.2.4.103',
+    '1.2.840.10008.1.2.4.103.1',
+    '1.2.840.10008.1.2.4.104',
+    '1.2.840.10008.1.2.4.104.1',
+    '1.2.840.10008.1.2.4.105',
+    '1.2.840.10008.1.2.4.105.1',
+    '1.2.840.10008.1.2.4.106',
+    '1.2.840.10008.1.2.4.106.1',
+    '1.2.840.10008.1.2.4.107',
+    '1.2.840.10008.1.2.4.108',
+]);
+export default function isVideoTransferSyntax(uidOrUids) {
+    if (!uidOrUids) {
+        return false;
+    }
+    const uids = Array.isArray(uidOrUids) ? uidOrUids : [uidOrUids];
+    return uids.find((uid) => videoUIDs.has(uid));
+}

package/dist/esm/utilities/logging.d.ts

@@ -0,0 +1,3 @@
+import { logging } from '@cornerstonejs/utils';
+export declare const getRootLogger: typeof logging.getRootLogger, getLogger: typeof logging.getLogger, cs3dLog: logging.Logger, metadataLog: logging.Logger, coreLog: logging.Logger, toolsLog: logging.Logger, loaderLog: logging.Logger, aiLog: logging.Logger, examplesLog: logging.Logger, workerLog: logging.Logger, dicomConsistencyLog: logging.Logger, imageConsistencyLog: logging.Logger, log: any;
+export type Logger = logging.Logger;

package/dist/esm/utilities/logging.js

@@ -0,0 +1,2 @@
+import { logging } from '@cornerstonejs/utils';
+export const { getRootLogger, getLogger, cs3dLog, metadataLog, coreLog, toolsLog, loaderLog, aiLog, examplesLog, workerLog, dicomConsistencyLog, imageConsistencyLog, log, } = logging;

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

@@ -0,0 +1,2 @@
+export declare function addDicomWebInstance(imageId: string, metadata: Record<string, unknown>): Promise<never>;
+export declare function addDicomPart10Instance(imageId: string, part10: ArrayBuffer | Uint8Array | (() => ArrayBuffer | Uint8Array | Promise<ArrayBuffer | Uint8Array>)): Promise<never>;

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

@@ -0,0 +1,12 @@
+import { addTyped } from '../../metaData';
+import { MetadataModules } from '../../enums';
+export function addDicomWebInstance(imageId, metadata) {
+    return addTyped(MetadataModules.NATURALIZED, imageId, {
+        dicomwebJson: metadata,
+    });
+}
+export async function addDicomPart10Instance(imageId, part10) {
+    return addTyped(MetadataModules.NATURALIZED, imageId, {
+        part10Buffer: part10,
+    });
+}