@cornerstonejs/core 5.1.4 → 5.2.1

package/dist/esm/RenderingEngine/GenericViewport/Planar/PlanarViewportTypes.d.ts

@@ -1,15 +1,15 @@
 import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
 import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import type { BlendModes, InterpolationType, OrientationAxis, VOILUTFunctionType } from '../../../enums';
-import type { ActorEntry, ActorRenderMode, ColormapPublic, IImage, IImageVolume, OrientationVectors, Point2, Point3, VOIRange } from '../../../types';
-import type { ViewportInput } from '../../../types/IViewport';
-import type ViewportInputOptions from '../../../types/ViewportInputOptions';
-import type { ViewPresentation, ViewPresentationSelector } from '../../../types';
-import type { BaseViewportRenderContext, BasePresentationProps, BindingRole, DataProvider, LoadedData, RenderPathResolver, ViewportDataReference } from '../ViewportArchitectureTypes';
-import type ICamera from '../../../types/ICamera';
-import type { CameraScaleMode, ViewAnchor } from '../ViewportCameraTypes';
-import type DisplayArea from '../../../types/displayArea';
-import type { PlanarScaleInput } from './planarCameraScale';
+import type { BlendModes, InterpolationType, OrientationAxis, VOILUTFunctionType } from '../../../enums/index.js';
+import type { ActorEntry, ActorRenderMode, ColormapPublic, IImage, IImageVolume, OrientationVectors, Point2, Point3, VOIRange } from '../../../types/index.js';
+import type { ViewportInput } from '../../../types/IViewport.js';
+import type ViewportInputOptions from '../../../types/ViewportInputOptions.js';
+import type { ViewPresentation, ViewPresentationSelector } from '../../../types/index.js';
+import type { BaseViewportRenderContext, BasePresentationProps, BindingRole, DataProvider, LoadedData, RenderPathResolver, ViewportDataReference } from '../ViewportArchitectureTypes.js';
+import type ICamera from '../../../types/ICamera.js';
+import type { CameraScaleMode, ViewAnchor } from '../ViewportCameraTypes.js';
+import type DisplayArea from '../../../types/displayArea.js';
+import type { PlanarScaleInput } from './planarCameraScale.js';
 export type PlanarRenderMode = ActorRenderMode.CPU_IMAGE | 'webgl2d' | ActorRenderMode.VTK_IMAGE | ActorRenderMode.VTK_VOLUME_SLICE;
 export type PlanarEffectiveRenderMode = ActorRenderMode.CPU_IMAGE | 'webgl2d' | ActorRenderMode.VTK_IMAGE | ActorRenderMode.VTK_VOLUME_SLICE | ActorRenderMode.CPU_VOLUME;
 export type PlanarOrientation = OrientationAxis.ACQUISITION | OrientationAxis.AXIAL | OrientationAxis.CORONAL | OrientationAxis.SAGITTAL | OrientationVectors;

package/dist/esm/RenderingEngine/GenericViewport/Planar/VtkImageMapperRenderPath.d.ts

@@ -1,6 +1,6 @@
-import { ViewportType } from '../../../enums';
-import type { DataAddOptions, LoadedData, RenderPathAttachment, RenderPathDefinition, RenderPath } from '../ViewportArchitectureTypes';
-import type { PlanarDataPresentation, PlanarViewportRenderContext, PlanarVtkImageAdapterContext } from './PlanarViewportTypes';
+import { ViewportType } from '../../../enums/index.js';
+import type { DataAddOptions, LoadedData, RenderPathAttachment, RenderPathDefinition, RenderPath } from '../ViewportArchitectureTypes.js';
+import type { PlanarDataPresentation, PlanarViewportRenderContext, PlanarVtkImageAdapterContext } from './PlanarViewportTypes.js';
 export declare class VtkImageMapperRenderPath implements RenderPath<PlanarVtkImageAdapterContext> {
     addData(ctx: PlanarVtkImageAdapterContext, data: LoadedData, options: DataAddOptions): Promise<RenderPathAttachment<PlanarDataPresentation>>;
     private updateDataPresentation;

package/dist/esm/RenderingEngine/GenericViewport/Planar/VtkImageMapperRenderPath.js

@@ -1,18 +1,18 @@
-import vtkImageMapper from '@kitware/vtk.js/Rendering/Core/ImageMapper';
-import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
-import { buildPlanarActorEntry } from './buildPlanarActorEntry';
-import uuidv4 from '../../../utilities/uuidv4';
-import { InterpolationType, MetadataModules, ViewportType, } from '../../../enums';
-import { loadAndCacheImage } from '../../../loaders/imageLoader';
-import { updateVTKImageDataWithCornerstoneImage } from '../../../utilities/updateVTKImageDataWithCornerstoneImage';
-import * as metaData from '../../../metaData';
-import { ActorRenderMode } from '../../../types';
-import { applyPlanarImagePresentation, createVTKImageDataFromImage, getDefaultImageVOIRange, updateVTKImageDataGeometryFromImage, } from '../../helpers/planarImageRendering';
-import { canvasToWorldContextPool, worldToCanvasContextPool, } from './planarAdapterCoordinateTransforms';
-import { buildPlanarImageData } from './CpuImageSliceRenderPath';
-import { triggerPlanarNewImage } from './planarImageEvents';
-import { applyPlanarICameraToActor, applyPlanarICameraToRenderer, } from './planarRenderCamera';
-import { resolvePlanarRenderPathCurrentImageIdIndex, resolvePlanarRenderPathProjection, } from './planarRenderPathProjection';
+import vtkImageMapper from '@kitware/vtk.js/Rendering/Core/ImageMapper.js';
+import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice.js';
+import { buildPlanarActorEntry } from './buildPlanarActorEntry.js';
+import uuidv4 from '../../../utilities/uuidv4.js';
+import { InterpolationType, MetadataModules, ViewportType, } from '../../../enums/index.js';
+import { loadAndCacheImage } from '../../../loaders/imageLoader.js';
+import { updateVTKImageDataWithCornerstoneImage } from '../../../utilities/updateVTKImageDataWithCornerstoneImage.js';
+import * as metaData from '../../../metaData.js';
+import { ActorRenderMode } from '../../../types/index.js';
+import { applyPlanarImagePresentation, createVTKImageDataFromImage, getDefaultImageVOIRange, updateVTKImageDataGeometryFromImage, } from '../../helpers/planarImageRendering.js';
+import { canvasToWorldContextPool, worldToCanvasContextPool, } from './planarAdapterCoordinateTransforms.js';
+import { buildPlanarImageData } from './CpuImageSliceRenderPath.js';
+import { triggerPlanarNewImage } from './planarImageEvents.js';
+import { applyPlanarICameraToActor, applyPlanarICameraToRenderer, } from './planarRenderCamera.js';
+import { resolvePlanarRenderPathCurrentImageIdIndex, resolvePlanarRenderPathProjection, } from './planarRenderPathProjection.js';
 export class VtkImageMapperRenderPath {
     async addData(ctx, data, options) {
         const payload = data;

package/dist/esm/RenderingEngine/GenericViewport/Planar/VtkVolumeSliceRenderPath.d.ts

@@ -1,6 +1,6 @@
-import { ViewportType } from '../../../enums';
-import type { DataAddOptions, LoadedData, RenderPathAttachment, RenderPathDefinition, RenderPath } from '../ViewportArchitectureTypes';
-import type { PlanarDataPresentation, PlanarViewportRenderContext, PlanarVtkVolumeAdapterContext } from './PlanarViewportTypes';
+import { ViewportType } from '../../../enums/index.js';
+import type { DataAddOptions, LoadedData, RenderPathAttachment, RenderPathDefinition, RenderPath } from '../ViewportArchitectureTypes.js';
+import type { PlanarDataPresentation, PlanarViewportRenderContext, PlanarVtkVolumeAdapterContext } from './PlanarViewportTypes.js';
 export declare class VtkVolumeSliceRenderPath implements RenderPath<PlanarVtkVolumeAdapterContext> {
     addData(ctx: PlanarVtkVolumeAdapterContext, data: LoadedData, options: DataAddOptions): Promise<RenderPathAttachment<PlanarDataPresentation>>;
     private updateDataPresentation;

package/dist/esm/RenderingEngine/GenericViewport/Planar/VtkVolumeSliceRenderPath.js

@@ -1,15 +1,15 @@
-import vtkPlaneFactory from '@kitware/vtk.js/Common/DataModel/Plane';
-import { buildPlanarActorEntry } from './buildPlanarActorEntry';
-import uuidv4 from '../../../utilities/uuidv4';
-import { Events, ViewportType } from '../../../enums';
-import eventTarget from '../../../eventTarget';
-import createVolumeSliceActor from '../../helpers/createVolumeSliceActor';
-import { ActorRenderMode } from '../../../types';
-import { canvasToWorldContextPool, worldToCanvasContextPool, } from './planarAdapterCoordinateTransforms';
-import { triggerPlanarVolumeNewImage } from './planarImageEvents';
-import { applyPlanarICameraToActor, applyPlanarICameraToRenderer, } from './planarRenderCamera';
-import { getPlanarRenderPathActiveSourceICamera, resolvePlanarRenderPathProjection, } from './planarRenderPathProjection';
-import { applyPlanarVolumePresentation } from './planarVolumePresentation';
+import vtkPlaneFactory from '@kitware/vtk.js/Common/DataModel/Plane.js';
+import { buildPlanarActorEntry } from './buildPlanarActorEntry.js';
+import uuidv4 from '../../../utilities/uuidv4.js';
+import { Events, ViewportType } from '../../../enums/index.js';
+import eventTarget from '../../../eventTarget.js';
+import createVolumeSliceActor from '../../helpers/createVolumeSliceActor.js';
+import { ActorRenderMode } from '../../../types/index.js';
+import { canvasToWorldContextPool, worldToCanvasContextPool, } from './planarAdapterCoordinateTransforms.js';
+import { triggerPlanarVolumeNewImage } from './planarImageEvents.js';
+import { applyPlanarICameraToActor, applyPlanarICameraToRenderer, } from './planarRenderCamera.js';
+import { getPlanarRenderPathActiveSourceICamera, resolvePlanarRenderPathProjection, } from './planarRenderPathProjection.js';
+import { applyPlanarVolumePresentation } from './planarVolumePresentation.js';
 const SLICE_OVERLAY_DEPTH_EPSILON = 1e-4;
 export class VtkVolumeSliceRenderPath {
     async addData(ctx, data, options) {

package/dist/esm/RenderingEngine/GenericViewport/Planar/buildPlanarActorEntry.d.ts

@@ -1,6 +1,6 @@
-import type { ActorEntry } from '../../../types';
-import type { LoadedData } from '../ViewportArchitectureTypes';
-import type { PlanarPayload } from './PlanarViewportTypes';
+import type { ActorEntry } from '../../../types/index.js';
+import type { LoadedData } from '../ViewportArchitectureTypes.js';
+import type { PlanarPayload } from './PlanarViewportTypes.js';
 export declare function buildPlanarActorEntry(data: LoadedData<PlanarPayload>, source: {
     actor: NonNullable<ActorEntry['actorMapper']>['actor'];
     mapper?: NonNullable<ActorEntry['actorMapper']>['mapper'];

package/dist/esm/RenderingEngine/GenericViewport/Planar/index.d.ts

@@ -1,10 +1,10 @@
-import { applyPlanarICameraToRenderer, derivePlanarPresentation, resolvePlanarICamera } from './planarRenderCamera';
-import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom } from './planarProjectionAdapter';
-import { createPlanarImageSliceBasis, createPlanarVolumeSliceBasis } from './planarSliceBasis';
-export { DefaultPlanarDataProvider } from './DefaultPlanarDataProvider';
-export { createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, } from './PlanarRenderPathResolver';
+import { applyPlanarICameraToRenderer, derivePlanarPresentation, resolvePlanarICamera } from './planarRenderCamera.js';
+import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom } from './planarProjectionAdapter.js';
+import { createPlanarImageSliceBasis, createPlanarVolumeSliceBasis } from './planarSliceBasis.js';
+export { DefaultPlanarDataProvider } from './DefaultPlanarDataProvider.js';
+export { createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, } from './PlanarRenderPathResolver.js';
 export declare const planarProjection: {
-    adapter: import("..").ViewportProjectionAdapter<import("./PlanarViewportTypes").PlanarViewState, import("./PlanarViewportTypes").PlanarViewPresentation, import("./PlanarProjectionTypes").PlanarProjectionSnapshot>;
+    adapter: import("../index.js").ViewportProjectionAdapter<import("./PlanarViewportTypes.js").PlanarViewState, import("./PlanarViewportTypes.js").PlanarViewPresentation, import("./PlanarProjectionTypes.js").PlanarProjectionSnapshot>;
     getSnapshot: typeof getPlanarProjectionSnapshot;
     getZoom: typeof getPlanarProjectionZoom;
     getScale: typeof getPlanarProjectionScale;
@@ -15,9 +15,9 @@ export declare const planarProjection: {
     createImageSliceBasis: typeof createPlanarImageSliceBasis;
     createVolumeSliceBasis: typeof createPlanarVolumeSliceBasis;
 };
-export type { PlanarProjectionPresentation, PlanarProjectionRequest, PlanarProjectionSnapshot, } from './planarProjectionAdapter';
-export { BasePlanarResolvedView, PlanarStackResolvedView, PlanarVolumeResolvedView, resolvePlanarStackImageIdIndex, } from './PlanarResolvedView';
-export { resolvePlanarRenderPathProjection } from './planarRenderPathProjection';
-export { default, default as PlanarViewport } from './PlanarViewport';
-export type { PlanarSliceBasis } from './planarSliceBasis';
-export type { PlanarViewState, PlanarDataPresentation, PlanarOrientation, PlanarPresentationProps, PlanarProperties, PlanarRenderMode, PlanarSetDataOptions, PlanarViewportInput, PlanarViewportInputOptions, PlanarDisplayArea, PlanarViewPresentation, PlanarViewPresentationSelector, PlanarSliceState, PlanarResolvedICamera, } from './PlanarViewportTypes';
+export type { PlanarProjectionPresentation, PlanarProjectionRequest, PlanarProjectionSnapshot, } from './planarProjectionAdapter.js';
+export { BasePlanarResolvedView, PlanarStackResolvedView, PlanarVolumeResolvedView, resolvePlanarStackImageIdIndex, } from './PlanarResolvedView.js';
+export { resolvePlanarRenderPathProjection } from './planarRenderPathProjection.js';
+export { default, default as PlanarViewport } from './PlanarViewport.js';
+export type { PlanarSliceBasis } from './planarSliceBasis.js';
+export type { PlanarViewState, PlanarDataPresentation, PlanarOrientation, PlanarPresentationProps, PlanarProperties, PlanarRenderMode, PlanarSetDataOptions, PlanarViewportInput, PlanarViewportInputOptions, PlanarDisplayArea, PlanarViewPresentation, PlanarViewPresentationSelector, PlanarSliceState, PlanarResolvedICamera, } from './PlanarViewportTypes.js';

package/dist/esm/RenderingEngine/GenericViewport/Planar/index.js

@@ -1,8 +1,8 @@
-import { applyPlanarICameraToRenderer, derivePlanarPresentation, resolvePlanarICamera, } from './planarRenderCamera';
-import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom, planarProjectionAdapter, } from './planarProjectionAdapter';
-import { createPlanarImageSliceBasis, createPlanarVolumeSliceBasis, } from './planarSliceBasis';
-export { DefaultPlanarDataProvider } from './DefaultPlanarDataProvider';
-export { createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, } from './PlanarRenderPathResolver';
+import { applyPlanarICameraToRenderer, derivePlanarPresentation, resolvePlanarICamera, } from './planarRenderCamera.js';
+import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom, planarProjectionAdapter, } from './planarProjectionAdapter.js';
+import { createPlanarImageSliceBasis, createPlanarVolumeSliceBasis, } from './planarSliceBasis.js';
+export { DefaultPlanarDataProvider } from './DefaultPlanarDataProvider.js';
+export { createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, } from './PlanarRenderPathResolver.js';
 export const planarProjection = {
     adapter: planarProjectionAdapter,
     getSnapshot: getPlanarProjectionSnapshot,
@@ -15,6 +15,6 @@ export const planarProjection = {
     createImageSliceBasis: createPlanarImageSliceBasis,
     createVolumeSliceBasis: createPlanarVolumeSliceBasis,
 };
-export { BasePlanarResolvedView, PlanarStackResolvedView, PlanarVolumeResolvedView, resolvePlanarStackImageIdIndex, } from './PlanarResolvedView';
-export { resolvePlanarRenderPathProjection } from './planarRenderPathProjection';
-export { default, default as PlanarViewport } from './PlanarViewport';
+export { BasePlanarResolvedView, PlanarStackResolvedView, PlanarVolumeResolvedView, resolvePlanarStackImageIdIndex, } from './PlanarResolvedView.js';
+export { resolvePlanarRenderPathProjection } from './planarRenderPathProjection.js';
+export { default, default as PlanarViewport } from './PlanarViewport.js';

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarActorCompatibility.d.ts

@@ -1,4 +1,4 @@
-import type { ActorEntry, IImage, IStackInput } from '../../../types';
-import type { IViewport } from '../../../types/IViewport';
+import type { ActorEntry, IImage, IStackInput } from '../../../types/index.js';
+import type { IViewport } from '../../../types/IViewport.js';
 export declare function createPlanarImageOverlayActorEntry(image: IImage, stackInput: IStackInput): ActorEntry;
 export declare function createPlanarCpuImageOverlayActorEntry(viewport: IViewport, image: IImage, stackInput: IStackInput): ActorEntry;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarActorCompatibility.js

@@ -1,9 +1,9 @@
-import vtkImageMapper from '@kitware/vtk.js/Rendering/Core/ImageMapper';
-import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
-import CanvasActor from '../../CanvasActor';
-import { ActorRenderMode } from '../../../types';
-import uuidv4 from '../../../utilities/uuidv4';
-import { createVTKImageDataFromImage } from '../../helpers/planarImageRendering';
+import vtkImageMapper from '@kitware/vtk.js/Rendering/Core/ImageMapper.js';
+import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice.js';
+import CanvasActor from '../../CanvasActor/index.js';
+import { ActorRenderMode } from '../../../types/index.js';
+import uuidv4 from '../../../utilities/uuidv4.js';
+import { createVTKImageDataFromImage } from '../../helpers/planarImageRendering.js';
 export function createPlanarImageOverlayActorEntry(image, stackInput) {
     const mapper = vtkImageMapper.newInstance();
     const actor = vtkImageSlice.newInstance();

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarAdapterCoordinateTransforms.d.ts

@@ -1,6 +1,6 @@
-export { canvasToWorldContextPool, worldToCanvasContextPool, } from '../../helpers/vtkCanvasCoordinateTransforms';
-import type { CPUFallbackEnabledElement, ICamera, IImage, Point2, Point3 } from '../../../types';
-import { type PlanarScaleInput } from './planarCameraScale';
+export { canvasToWorldContextPool, worldToCanvasContextPool, } from '../../helpers/vtkCanvasCoordinateTransforms.js';
+import type { CPUFallbackEnabledElement, ICamera, IImage, Point2, Point3 } from '../../../types/index.js';
+import { type PlanarScaleInput } from './planarCameraScale.js';
 type PlanarResolvedView = Pick<Required<ICamera>, 'focalPoint' | 'parallelScale' | 'viewPlaneNormal' | 'viewUp'> & {
     presentationScale?: PlanarScaleInput;
 };

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarAdapterCoordinateTransforms.js

@@ -1,9 +1,9 @@
 import { vec3 } from 'gl-matrix';
-import canvasToPixel from '../../helpers/cpuFallback/rendering/canvasToPixel';
-import pixelToCanvas from '../../helpers/cpuFallback/rendering/pixelToCanvas';
-export { canvasToWorldContextPool, worldToCanvasContextPool, } from '../../helpers/vtkCanvasCoordinateTransforms';
-import { getImageDataMetadata } from '../../../utilities/getImageDataMetadata';
-import { getPlanarScaleRatio, } from './planarCameraScale';
+import canvasToPixel from '../../helpers/cpuFallback/rendering/canvasToPixel.js';
+import pixelToCanvas from '../../helpers/cpuFallback/rendering/pixelToCanvas.js';
+export { canvasToWorldContextPool, worldToCanvasContextPool, } from '../../helpers/vtkCanvasCoordinateTransforms.js';
+import { getImageDataMetadata } from '../../../utilities/getImageDataMetadata.js';
+import { getPlanarScaleRatio, } from './planarCameraScale.js';
 function getPlanarViewStateBasis(camera) {
     const viewUp = vec3.normalize(vec3.create(), camera.viewUp);
     const viewPlaneNormal = vec3.normalize(vec3.create(), camera.viewPlaneNormal);

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarCPUVolumeSamplingUtils.d.ts

@@ -1,4 +1,4 @@
-import type { IImageVolume, Point3 } from '../../../types';
+import type { IImageVolume, Point3 } from '../../../types/index.js';
 export type IndexMajorAxis = {
     axis: 0 | 1 | 2;
     sign: 1 | -1;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarCameraScale.d.ts

@@ -1,5 +1,5 @@
-import type { Point2 } from '../../../types';
-import type { CameraScaleMode } from '../ViewportCameraTypes';
+import type { Point2 } from '../../../types/index.js';
+import type { CameraScaleMode } from '../ViewportCameraTypes.js';
 export type PlanarScaleInput = number | Point2;
 export type PlanarScale = Point2;
 export declare const MIN_PLANAR_SCALE = 0.001;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarCpuImageTransforms.d.ts

@@ -1,3 +1,3 @@
-import type { CPUFallbackEnabledElement, CPUIImageData, Point2, Point3 } from '../../../types';
+import type { CPUFallbackEnabledElement, CPUIImageData, Point2, Point3 } from '../../../types/index.js';
 export declare function canvasToWorldPlanarCpuImage(enabledElement: CPUFallbackEnabledElement, imageData: CPUIImageData, canvasPos: Point2, worldPos?: Point3): Point3;
 export declare function worldToCanvasPlanarCpuImage(enabledElement: CPUFallbackEnabledElement, imageData: CPUIImageData, worldPos: Point3): Point2;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarCpuImageTransforms.js

@@ -1,6 +1,6 @@
 import { vec3 } from 'gl-matrix';
-import canvasToPixel from '../../helpers/cpuFallback/rendering/canvasToPixel';
-import pixelToCanvas from '../../helpers/cpuFallback/rendering/pixelToCanvas';
+import canvasToPixel from '../../helpers/cpuFallback/rendering/canvasToPixel.js';
+import pixelToCanvas from '../../helpers/cpuFallback/rendering/pixelToCanvas.js';
 function getDisplayedAreaSource(enabledElement) {
     const displayedArea = enabledElement.viewport.displayedArea;
     return [(displayedArea?.tlhc.x ?? 1) - 1, (displayedArea?.tlhc.y ?? 1) - 1];

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarCpuViewportMath.d.ts

@@ -1,5 +1,5 @@
-import type { CPUFallbackViewport, IImage, Point2 } from '../../../types';
-import { type PlanarScaleInput } from './planarCameraScale';
+import type { CPUFallbackViewport, IImage, Point2 } from '../../../types/index.js';
+import { type PlanarScaleInput } from './planarCameraScale.js';
 export declare function resolvePlanarCpuImageDisplayedArea(image: IImage): CPUFallbackViewport['displayedArea'];
 export declare function resolvePlanarCpuViewportScale(args: {
     canvas: HTMLCanvasElement;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarCpuViewportMath.js

@@ -1,4 +1,4 @@
-import { getPlanarScaleRatio, } from './planarCameraScale';
+import { getPlanarScaleRatio, } from './planarCameraScale.js';
 const EPSILON = 1e-6;
 export function resolvePlanarCpuImageDisplayedArea(image) {
     return {

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarImageEvents.d.ts

@@ -1,5 +1,5 @@
-import type { IImage } from '../../../types';
-import type { PlanarViewState } from './PlanarViewportTypes';
+import type { IImage } from '../../../types/index.js';
+import type { PlanarViewState } from './PlanarViewportTypes.js';
 interface PlanarImageEventContext {
     viewportId: string;
     renderingEngineId: string;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarImageEvents.js

@@ -1,5 +1,5 @@
-import { Events, OrientationAxis } from '../../../enums';
-import triggerEvent from '../../../utilities/triggerEvent';
+import { Events, OrientationAxis } from '../../../enums/index.js';
+import triggerEvent from '../../../utilities/triggerEvent.js';
 export function triggerPlanarNewImage(ctx, args = {}) {
     triggerEvent(ctx.viewport.element, Events.STACK_NEW_IMAGE, {
         image: args.image,

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarLegacyCompatibility.d.ts

@@ -1,6 +1,6 @@
-import type BlendModes from '../../../enums/BlendModes';
-import type { ColormapPublic, OrientationVectors, StackViewportProperties, VolumeViewportProperties } from '../../../types';
-import type { PlanarDataPresentation, PlanarOrientation } from './PlanarViewportTypes';
+import type BlendModes from '../../../enums/BlendModes.js';
+import type { ColormapPublic, OrientationVectors, StackViewportProperties, VolumeViewportProperties } from '../../../types/index.js';
+import type { PlanarDataPresentation, PlanarOrientation } from './PlanarViewportTypes.js';
 export type PlanarLegacyViewportProperties = Partial<Omit<StackViewportProperties & VolumeViewportProperties, 'orientation'> & Pick<PlanarDataPresentation, 'opacity' | 'visible'> & {
     blendMode?: BlendModes;
     orientation?: PlanarOrientation;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarMath.d.ts

@@ -1,3 +1,3 @@
-import type { Point3 } from '../../../types';
+import type { Point3 } from '../../../types/index.js';
 export declare function getSafeCanvasDimension(value: number): number;
 export declare function normalizePoint3(point: Point3, fallback?: Point3): Point3;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarOrientationVectors.d.ts

@@ -1,5 +1,5 @@
-import type { IImageVolume, Point3 } from '../../../types';
-import type { PlanarViewState } from './PlanarViewportTypes';
+import type { IImageVolume, Point3 } from '../../../types/index.js';
+import type { PlanarViewState } from './PlanarViewportTypes.js';
 type PlanarViewStateVectors = {
     viewPlaneNormal: Point3;
     viewUp: Point3;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarOrientationVectors.js

@@ -1,7 +1,7 @@
-import { MPR_CAMERA_VALUES } from '../../../constants';
-import { OrientationAxis } from '../../../enums';
-import getAcquisitionPlaneOrientation from '../../../utilities/getAcquisitionPlaneOrientation';
-import { isPlanarOrientationVectors } from './planarLegacyCompatibility';
+import { MPR_CAMERA_VALUES } from '../../../constants/index.js';
+import { OrientationAxis } from '../../../enums/index.js';
+import getAcquisitionPlaneOrientation from '../../../utilities/getAcquisitionPlaneOrientation.js';
+import { isPlanarOrientationVectors } from './planarLegacyCompatibility.js';
 export function getAcquisitionCameraVectors(imageVolume) {
     const { viewPlaneNormal, viewUp } = getAcquisitionPlaneOrientation(imageVolume);
     return {

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarProjectionAdapter.d.ts

@@ -1,7 +1,7 @@
-import type { ViewportProjectionAdapter } from '../ViewportProjectionTypes';
-import type { PlanarViewState } from './PlanarViewportTypes';
-import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom } from './planarProjectionSnapshot';
-import { type PlanarProjectionSnapshot, type PlanarProjectionAdapterPresentation } from './PlanarProjectionTypes';
+import type { ViewportProjectionAdapter } from '../ViewportProjectionTypes.js';
+import type { PlanarViewState } from './PlanarViewportTypes.js';
+import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom } from './planarProjectionSnapshot.js';
+import { type PlanarProjectionSnapshot, type PlanarProjectionAdapterPresentation } from './PlanarProjectionTypes.js';
 export { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom, };
-export type { PlanarProjectionPresentation, PlanarProjectionRequest, PlanarProjectionSnapshot, } from './PlanarProjectionTypes';
+export type { PlanarProjectionPresentation, PlanarProjectionRequest, PlanarProjectionSnapshot, } from './PlanarProjectionTypes.js';
 export declare const planarProjectionAdapter: ViewportProjectionAdapter<PlanarViewState, PlanarProjectionAdapterPresentation, PlanarProjectionSnapshot>;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarProjectionAdapter.js

@@ -1,8 +1,8 @@
-import { ViewportType } from '../../../enums';
-import { applyPlanarICameraToRenderer } from './planarRenderCamera';
-import { getPlanarProjectionPresentation, withPlanarProjectionPresentation, } from './planarProjectionPresentation';
-import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom, } from './planarProjectionSnapshot';
-import { PLANAR_PROJECTION_ID, } from './PlanarProjectionTypes';
+import { ViewportType } from '../../../enums/index.js';
+import { applyPlanarICameraToRenderer } from './planarRenderCamera.js';
+import { getPlanarProjectionPresentation, withPlanarProjectionPresentation, } from './planarProjectionPresentation.js';
+import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom, } from './planarProjectionSnapshot.js';
+import { PLANAR_PROJECTION_ID, } from './PlanarProjectionTypes.js';
 export { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom, };
 function isVtkRenderer(target) {
     return Boolean(target &&

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarProjectionFallback.d.ts

@@ -1,4 +1,4 @@
-import type { Point2 } from '../../../types';
-import type { PlanarViewState } from './PlanarViewportTypes';
+import type { Point2 } from '../../../types/index.js';
+import type { PlanarViewState } from './PlanarViewportTypes.js';
 export declare function getPlanarProjectionFallbackPan(viewState: PlanarViewState, canvasWidth: number, canvasHeight: number): Point2;
 export declare function getPlanarProjectionFallbackViewStateWithPan(viewState: PlanarViewState, nextPan: Point2, canvasWidth: number, canvasHeight: number): PlanarViewState;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarProjectionFallback.js

@@ -1,5 +1,5 @@
-import { normalizePlanarScale } from './planarCameraScale';
-import { normalizePlanarViewState } from './planarViewState';
+import { normalizePlanarScale } from './planarCameraScale.js';
+import { normalizePlanarViewState } from './planarViewState.js';
 export function getPlanarProjectionFallbackPan(viewState, canvasWidth, canvasHeight) {
     const anchorCanvas = viewState.anchorCanvas ?? [0.5, 0.5];
     const anchorWorld = viewState.anchorWorld ?? [0, 0, 0];

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarProjectionPresentation.d.ts

@@ -1,5 +1,5 @@
-import type { ViewPresentationSelector } from '../../../types/IViewport';
-import type { PlanarProjectionSnapshot } from './PlanarProjectionTypes';
-import type { PlanarViewPresentation, PlanarViewState } from './PlanarViewportTypes';
+import type { ViewPresentationSelector } from '../../../types/IViewport.js';
+import type { PlanarProjectionSnapshot } from './PlanarProjectionTypes.js';
+import type { PlanarViewPresentation, PlanarViewState } from './PlanarViewportTypes.js';
 export declare function getPlanarProjectionPresentation(snapshot: PlanarProjectionSnapshot, selector: ViewPresentationSelector | undefined): PlanarViewPresentation;
 export declare function withPlanarProjectionPresentation(snapshot: PlanarProjectionSnapshot, presentation: Partial<PlanarViewPresentation>): PlanarViewState;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarProjectionPresentation.js

@@ -1,7 +1,7 @@
-import { normalizePlanarScale } from './planarCameraScale';
-import { getPlanarProjectionFallbackViewStateWithPan } from './planarProjectionFallback';
-import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionZoom, } from './planarProjectionSnapshot';
-import { cloneDisplayArea, normalizePlanarViewState } from './planarViewState';
+import { normalizePlanarScale } from './planarCameraScale.js';
+import { getPlanarProjectionFallbackViewStateWithPan } from './planarProjectionFallback.js';
+import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionZoom, } from './planarProjectionSnapshot.js';
+import { cloneDisplayArea, normalizePlanarViewState } from './planarViewState.js';
 const DEFAULT_SELECTOR = {
     rotation: true,
     displayArea: true,

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarProjectionSnapshot.d.ts

@@ -1,5 +1,5 @@
-import type { Point2 } from '../../../types';
-import { type PlanarProjectionRequest, type PlanarProjectionSnapshot } from './PlanarProjectionTypes';
+import type { Point2 } from '../../../types/index.js';
+import { type PlanarProjectionRequest, type PlanarProjectionSnapshot } from './PlanarProjectionTypes.js';
 export declare function getPlanarProjectionSnapshot(request: PlanarProjectionRequest): PlanarProjectionSnapshot | undefined;
 export declare function getPlanarProjectionZoom(snapshot: PlanarProjectionSnapshot): number;
 export declare function getPlanarProjectionScale(snapshot: PlanarProjectionSnapshot): Point2;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarProjectionSnapshot.js

@@ -1,8 +1,8 @@
-import { clonePlanarScale, getPlanarScaleZoom } from './planarCameraScale';
-import { getPlanarProjectionFallbackPan } from './planarProjectionFallback';
-import { PLANAR_PROJECTION_ID, } from './PlanarProjectionTypes';
-import { normalizePlanarRotation } from './planarViewPresentation';
-import { cloneDisplayArea, normalizePlanarViewState } from './planarViewState';
+import { clonePlanarScale, getPlanarScaleZoom } from './planarCameraScale.js';
+import { getPlanarProjectionFallbackPan } from './planarProjectionFallback.js';
+import { PLANAR_PROJECTION_ID, } from './PlanarProjectionTypes.js';
+import { normalizePlanarRotation } from './planarViewPresentation.js';
+import { cloneDisplayArea, normalizePlanarViewState } from './planarViewState.js';
 function clonePoint2(point) {
     return [point[0], point[1]];
 }

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarRenderCamera.d.ts

@@ -1,9 +1,9 @@
 import { mat4 } from 'gl-matrix';
 import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
 import type vtkVolumeMapper from '@kitware/vtk.js/Rendering/Core/VolumeMapper';
-import type { ICamera, Point2, Point3 } from '../../../types';
-import type { PlanarViewState, PlanarResolvedICamera } from './PlanarViewportTypes';
-import type { PlanarSliceBasis } from './planarSliceBasis';
+import type { ICamera, Point2, Point3 } from '../../../types/index.js';
+import type { PlanarViewState, PlanarResolvedICamera } from './PlanarViewportTypes.js';
+import type { PlanarSliceBasis } from './planarSliceBasis.js';
 export interface DerivedPlanarPresentation {
     pan: Point2;
     zoom: number;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarRenderCamera.js

@@ -1,10 +1,10 @@
 import { mat4, vec2, vec3 } from 'gl-matrix';
-import vtkPlaneFactory from '@kitware/vtk.js/Common/DataModel/Plane';
-import { RENDERING_DEFAULTS } from '../../../constants';
-import { applyPlanarViewFlip, normalizePlanarRotation, rotatePlanarViewUp, } from './planarViewPresentation';
-import { getSafeCanvasDimension, normalizePoint3 } from './planarMath';
-import setVtkCameraClippingRange from '../setVtkCameraClippingRange';
-import { MIN_PLANAR_SCALE, normalizePlanarScale, normalizePlanarScaleMode, } from './planarCameraScale';
+import vtkPlaneFactory from '@kitware/vtk.js/Common/DataModel/Plane.js';
+import { RENDERING_DEFAULTS } from '../../../constants/index.js';
+import { applyPlanarViewFlip, normalizePlanarRotation, rotatePlanarViewUp, } from './planarViewPresentation.js';
+import { getSafeCanvasDimension, normalizePoint3 } from './planarMath.js';
+import setVtkCameraClippingRange from '../setVtkCameraClippingRange.js';
+import { MIN_PLANAR_SCALE, normalizePlanarScale, normalizePlanarScaleMode, } from './planarCameraScale.js';
 const MIN_DISPLAY_AREA_VALUE = 1e-3;
 const MIN_SCALE_RATIO = 1e-6;
 function getSliceCanvasDimensionsAtFit(args) {

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarRenderPathProjection.d.ts

@@ -1,8 +1,8 @@
-import type { Point2, Point3 } from '../../../types';
-import { resolvePlanarStackImageIdIndex, resolvePlanarViewportView, type PlanarViewResolutionRenderContext } from './PlanarResolvedView';
-import type { DerivedPlanarPresentation } from './planarRenderCamera';
-import type { PlanarActiveViewRuntime, PlanarPayload, PlanarResolvedICamera, PlanarViewState } from './PlanarViewportTypes';
-import type { PlanarRendering } from './planarRuntimeTypes';
+import type { Point2, Point3 } from '../../../types/index.js';
+import { resolvePlanarStackImageIdIndex, resolvePlanarViewportView, type PlanarViewResolutionRenderContext } from './PlanarResolvedView.js';
+import type { DerivedPlanarPresentation } from './planarRenderCamera.js';
+import type { PlanarActiveViewRuntime, PlanarPayload, PlanarResolvedICamera, PlanarViewState } from './PlanarViewportTypes.js';
+import type { PlanarRendering } from './planarRuntimeTypes.js';
 type PlanarRenderPathProjectionContext = PlanarViewResolutionRenderContext & {
     viewport: {
         isCurrentDataId(dataId: string): boolean;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarRenderPathProjection.js

@@ -1,6 +1,6 @@
-import { ActorRenderMode } from '../../../types';
-import { canvasToWorldPlanarViewState, getCanvasCssDimensions, worldToCanvasPlanarViewState, } from './planarAdapterCoordinateTransforms';
-import { resolvePlanarStackImageIdIndex, resolvePlanarViewportView, } from './PlanarResolvedView';
+import { ActorRenderMode } from '../../../types/index.js';
+import { canvasToWorldPlanarViewState, getCanvasCssDimensions, worldToCanvasPlanarViewState, } from './planarAdapterCoordinateTransforms.js';
+import { resolvePlanarStackImageIdIndex, resolvePlanarViewportView, } from './PlanarResolvedView.js';
 export { resolvePlanarStackImageIdIndex };
 export function resolvePlanarRenderPathCurrentImageIdIndex(args) {
     const { projection, rendering, viewState } = args;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarRenderPathSelector.d.ts

@@ -1,4 +1,4 @@
-import type { PlanarViewState, PlanarOrientation } from './PlanarViewportTypes';
-export { DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD, DEFAULT_PLANAR_CPU_VOLUME_THRESHOLD, PlanarRenderPathDecisionService, defaultPlanarRenderPathDecisionService, getPlanarAcquisitionOrientation, selectPlanarRenderPath, shouldUseCPU, } from './PlanarRenderPathDecisionService';
-export type { PlanarRenderPathDecisionOptions, SelectedPlanarRenderPath, } from './PlanarRenderPathDecisionService';
+import type { PlanarViewState, PlanarOrientation } from './PlanarViewportTypes.js';
+export { DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD, DEFAULT_PLANAR_CPU_VOLUME_THRESHOLD, PlanarRenderPathDecisionService, defaultPlanarRenderPathDecisionService, getPlanarAcquisitionOrientation, selectPlanarRenderPath, shouldUseCPU, } from './PlanarRenderPathDecisionService.js';
+export type { PlanarRenderPathDecisionOptions, SelectedPlanarRenderPath, } from './PlanarRenderPathDecisionService.js';
 export declare function normalizePlanarOrientation(orientation: PlanarOrientation | undefined, acquisitionOrientation?: PlanarViewState['orientation']): PlanarViewState['orientation'];

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarRenderPathSelector.js

@@ -1,6 +1,6 @@
-import { OrientationAxis } from '../../../enums';
-import { clonePlanarOrientation } from './planarLegacyCompatibility';
-export { DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD, DEFAULT_PLANAR_CPU_VOLUME_THRESHOLD, PlanarRenderPathDecisionService, defaultPlanarRenderPathDecisionService, getPlanarAcquisitionOrientation, selectPlanarRenderPath, shouldUseCPU, } from './PlanarRenderPathDecisionService';
+import { OrientationAxis } from '../../../enums/index.js';
+import { clonePlanarOrientation } from './planarLegacyCompatibility.js';
+export { DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD, DEFAULT_PLANAR_CPU_VOLUME_THRESHOLD, PlanarRenderPathDecisionService, defaultPlanarRenderPathDecisionService, getPlanarAcquisitionOrientation, selectPlanarRenderPath, shouldUseCPU, } from './PlanarRenderPathDecisionService.js';
 export function normalizePlanarOrientation(orientation, acquisitionOrientation) {
     if (!orientation || orientation === OrientationAxis.ACQUISITION) {
         return OrientationAxis.ACQUISITION;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarRuntimeTypes.d.ts

@@ -2,10 +2,10 @@ import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import type vtkImageMapper from '@kitware/vtk.js/Rendering/Core/ImageMapper';
 import type vtkImageResliceMapper from '@kitware/vtk.js/Rendering/Core/ImageResliceMapper';
 import type vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
-import type { InterpolationType } from '../../../enums';
-import type { CPUFallbackEnabledElement, ActorRenderMode, ICanvasActor, IImage, IImageVolume, Point3, VOIRange } from '../../../types';
-import type { MountedRendering } from '../ViewportArchitectureTypes';
-import type { PlanarViewState, PlanarDataPresentation } from './PlanarViewportTypes';
+import type { InterpolationType } from '../../../enums/index.js';
+import type { CPUFallbackEnabledElement, ActorRenderMode, ICanvasActor, IImage, IImageVolume, Point3, VOIRange } from '../../../types/index.js';
+import type { MountedRendering } from '../ViewportArchitectureTypes.js';
+import type { PlanarViewState, PlanarDataPresentation } from './PlanarViewportTypes.js';
 export type PlanarImageMapperRendering = MountedRendering<{
     renderMode: ActorRenderMode.VTK_IMAGE;
     actorEntryUID: string;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarSliceBasis.d.ts

@@ -1,6 +1,6 @@
-import { InterpolationType } from '../../../enums';
-import type { IImage, IImageVolume, Point3 } from '../../../types';
-import type { PlanarViewState } from './PlanarViewportTypes';
+import { InterpolationType } from '../../../enums/index.js';
+import type { IImage, IImageVolume, Point3 } from '../../../types/index.js';
+import type { PlanarViewState } from './PlanarViewportTypes.js';
 export interface PlanarSliceBasis {
     sliceCenterWorld: Point3;
     viewPlaneNormal: Point3;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarSliceBasis.js

@@ -1,12 +1,12 @@
 import { vec3 } from 'gl-matrix';
-import { InterpolationType, OrientationAxis } from '../../../enums';
-import { getImageDataMetadata } from '../../../utilities/getImageDataMetadata';
-import { getCubeSizeInView } from '../../../utilities/getPlaneCubeIntersectionDimensions';
-import getSpacingInNormalDirection from '../../../utilities/getSpacingInNormalDirection';
-import { getVolumeCenterIJK } from '../../Viewport';
-import { getCpuEquivalentParallelScale, getOrthogonalVolumeSliceGeometry, } from './planarAdapterCoordinateTransforms';
-import { getPlanarViewStateVectors } from './planarOrientationVectors';
-import { getSafeCanvasDimension, normalizePoint3 } from './planarMath';
+import { InterpolationType, OrientationAxis } from '../../../enums/index.js';
+import { getImageDataMetadata } from '../../../utilities/getImageDataMetadata.js';
+import { getCubeSizeInView } from '../../../utilities/getPlaneCubeIntersectionDimensions.js';
+import getSpacingInNormalDirection from '../../../utilities/getSpacingInNormalDirection.js';
+import { getVolumeCenterIJK } from '../../Viewport.js';
+import { getCpuEquivalentParallelScale, getOrthogonalVolumeSliceGeometry, } from './planarAdapterCoordinateTransforms.js';
+import { getPlanarViewStateVectors } from './planarOrientationVectors.js';
+import { getSafeCanvasDimension, normalizePoint3 } from './planarMath.js';
 const MIN_CAMERA_DISTANCE = 1;
 const MIN_SLICE_SPACING = 1e-6;
 const ORTHONORMAL_EPSILON = 1e-6;