@cornerstonejs/core 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/esm/types/Point3.d.ts

@@ -1,2 +1,7 @@
-declare type Point3 = [number, number, number];
-export default Point3;
+export type Point3 = [number, number, number];
+export interface PointsXYZ {
+    x: number[];
+    y: number[];
+    z: number[];
+}
+export type { Point3 as default };

package/dist/esm/types/Point3.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Point3.js.map

package/dist/esm/types/Point4.d.ts

@@ -1,2 +1,2 @@
-declare type Point4 = [number, number, number, number];
-export default Point4;
+type Point4 = [number, number, number, number];
+export type { Point4 as default };

package/dist/esm/types/Point4.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Point4.js.map

package/dist/esm/types/RGB.d.ts

@@ -1,2 +1,2 @@
-declare type RGB = [number, number, number];
-export default RGB;
+type RGB = [number, number, number];
+export type { RGB as default };

package/dist/esm/types/RGB.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=RGB.js.map

package/dist/esm/types/ScalingParameters.d.ts

@@ -1,19 +1,19 @@
-declare type ScalingParameters = {
+interface ScalingParameters {
     rescaleSlope: number;
     rescaleIntercept: number;
     modality: string;
     suvbw?: number;
     suvlbm?: number;
     suvbsa?: number;
-};
-declare type PTScaling = {
+}
+interface PTScaling {
     suvbwToSuvlbm?: number;
     suvbwToSuvbsa?: number;
     suvbw?: number;
     suvlbm?: number;
     suvbsa?: number;
-};
-declare type Scaling = {
+}
+interface Scaling {
     PT?: PTScaling;
-};
-export { PTScaling, Scaling, ScalingParameters };
+}
+export type { PTScaling, Scaling, ScalingParameters };

package/dist/esm/types/ScalingParameters.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ScalingParameters.js.map

package/dist/esm/types/StackViewportProperties.d.ts

@@ -1,9 +1,8 @@
-import InterpolationType from '../enums/InterpolationType';
-import { ViewportProperties } from './ViewportProperties';
-declare type StackViewportProperties = ViewportProperties & {
+import type InterpolationType from '../enums/InterpolationType';
+import type { ViewportProperties } from './ViewportProperties';
+type StackViewportProperties = ViewportProperties & {
     interpolationType?: InterpolationType;
-    rotation?: number;
     suppressEvents?: boolean;
     isComputedVOI?: boolean;
 };
-export default StackViewportProperties;
+export type { StackViewportProperties as default };

package/dist/esm/types/StackViewportProperties.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=StackViewportProperties.js.map

package/dist/esm/types/SurfaceData.d.ts

@@ -0,0 +1,12 @@
+import type Point3 from './Point3';
+interface PublicSurfaceData {
+    id: string;
+    data: SurfaceData;
+    frameOfReferenceUID: string;
+    color?: Point3;
+}
+interface SurfaceData {
+    points: number[];
+    polys: number[];
+}
+export type { PublicSurfaceData, SurfaceData };

package/dist/esm/types/TransformMatrix2D.d.ts

@@ -1,2 +1,2 @@
-declare type TransformMatrix2D = [number, number, number, number, number, number];
-export default TransformMatrix2D;
+type TransformMatrix2D = [number, number, number, number, number, number];
+export type { TransformMatrix2D as default };

package/dist/esm/types/TransformMatrix2D.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=TransformMatrix2D.js.map

package/dist/esm/types/VideoViewportProperties.d.ts

@@ -0,0 +1,10 @@
+import type { ViewportProperties } from './ViewportProperties';
+import type Point2 from './Point2';
+type VideoViewportProperties = ViewportProperties & {
+    loop?: boolean;
+    muted?: boolean;
+    pan?: Point2;
+    playbackRate?: number;
+    scrollSpeed?: number;
+};
+export type { VideoViewportProperties as default };

package/dist/esm/types/VideoViewportTypes.d.ts

@@ -0,0 +1,18 @@
+import type { ViewportType } from '../enums';
+import type Point2 from './Point2';
+export interface InternalVideoCamera {
+    panWorld?: Point2;
+    parallelScale?: number;
+}
+export interface VideoViewportInput {
+    id: string;
+    renderingEngineId: string;
+    type: ViewportType;
+    element: HTMLDivElement;
+    sx: number;
+    sy: number;
+    sWidth: number;
+    sHeight: number;
+    defaultOptions: unknown;
+    canvas: HTMLCanvasElement;
+}

package/dist/esm/types/ViewportInputOptions.d.ts

@@ -1,12 +1,12 @@
-import { OrientationAxis } from '../enums';
-import OrientationVectors from './OrientationVectors';
-import DisplayArea from './displayArea';
-import RGB from './RGB';
-declare type ViewportInputOptions = {
+import type { OrientationAxis } from '../enums';
+import type OrientationVectors from './OrientationVectors';
+import type DisplayArea from './displayArea';
+import type RGB from './RGB';
+interface ViewportInputOptions {
     background?: RGB;
     orientation?: OrientationAxis | OrientationVectors;
     displayArea?: DisplayArea;
     suppressEvents?: boolean;
     parallelProjection?: boolean;
-};
-export default ViewportInputOptions;
+}
+export type { ViewportInputOptions as default };

package/dist/esm/types/ViewportInputOptions.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ViewportInputOptions.js.map

package/dist/esm/types/ViewportPreset.d.ts

@@ -10,4 +10,4 @@ interface ViewportPreset {
     diffuse: string;
     interpolation: string;
 }
-export default ViewportPreset;
+export type { ViewportPreset as default };

package/dist/esm/types/ViewportPreset.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ViewportPreset.js.map

package/dist/esm/types/ViewportProperties.d.ts

@@ -1,9 +1,11 @@
-import { InterpolationType, VOILUTFunctionType } from '../enums';
-import { VOIRange } from './voi';
-declare type ViewportProperties = {
+import type { InterpolationType, VOILUTFunctionType } from '../enums';
+import type { VOIRange } from './voi';
+import type { ColormapPublic } from './Colormap';
+export interface ViewportProperties {
     voiRange?: VOIRange;
     VOILUTFunction?: VOILUTFunctionType;
     invert?: boolean;
+    colormap?: ColormapPublic;
     interpolationType?: InterpolationType;
-};
-export type { ViewportProperties };
+    preset?: string;
+}

package/dist/esm/types/ViewportProperties.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ViewportProperties.js.map

package/dist/esm/types/VolumeLoaderFn.d.ts

@@ -1,6 +1,7 @@
-declare type VolumeLoaderFn = (volumeId: string, options?: Record<string, any>) => {
-    promise: Promise<Record<string, any>>;
+import type IImageVolume from './IImageVolume';
+type VolumeLoaderFn = (volumeId: string, options?: Record<string, unknown>) => {
+    promise: Promise<IImageVolume>;
     cancelFn?: () => void | undefined;
     decache?: () => void | undefined;
 };
-export default VolumeLoaderFn;
+export type { VolumeLoaderFn as default };

package/dist/esm/types/VolumeLoaderFn.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=VolumeLoaderFn.js.map

package/dist/esm/types/VolumeProps.d.ts

@@ -0,0 +1,32 @@
+import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type Point3 from './Point3';
+import type Metadata from './Metadata';
+import type Mat3 from './Mat3';
+import type { PixelDataTypedArray, PixelDataTypedArrayString } from './PixelDataTypedArray';
+import type RGB from './RGB';
+import type { IVoxelManager } from './IVoxelManager';
+interface VolumeProps {
+    volumeId: string;
+    metadata: Metadata;
+    dimensions: Point3;
+    spacing: Point3;
+    origin: Point3;
+    direction: Mat3;
+    imageData?: vtkImageData;
+    voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
+    dataType: PixelDataTypedArrayString;
+    scalarData?: PixelDataTypedArray | PixelDataTypedArray[];
+    sizeInBytes?: number;
+    additionalDetails?: Record<string, unknown>;
+    scaling?: {
+        PT?: {
+            SUVlbmFactor?: number;
+            SUVbsaFactor?: number;
+            suvbwToSuvlbm?: number;
+            suvbwToSuvbsa?: number;
+        };
+    };
+    referencedVolumeId?: string;
+    numberOfComponents?: number;
+}
+export type { VolumeProps };

package/dist/esm/types/VolumeViewportProperties.d.ts

@@ -1,7 +1,8 @@
-import { ColormapPublic } from './Colormap';
-import { ViewportProperties } from './ViewportProperties';
-declare type VolumeViewportProperties = ViewportProperties & {
-    colormap?: ColormapPublic;
+import type { ViewportProperties } from './ViewportProperties';
+import type { OrientationAxis } from '../enums';
+type VolumeViewportProperties = ViewportProperties & {
     preset?: string;
+    slabThickness?: number;
+    orientation?: OrientationAxis;
 };
-export default VolumeViewportProperties;
+export type { VolumeViewportProperties as default };

package/dist/esm/types/VolumeViewportProperties.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=VolumeViewportProperties.js.map

package/dist/esm/types/WSIViewportProperties.d.ts

@@ -0,0 +1,3 @@
+import type { ViewportProperties } from './ViewportProperties';
+export type WSIViewportProperties = ViewportProperties;
+export type { WSIViewportProperties as default };

package/dist/esm/types/displayArea.d.ts

@@ -1,9 +1,13 @@
-declare type DisplayArea = {
-    imageArea: [number, number];
-    imageCanvasPoint: {
+import type InterpolationType from '../enums/InterpolationType';
+interface DisplayArea {
+    type?: 'SCALE' | 'FIT';
+    scale?: number;
+    interpolationType?: InterpolationType;
+    imageArea?: [number, number];
+    imageCanvasPoint?: {
         imagePoint: [number, number];
-        canvasPoint: [number, number];
+        canvasPoint?: [number, number];
     };
-    storeAsInitialCamera: boolean;
-};
-export default DisplayArea;
+    storeAsInitialCamera?: boolean;
+}
+export type { DisplayArea as default };

package/dist/esm/types/displayArea.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=displayArea.js.map

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

@@ -2,7 +2,7 @@ import type Cornerstone3DConfig from './Cornerstone3DConfig';
 import type ICamera from './ICamera';
 import type IEnabledElement from './IEnabledElement';
 import type ICache from './ICache';
-import type { IVolume, VolumeScalarData } from './IVolume';
+import type { IVolume } from './IVolume';
 import type { VOI, VOIRange } from './voi';
 import type DisplayArea from './displayArea';
 import type ImageLoaderFn from './ImageLoaderFn';
@@ -12,14 +12,18 @@ import type VolumeLoaderFn from './VolumeLoaderFn';
 import type IRegisterImageLoader from './IRegisterImageLoader';
 import type IStreamingVolumeProperties from './IStreamingVolumeProperties';
 import type CustomEventType from './CustomEventType';
-import type { IViewport, PublicViewportInput } from './IViewport';
-import type { VolumeActor, Actor, ActorEntry } from './IActor';
+import type { LocalVolumeOptions } from './../loaders/volumeLoader';
+import type { IViewport, PublicViewportInput, ViewReferenceSpecifier, DataSetOptions, ReferenceCompatibleOptions, ViewReference, ViewPresentation, ViewPresentationSelector, ViewportInput } from './IViewport';
+import type { VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor } from './IActor';
 import type { IImageLoadObject, IVolumeLoadObject, IGeometryLoadObject } from './ILoadObject';
 import type Metadata from './Metadata';
 import type OrientationVectors from './OrientationVectors';
+import type AABB2 from './AABB2';
+import type AABB3 from './AABB3';
 import type Point2 from './Point2';
 import type Point3 from './Point3';
 import type Point4 from './Point4';
+import type { PointsXYZ } from './Point3';
 import type Mat3 from './Mat3';
 import type Plane from './Plane';
 import type IStreamingImageVolume from './IStreamingImageVolume';
@@ -37,6 +41,7 @@ import type FlipDirection from './FlipDirection';
 import type ICachedImage from './ICachedImage';
 import type ICachedVolume from './ICachedVolume';
 import type IStackViewport from './IStackViewport';
+import type IWSIViewport from './IWSIViewport';
 import type IVolumeViewport from './IVolumeViewport';
 import type ViewportPreset from './ViewportPreset';
 import type CPUFallbackEnabledElement from './CPUFallbackEnabledElement';
@@ -44,27 +49,48 @@ import type CPUFallbackViewport from './CPUFallbackViewport';
 import type CPUFallbackTransform from './CPUFallbackTransform';
 import type CPUFallbackColormapData from './CPUFallbackColormapData';
 import type CPUFallbackViewportDisplayedArea from './CPUFallbackViewportDisplayedArea';
-import type CPUFallbackColormapsData from './CPUFallbackColormapsData';
+import type { CPUFallbackColormapsData } from './CPUFallbackColormapsData';
 import type CPUFallbackColormap from './CPUFallbackColormap';
 import type TransformMatrix2D from './TransformMatrix2D';
 import type CPUFallbackLookupTable from './CPUFallbackLookupTable';
 import type CPUFallbackLUT from './CPUFallbackLUT';
 import type CPUFallbackRenderingTools from './CPUFallbackRenderingTools';
 import type { IVolumeInput, VolumeInputCallback } from './IVolumeInput';
+import type { IStackInput, StackInputCallback } from './IStackInput';
 import type * as EventTypes from './EventTypes';
 import type IRenderingEngine from './IRenderingEngine';
 import type ActorSliceRange from './ActorSliceRange';
 import type ImageSliceData from './ImageSliceData';
 import type IGeometry from './IGeometry';
 import type { PublicContourSetData, ContourSetData, ContourData } from './ContourData';
+import type { PublicSurfaceData, SurfaceData } from './SurfaceData';
 import type ICachedGeometry from './ICachedGeometry';
 import type { IContourSet } from './IContourSet';
 import type { IContour } from './IContour';
 import type RGB from './RGB';
-import { ColormapPublic, ColormapRegistration } from './Colormap';
+import type { ColormapPublic, ColormapRegistration } from './Colormap';
 import type { ViewportProperties } from './ViewportProperties';
-import type { PixelDataTypedArray } from './PixelDataTypedArray';
+import type { PixelDataTypedArray, PixelDataTypedArrayString } from './PixelDataTypedArray';
 import type { ImagePixelModule } from './ImagePixelModule';
 import type { ImagePlaneModule } from './ImagePlaneModule';
 import type { AffineMatrix } from './AffineMatrix';
-export type { Cornerstone3DConfig, ICamera, IStackViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, VolumeScalarData, IViewportId, IImageVolume, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, ViewportPreset, Metadata, OrientationVectors, Point2, Point3, Point4, Mat3, Plane, ViewportInputOptions, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, ImagePixelModule, ImagePlaneModule, AffineMatrix, };
+export type { RetrieveStage, RetrieveOptions, RangeRetrieveOptions, StreamingRetrieveOptions, NearbyFrames, IRetrieveConfiguration, IImagesLoader, } from './IRetrieveConfiguration';
+import type { ImageLoadListener } from './ImageLoadListener';
+import type { Color, ColorLUT } from './Color';
+import type VideoViewportProperties from './VideoViewportProperties';
+import type WSIViewportProperties from './WSIViewportProperties';
+import type { IVideoViewport } from './IVideoViewport';
+import type { InternalVideoCamera, VideoViewportInput } from './VideoViewportTypes';
+import type { ISurface } from './ISurface';
+import type BoundsIJK from './BoundsIJK';
+import type { ImageVolumeProps } from './ImageVolumeProps';
+import type { VolumeProps } from './VolumeProps';
+import type { BoundsLPS } from './BoundsLPS';
+import type { IPointsManager, PolyDataPointConfiguration } from './IPointsManager';
+import type IImageFrame from './IImageFrame';
+import type { DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata } from './MetadataModuleTypes';
+import type { IVoxelManager } from './IVoxelManager';
+import type { IRLEVoxelMap, RLERun } from './IRLEVoxelMap';
+import type ImageLoadRequests from './ImageLoadRequests';
+import type { IBaseVolumeViewport } from './IBaseVolumeViewport';
+export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, };

package/dist/esm/types/index.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=index.js.map

package/dist/esm/types/voi.d.ts

@@ -1,9 +1,9 @@
-declare type VOI = {
+interface VOI {
     windowWidth: number;
     windowCenter: number;
-};
-declare type VOIRange = {
+}
+interface VOIRange {
     upper: number;
     lower: number;
-};
+}
 export type { VOI, VOIRange };

package/dist/esm/types/voi.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=voi.js.map

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

@@ -0,0 +1,31 @@
+import type { IPointsManager, PolyDataPointConfiguration } from '../types';
+import type Point2 from '../types/Point2';
+import type Point3 from '../types/Point3';
+import type { PointsXYZ } from '../types/Point3';
+export default class PointsManager<T> {
+    kIndex: number;
+    sources: IPointsManager<T>[];
+    data: Float32Array;
+    _dimensions: number;
+    _length: number;
+    _byteSize: number;
+    growSize: number;
+    array: ArrayBuffer;
+    constructor(configuration?: PolyDataPointConfiguration);
+    forEach(func: (value: T, index: number) => void): void;
+    get length(): number;
+    get dimensions(): number;
+    get dimensionLength(): number;
+    getPoint(index: number): T;
+    getPointArray(index: number): T;
+    protected grow(additionalSize?: number, growSize?: number): void;
+    reverse(): void;
+    push(point: T): void;
+    map<R>(f: (value: any, index: number) => R): R[];
+    get points(): T[];
+    toXYZ(): PointsXYZ;
+    static fromXYZ({ x, y, z }: PointsXYZ): IPointsManager<Point3>;
+    subselect(count?: number, offset?: number): IPointsManager<T>;
+    static create3(initialSize?: number): PointsManager<Point3>;
+    static create2(initialSize?: number): PointsManager<Point2>;
+}

package/dist/esm/utilities/PointsManager.js

@@ -0,0 +1,137 @@
+export default class PointsManager {
+    constructor(configuration = {}) {
+        this._dimensions = 3;
+        this._length = 0;
+        this._byteSize = 4;
+        this.growSize = 128;
+        const { initialSize = 1024, dimensions = 3, growSize = 128, } = configuration;
+        const itemLength = initialSize * dimensions;
+        this.growSize = growSize;
+        this.array = new ArrayBuffer(itemLength * this._byteSize);
+        this.data = new Float32Array(this.array);
+        this._dimensions = dimensions;
+    }
+    forEach(func) {
+        for (let i = 0; i < this._length; i++) {
+            func(this.getPoint(i), i);
+        }
+    }
+    get length() {
+        return this._length;
+    }
+    get dimensions() {
+        return this._dimensions;
+    }
+    get dimensionLength() {
+        return this._length * this._dimensions;
+    }
+    getPoint(index) {
+        if (index < 0) {
+            index += this._length;
+        }
+        if (index < 0 || index >= this._length) {
+            return;
+        }
+        const offset = this._dimensions * index;
+        return this.data.subarray(offset, offset + this._dimensions);
+    }
+    getPointArray(index) {
+        const array = [];
+        if (index < 0) {
+            index += this._length;
+        }
+        if (index < 0 || index >= this._length) {
+            return;
+        }
+        const offset = this._dimensions * index;
+        for (let i = 0; i < this._dimensions; i++) {
+            array.push(this.data[i + offset]);
+        }
+        return array;
+    }
+    grow(additionalSize = 1, growSize = this.growSize) {
+        if (this.dimensionLength + additionalSize * this._dimensions <=
+            this.data.length) {
+            return;
+        }
+        const newSize = this.data.length + growSize;
+        const newArray = new ArrayBuffer(newSize * this._dimensions * this._byteSize);
+        const newData = new Float32Array(newArray);
+        newData.set(this.data);
+        this.data = newData;
+        this.array = newArray;
+    }
+    reverse() {
+        const midLength = Math.floor(this._length / 2);
+        for (let i = 0; i < midLength; i++) {
+            const indexStart = i * this._dimensions;
+            const indexEnd = (this._length - 1 - i) * this._dimensions;
+            for (let dimension = 0; dimension < this._dimensions; dimension++) {
+                const valueStart = this.data[indexStart + dimension];
+                this.data[indexStart + dimension] = this.data[indexEnd + dimension];
+                this.data[indexEnd + dimension] = valueStart;
+            }
+        }
+    }
+    push(point) {
+        this.grow(1);
+        const offset = this.length * this._dimensions;
+        for (let i = 0; i < this._dimensions; i++) {
+            this.data[i + offset] = point[i];
+        }
+        this._length++;
+    }
+    map(f) {
+        const mapData = [];
+        for (let i = 0; i < this._length; i++) {
+            mapData.push(f(this.getPoint(i), i));
+        }
+        return mapData;
+    }
+    get points() {
+        return this.map((p) => p);
+    }
+    toXYZ() {
+        const xyz = { x: [], y: [] };
+        if (this._dimensions >= 3) {
+            xyz.z = [];
+        }
+        const { x, y, z } = xyz;
+        this.forEach((p) => {
+            x.push(p[0]);
+            y.push(p[1]);
+            if (z) {
+                z.push(p[2]);
+            }
+        });
+        return xyz;
+    }
+    static fromXYZ({ x, y, z }) {
+        const array = PointsManager.create3(x.length);
+        let offset = 0;
+        for (let i = 0; i < x.length; i++) {
+            array.data[offset++] = x[i];
+            array.data[offset++] = y[i];
+            array.data[offset++] = z ? z[i] : 0;
+        }
+        array._length = x.length;
+        return array;
+    }
+    subselect(count = 10, offset = 0) {
+        const selected = new PointsManager({
+            initialSize: count,
+            dimensions: this._dimensions,
+        });
+        for (let i = 0; i < count; i++) {
+            const index = (offset + Math.floor((this.length * i) / count)) % this.length;
+            selected.push(this.getPoint(index));
+        }
+        return selected;
+    }
+    static create3(initialSize = 128) {
+        return new PointsManager({ initialSize, dimensions: 3 });
+    }
+    static create2(initialSize = 128) {
+        return new PointsManager({ initialSize, dimensions: 2 });
+    }
+}

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

@@ -0,0 +1,24 @@
+export declare class PromiseIterator<T> extends Promise<T> {
+    iterator?: ProgressiveIterator<T>;
+}
+export type ErrorCallback = (message: string | Error) => void;
+export default class ProgressiveIterator<T> {
+    done: any;
+    name?: string;
+    private nextValue;
+    private waiting;
+    private rejectReason;
+    constructor(name?: any);
+    static as(promise: any): any;
+    add(x: T, done?: boolean): void;
+    resolve(): void;
+    reject(reason: Error): void;
+    getRecent(): T;
+    [Symbol.asyncIterator](): AsyncGenerator<any, void, unknown>;
+    forEach(callback: any, errorCallback: any): Promise<void>;
+    generate(processFunction: any, errorCallback?: ErrorCallback): Promise<unknown>;
+    nextPromise(): Promise<T>;
+    donePromise(): Promise<T>;
+    getNextPromise(): PromiseIterator<T>;
+    getDonePromise(): PromiseIterator<T>;
+}