gaussian-splat-lite 1.2.2 → 1.3.0

package/dist/types/data/SplatOpacityTable.d.ts

@@ -1,32 +1,32 @@
-import * as THREE from "three";
+import type * as THREE from "three";
 /** Source blocks hold group IDs; a small float32 table holds their opacities. */
 export declare class SplatOpacityTable {
-    private blocks;
-    private readonly blockSize;
-    private readonly blocksPerLayer;
-    private readonly blockTexture;
-    private dirtyLayers;
-    private dirty;
-    private values;
-    private valueTexture;
-    private valuesDirty;
-    private readonly ranges;
-    private readonly freeGroups;
-    private nextGroup;
-    constructor(capacity: number, layerSize: number, blockBits: number);
-    private createTexture;
-    private createValueTexture;
-    /** CPU arrays and GPU storage each occupy this many bytes. */
-    get byteLength(): number;
-    getOpacity(source: number): number;
-    setGroupOpacity(group: number, opacity: number): boolean;
-    private releaseBlock;
-    /** Validated ranges retain their group while only its coefficient changes. */
-    setOpacity(start: number, count: number, opacity: number): boolean;
-    copyBlocks(): Uint32Array<ArrayBuffer>;
-    /** Adopt a prepared RAD table, retaining any uploads still pending. */
-    commitBlocks(blocks: Uint32Array, dirtyLayers: Uint8Array): void;
-    get texture(): THREE.DataArrayTexture;
-    get opacityTexture(): THREE.DataArrayTexture;
-    dispose(): void;
+  private blocks;
+  private readonly blockSize;
+  private readonly blocksPerLayer;
+  private readonly blockTexture;
+  private dirtyLayers;
+  private dirty;
+  private values;
+  private valueTexture;
+  private valuesDirty;
+  private readonly ranges;
+  private readonly freeGroups;
+  private nextGroup;
+  constructor(capacity: number, layerSize: number, blockBits: number);
+  private createTexture;
+  private createValueTexture;
+  /** CPU arrays and GPU storage each occupy this many bytes. */
+  get byteLength(): number;
+  getOpacity(source: number): number;
+  setGroupOpacity(group: number, opacity: number): boolean;
+  private releaseBlock;
+  /** Validated ranges retain their group while only its coefficient changes. */
+  setOpacity(start: number, count: number, opacity: number): boolean;
+  copyBlocks(): Uint32Array<ArrayBuffer>;
+  /** Adopt a prepared RAD table, retaining any uploads still pending. */
+  commitBlocks(blocks: Uint32Array, dirtyLayers: Uint8Array): void;
+  get texture(): THREE.DataArrayTexture;
+  get opacityTexture(): THREE.DataArrayTexture;
+  dispose(): void;
 }

package/dist/types/data/Splats.d.cts

@@ -1,78 +1,108 @@
-import { SplatFileResolver, SplatProgressEvent } from '../loaders/loadTypes.cjs';
-import { SplatPostDecodeProgram } from '../loaders/postDecode/program.cjs';
-import { ReorderedSplatResult, SplatFileType, SplatResult } from './defines.cjs';
-import { RaycastRangeCallback, SplatRaycastQuery } from './raycast.cjs';
-import { decodeSplat } from './unpack.cjs';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type {
+  SplatFileResolver,
+  SplatProgressEvent,
+} from "../loaders/loadTypes.cjs";
+import type { SplatPostDecodeProgram } from "../loaders/postDecode/program.cjs";
+import type {
+  ReorderedSplatResult,
+  SplatFileType,
+  SplatResult,
+} from "./defines.cjs";
+import type { RaycastRangeCallback, SplatRaycastQuery } from "./raycast.cjs";
+import type { decodeSplat } from "./unpack.cjs";
 type DecodedSplat = ReturnType<typeof decodeSplat>;
 type DecodedSplatWithSh = DecodedSplat & {
-    sh: THREE.Color[];
+  sh: THREE.Color[];
 };
 export type SplatsOptions = {
-    url?: string;
-    file?: Blob;
-    fileBytes?: Uint8Array | ArrayBuffer;
-    fileType?: SplatFileType;
-    fileName?: string;
-    /** Resolve external SOG images or RAD chunks by metadata filename. */
-    resolveFile?: SplatFileResolver;
-    /** Declarative per-splat transform executed in the decode worker. */
-    postDecode?: SplatPostDecodeProgram;
-    onProgress?: (event: SplatProgressEvent) => void;
+  url?: string;
+  file?: Blob;
+  fileBytes?: Uint8Array | ArrayBuffer;
+  fileType?: SplatFileType;
+  fileName?: string;
+  /** Resolve external SOG images or RAD chunks by metadata filename. */
+  resolveFile?: SplatFileResolver;
+  /** Declarative per-splat transform executed in the decode worker. */
+  postDecode?: SplatPostDecodeProgram;
+  onProgress?: (event: SplatProgressEvent) => void;
 };
 /** An encoded splat source with two 16-byte texture records per splat. */
 export declare class Splats {
-    maxSplats: number;
-    numSplats: number;
-    private splatArrays;
-    private sortCenters?;
-    protected sourceIds: Uint32Array;
-    protected centerOnlyBounds: Float32Array;
-    protected bounds: Float32Array;
-    private spatialBounds;
-    private extra;
-    initialized: Promise<Splats>;
-    isInitialized: boolean;
-    needsUpdate: boolean;
-    private textures;
-    private shTextures;
-    private loadController?;
-    constructor(options?: SplatsOptions);
-    initialize(options?: SplatsOptions): Promise<Splats>;
-    private commitState;
-    /** @internal Adopt a loader result with precomputed bounds. */
-    initializeDecoded(data: ReorderedSplatResult): void;
-    private asyncInitialize;
-    dispose(): void;
-    private disposeTextures;
-    getNumSplats(): number;
-    /** @internal Copy cached local bounds into the target box. */
-    getBoundingBox(centersOnly?: boolean, target?: THREE.Box3): THREE.Box3;
-    getNumSh(): 0 | 1 | 2 | 3;
-    /** Current retained bytes for encoded Splat, sort-center, and SH arrays. */
-    getByteLength(): number;
-    /** @internal Consume owned arrays for transfer to a streaming worker. */
-    takeData(): SplatResult & {
-        sourceIds: Uint32Array;
-    };
-    /** Original source ID, retained across reordering and range extraction. */
-    getSourceIndex(index: number): number;
-    getSplat(index: number): DecodedSplatWithSh;
-    getSplat(index: number, includeSh: true): DecodedSplatWithSh;
-    getSplat(index: number, includeSh: false): DecodedSplat;
-    getSplat(index: number, includeSh: boolean): DecodedSplat;
-    /** @internal Consecutive visible records surviving spatial block picking. */
-    forEachRaycastRange(query: SplatRaycastQuery, callback: RaycastRangeCallback): void;
-    copySplatRecords(firstTarget: Uint32Array, secondTarget: Uint32Array, sourceStart: number, count: number): void;
-    copySortCenters(target: Float32Array, targetStart: number, count: number): void;
-    private getSortCenters;
-    forEachCenter(callback: (index: number, x: number, y: number, z: number) => void): void;
-    forEachSplat(callback: (index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color) => void): void;
-    setTextureUniforms(uniforms: Record<string, THREE.IUniform>): void;
-    private getSplatTextures;
-    private disposeMainTextures;
-    private getShTextures;
-    private ensureShTexture;
-    static emptyTexture: THREE.DataArrayTexture;
+  maxSplats: number;
+  numSplats: number;
+  private splatArrays;
+  private sortCenters?;
+  protected sourceIds: Uint32Array;
+  protected centerOnlyBounds: Float32Array;
+  protected bounds: Float32Array;
+  private spatialBounds;
+  private extra;
+  initialized: Promise<Splats>;
+  isInitialized: boolean;
+  needsUpdate: boolean;
+  private textures;
+  private shTextures;
+  private loadController?;
+  constructor(options?: SplatsOptions);
+  initialize(options?: SplatsOptions): Promise<Splats>;
+  private commitState;
+  /** @internal Adopt a loader result with precomputed bounds. */
+  initializeDecoded(data: ReorderedSplatResult): void;
+  private asyncInitialize;
+  dispose(): void;
+  private disposeTextures;
+  getNumSplats(): number;
+  /** @internal Copy cached local bounds into the target box. */
+  getBoundingBox(centersOnly?: boolean, target?: THREE.Box3): THREE.Box3;
+  getNumSh(): 1 | 2 | 0 | 3;
+  /** Current retained bytes for encoded Splat, sort-center, and SH arrays. */
+  getByteLength(): number;
+  /** @internal Consume owned arrays for transfer to a streaming worker. */
+  takeData(): SplatResult & {
+    sourceIds: Uint32Array;
+  };
+  /** Original source ID, retained across reordering and range extraction. */
+  getSourceIndex(index: number): number;
+  getSplat(index: number): DecodedSplatWithSh;
+  getSplat(index: number, includeSh: true): DecodedSplatWithSh;
+  getSplat(index: number, includeSh: false): DecodedSplat;
+  getSplat(index: number, includeSh: boolean): DecodedSplat;
+  /** @internal Consecutive visible records surviving spatial block picking. */
+  forEachRaycastRange(
+    query: SplatRaycastQuery,
+    callback: RaycastRangeCallback,
+  ): void;
+  copySplatRecords(
+    firstTarget: Uint32Array,
+    secondTarget: Uint32Array,
+    sourceStart: number,
+    count: number,
+  ): void;
+  copySortCenters(
+    target: Float32Array,
+    targetStart: number,
+    count: number,
+  ): void;
+  private getSortCenters;
+  forEachCenter(
+    callback: (index: number, x: number, y: number, z: number) => void,
+  ): void;
+  forEachSplat(
+    callback: (
+      index: number,
+      center: THREE.Vector3,
+      scales: THREE.Vector3,
+      quaternion: THREE.Quaternion,
+      opacity: number,
+      color: THREE.Color,
+    ) => void,
+  ): void;
+  setTextureUniforms(uniforms: Record<string, THREE.IUniform>): void;
+  private getSplatTextures;
+  private disposeMainTextures;
+  private getShTextures;
+  private ensureShTexture;
+  static emptyTexture: THREE.DataArrayTexture;
 }
 export {};

package/dist/types/data/Splats.d.ts

@@ -1,78 +1,108 @@
-import { SplatFileResolver, SplatProgressEvent } from '../loaders/loadTypes';
-import { SplatPostDecodeProgram } from '../loaders/postDecode/program';
-import { ReorderedSplatResult, SplatFileType, SplatResult } from './defines';
-import { RaycastRangeCallback, SplatRaycastQuery } from './raycast';
-import { decodeSplat } from './unpack';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type {
+  SplatFileResolver,
+  SplatProgressEvent,
+} from "../loaders/loadTypes.js";
+import type { SplatPostDecodeProgram } from "../loaders/postDecode/program.js";
+import type {
+  ReorderedSplatResult,
+  SplatFileType,
+  SplatResult,
+} from "./defines.js";
+import type { RaycastRangeCallback, SplatRaycastQuery } from "./raycast.js";
+import type { decodeSplat } from "./unpack.js";
 type DecodedSplat = ReturnType<typeof decodeSplat>;
 type DecodedSplatWithSh = DecodedSplat & {
-    sh: THREE.Color[];
+  sh: THREE.Color[];
 };
 export type SplatsOptions = {
-    url?: string;
-    file?: Blob;
-    fileBytes?: Uint8Array | ArrayBuffer;
-    fileType?: SplatFileType;
-    fileName?: string;
-    /** Resolve external SOG images or RAD chunks by metadata filename. */
-    resolveFile?: SplatFileResolver;
-    /** Declarative per-splat transform executed in the decode worker. */
-    postDecode?: SplatPostDecodeProgram;
-    onProgress?: (event: SplatProgressEvent) => void;
+  url?: string;
+  file?: Blob;
+  fileBytes?: Uint8Array | ArrayBuffer;
+  fileType?: SplatFileType;
+  fileName?: string;
+  /** Resolve external SOG images or RAD chunks by metadata filename. */
+  resolveFile?: SplatFileResolver;
+  /** Declarative per-splat transform executed in the decode worker. */
+  postDecode?: SplatPostDecodeProgram;
+  onProgress?: (event: SplatProgressEvent) => void;
 };
 /** An encoded splat source with two 16-byte texture records per splat. */
 export declare class Splats {
-    maxSplats: number;
-    numSplats: number;
-    private splatArrays;
-    private sortCenters?;
-    protected sourceIds: Uint32Array;
-    protected centerOnlyBounds: Float32Array;
-    protected bounds: Float32Array;
-    private spatialBounds;
-    private extra;
-    initialized: Promise<Splats>;
-    isInitialized: boolean;
-    needsUpdate: boolean;
-    private textures;
-    private shTextures;
-    private loadController?;
-    constructor(options?: SplatsOptions);
-    initialize(options?: SplatsOptions): Promise<Splats>;
-    private commitState;
-    /** @internal Adopt a loader result with precomputed bounds. */
-    initializeDecoded(data: ReorderedSplatResult): void;
-    private asyncInitialize;
-    dispose(): void;
-    private disposeTextures;
-    getNumSplats(): number;
-    /** @internal Copy cached local bounds into the target box. */
-    getBoundingBox(centersOnly?: boolean, target?: THREE.Box3): THREE.Box3;
-    getNumSh(): 0 | 1 | 2 | 3;
-    /** Current retained bytes for encoded Splat, sort-center, and SH arrays. */
-    getByteLength(): number;
-    /** @internal Consume owned arrays for transfer to a streaming worker. */
-    takeData(): SplatResult & {
-        sourceIds: Uint32Array;
-    };
-    /** Original source ID, retained across reordering and range extraction. */
-    getSourceIndex(index: number): number;
-    getSplat(index: number): DecodedSplatWithSh;
-    getSplat(index: number, includeSh: true): DecodedSplatWithSh;
-    getSplat(index: number, includeSh: false): DecodedSplat;
-    getSplat(index: number, includeSh: boolean): DecodedSplat;
-    /** @internal Consecutive visible records surviving spatial block picking. */
-    forEachRaycastRange(query: SplatRaycastQuery, callback: RaycastRangeCallback): void;
-    copySplatRecords(firstTarget: Uint32Array, secondTarget: Uint32Array, sourceStart: number, count: number): void;
-    copySortCenters(target: Float32Array, targetStart: number, count: number): void;
-    private getSortCenters;
-    forEachCenter(callback: (index: number, x: number, y: number, z: number) => void): void;
-    forEachSplat(callback: (index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color) => void): void;
-    setTextureUniforms(uniforms: Record<string, THREE.IUniform>): void;
-    private getSplatTextures;
-    private disposeMainTextures;
-    private getShTextures;
-    private ensureShTexture;
-    static emptyTexture: THREE.DataArrayTexture;
+  maxSplats: number;
+  numSplats: number;
+  private splatArrays;
+  private sortCenters?;
+  protected sourceIds: Uint32Array;
+  protected centerOnlyBounds: Float32Array;
+  protected bounds: Float32Array;
+  private spatialBounds;
+  private extra;
+  initialized: Promise<Splats>;
+  isInitialized: boolean;
+  needsUpdate: boolean;
+  private textures;
+  private shTextures;
+  private loadController?;
+  constructor(options?: SplatsOptions);
+  initialize(options?: SplatsOptions): Promise<Splats>;
+  private commitState;
+  /** @internal Adopt a loader result with precomputed bounds. */
+  initializeDecoded(data: ReorderedSplatResult): void;
+  private asyncInitialize;
+  dispose(): void;
+  private disposeTextures;
+  getNumSplats(): number;
+  /** @internal Copy cached local bounds into the target box. */
+  getBoundingBox(centersOnly?: boolean, target?: THREE.Box3): THREE.Box3;
+  getNumSh(): 1 | 2 | 0 | 3;
+  /** Current retained bytes for encoded Splat, sort-center, and SH arrays. */
+  getByteLength(): number;
+  /** @internal Consume owned arrays for transfer to a streaming worker. */
+  takeData(): SplatResult & {
+    sourceIds: Uint32Array;
+  };
+  /** Original source ID, retained across reordering and range extraction. */
+  getSourceIndex(index: number): number;
+  getSplat(index: number): DecodedSplatWithSh;
+  getSplat(index: number, includeSh: true): DecodedSplatWithSh;
+  getSplat(index: number, includeSh: false): DecodedSplat;
+  getSplat(index: number, includeSh: boolean): DecodedSplat;
+  /** @internal Consecutive visible records surviving spatial block picking. */
+  forEachRaycastRange(
+    query: SplatRaycastQuery,
+    callback: RaycastRangeCallback,
+  ): void;
+  copySplatRecords(
+    firstTarget: Uint32Array,
+    secondTarget: Uint32Array,
+    sourceStart: number,
+    count: number,
+  ): void;
+  copySortCenters(
+    target: Float32Array,
+    targetStart: number,
+    count: number,
+  ): void;
+  private getSortCenters;
+  forEachCenter(
+    callback: (index: number, x: number, y: number, z: number) => void,
+  ): void;
+  forEachSplat(
+    callback: (
+      index: number,
+      center: THREE.Vector3,
+      scales: THREE.Vector3,
+      quaternion: THREE.Quaternion,
+      opacity: number,
+      color: THREE.Color,
+    ) => void,
+  ): void;
+  setTextureUniforms(uniforms: Record<string, THREE.IUniform>): void;
+  private getSplatTextures;
+  private disposeMainTextures;
+  private getShTextures;
+  private ensureShTexture;
+  static emptyTexture: THREE.DataArrayTexture;
 }
 export {};

package/dist/types/data/defines.d.cts

@@ -6,37 +6,37 @@ export declare const SPLAT_TEX_MIN_HEIGHT = 1;
 /** Valid block shifts include zero (one opacity per Splat). */
 export declare const SPLAT_BLOCKS_DISABLED = 32;
 export declare enum SplatFileType {
-    PLY = "ply",
-    SPZ = "spz",
-    SOG = "sog",
-    RAD = "rad"
+  PLY = "ply",
+  SPZ = "spz",
+  SOG = "sog",
+  RAD = "rad",
 }
 export type SplatExtra = {
-    sh1?: Uint32Array;
-    sh2?: Uint32Array;
-    sh3a?: Uint32Array;
-    sh3b?: Uint32Array;
+  sh1?: Uint32Array;
+  sh2?: Uint32Array;
+  sh3a?: Uint32Array;
+  sh3b?: Uint32Array;
 };
 /** Morton storage records per cached spatial bounds block. */
 export declare const SPLAT_BOUNDS_BLOCK_SIZE = 256;
 export type SplatResult = {
-    numSplats: number;
-    splatArrays: [Uint32Array, Uint32Array];
-    sortCenters?: Float32Array;
-    /** Storage index to original source index; absent for identity order. */
-    sourceIds?: Uint32Array;
-    /** Local finite center bounds: min XYZ followed by max XYZ. */
-    centerOnlyBoundingBox?: Float32Array;
-    /** Local scale/rotation bounds at source alpha 0.01, including kernel shape. */
-    boundingBox?: Float32Array;
-    /** Per 256 records: min/max XYZ at source alpha 0.01, including scale, rotation and shape. */
-    spatialBounds?: Float32Array;
-    extra: SplatExtra;
+  numSplats: number;
+  splatArrays: [Uint32Array, Uint32Array];
+  sortCenters?: Float32Array;
+  /** Storage index to original source index; absent for identity order. */
+  sourceIds?: Uint32Array;
+  /** Local finite center bounds: min XYZ followed by max XYZ. */
+  centerOnlyBoundingBox?: Float32Array;
+  /** Local scale/rotation bounds at source alpha 0.01, including kernel shape. */
+  boundingBox?: Float32Array;
+  /** Per 256 records: min/max XYZ at source alpha 0.01, including scale, rotation and shape. */
+  spatialBounds?: Float32Array;
+  extra: SplatExtra;
 };
 /** Spatially reordered records with source IDs and cached local bounds. */
 export type ReorderedSplatResult = SplatResult & {
-    sourceIds: Uint32Array;
-    centerOnlyBoundingBox: Float32Array;
-    boundingBox: Float32Array;
-    spatialBounds: Float32Array;
+  sourceIds: Uint32Array;
+  centerOnlyBoundingBox: Float32Array;
+  boundingBox: Float32Array;
+  spatialBounds: Float32Array;
 };

package/dist/types/data/defines.d.ts

@@ -6,37 +6,37 @@ export declare const SPLAT_TEX_MIN_HEIGHT = 1;
 /** Valid block shifts include zero (one opacity per Splat). */
 export declare const SPLAT_BLOCKS_DISABLED = 32;
 export declare enum SplatFileType {
-    PLY = "ply",
-    SPZ = "spz",
-    SOG = "sog",
-    RAD = "rad"
+  PLY = "ply",
+  SPZ = "spz",
+  SOG = "sog",
+  RAD = "rad",
 }
 export type SplatExtra = {
-    sh1?: Uint32Array;
-    sh2?: Uint32Array;
-    sh3a?: Uint32Array;
-    sh3b?: Uint32Array;
+  sh1?: Uint32Array;
+  sh2?: Uint32Array;
+  sh3a?: Uint32Array;
+  sh3b?: Uint32Array;
 };
 /** Morton storage records per cached spatial bounds block. */
 export declare const SPLAT_BOUNDS_BLOCK_SIZE = 256;
 export type SplatResult = {
-    numSplats: number;
-    splatArrays: [Uint32Array, Uint32Array];
-    sortCenters?: Float32Array;
-    /** Storage index to original source index; absent for identity order. */
-    sourceIds?: Uint32Array;
-    /** Local finite center bounds: min XYZ followed by max XYZ. */
-    centerOnlyBoundingBox?: Float32Array;
-    /** Local scale/rotation bounds at source alpha 0.01, including kernel shape. */
-    boundingBox?: Float32Array;
-    /** Per 256 records: min/max XYZ at source alpha 0.01, including scale, rotation and shape. */
-    spatialBounds?: Float32Array;
-    extra: SplatExtra;
+  numSplats: number;
+  splatArrays: [Uint32Array, Uint32Array];
+  sortCenters?: Float32Array;
+  /** Storage index to original source index; absent for identity order. */
+  sourceIds?: Uint32Array;
+  /** Local finite center bounds: min XYZ followed by max XYZ. */
+  centerOnlyBoundingBox?: Float32Array;
+  /** Local scale/rotation bounds at source alpha 0.01, including kernel shape. */
+  boundingBox?: Float32Array;
+  /** Per 256 records: min/max XYZ at source alpha 0.01, including scale, rotation and shape. */
+  spatialBounds?: Float32Array;
+  extra: SplatExtra;
 };
 /** Spatially reordered records with source IDs and cached local bounds. */
 export type ReorderedSplatResult = SplatResult & {
-    sourceIds: Uint32Array;
-    centerOnlyBoundingBox: Float32Array;
-    boundingBox: Float32Array;
-    spatialBounds: Float32Array;
+  sourceIds: Uint32Array;
+  centerOnlyBoundingBox: Float32Array;
+  boundingBox: Float32Array;
+  spatialBounds: Float32Array;
 };

package/dist/types/data/raycast.d.cts

@@ -1,13 +1,17 @@
-import { Vector3 } from 'three';
+import type { Vector3 } from "three";
 /** Picking uses the same f32 ray and world-distance parameter as WASM. */
 export declare class SplatRaycastQuery {
-    private readonly origin;
-    private readonly direction;
-    private readonly near;
-    private readonly far;
-    constructor(origin: Vector3, direction: Vector3, near: number, far: number);
-    /** Visit consecutive candidate records in one Morton-ordered chunk. */
-    forEachRange(bounds: Float32Array, count: number, callback: RaycastRangeCallback): void;
-    private intersects;
+  private readonly origin;
+  private readonly direction;
+  private readonly near;
+  private readonly far;
+  constructor(origin: Vector3, direction: Vector3, near: number, far: number);
+  /** Visit consecutive candidate records in one Morton-ordered chunk. */
+  forEachRange(
+    bounds: Float32Array,
+    count: number,
+    callback: RaycastRangeCallback,
+  ): void;
+  private intersects;
 }
 export type RaycastRangeCallback = (start: number, count: number) => void;

package/dist/types/data/raycast.d.ts

@@ -1,13 +1,17 @@
-import { Vector3 } from 'three';
+import type { Vector3 } from "three";
 /** Picking uses the same f32 ray and world-distance parameter as WASM. */
 export declare class SplatRaycastQuery {
-    private readonly origin;
-    private readonly direction;
-    private readonly near;
-    private readonly far;
-    constructor(origin: Vector3, direction: Vector3, near: number, far: number);
-    /** Visit consecutive candidate records in one Morton-ordered chunk. */
-    forEachRange(bounds: Float32Array, count: number, callback: RaycastRangeCallback): void;
-    private intersects;
+  private readonly origin;
+  private readonly direction;
+  private readonly near;
+  private readonly far;
+  constructor(origin: Vector3, direction: Vector3, near: number, far: number);
+  /** Visit consecutive candidate records in one Morton-ordered chunk. */
+  forEachRange(
+    bounds: Float32Array,
+    count: number,
+    callback: RaycastRangeCallback,
+  ): void;
+  private intersects;
 }
 export type RaycastRangeCallback = (start: number, count: number) => void;

package/dist/types/data/splatCodec.d.cts

@@ -1,9 +1,33 @@
 export declare function decodeSplatOpacity(word: number): number;
 export declare function encodeSplatOpacity(opacity: number): number;
 type CodecOutput = Float32Array | number[];
-export declare function encodeShRgb(red: number, green: number, blue: number): number;
-export declare function decodeShRgbToArray(word: number, output: CodecOutput, base?: number, stride?: number): void;
-export declare function decodeQuatOctXy1010R12ToArray(word: number, output: CodecOutput, base?: number, stride?: number): void;
-export declare function encodeQuatOctXy1010R12(qx: number, qy: number, qz: number, qw: number): number;
-export declare function tryEncodeQuatOctXy1010R12(qx: number, qy: number, qz: number, qw: number): number | undefined;
+export declare function encodeShRgb(
+  red: number,
+  green: number,
+  blue: number,
+): number;
+export declare function decodeShRgbToArray(
+  word: number,
+  output: CodecOutput,
+  base?: number,
+  stride?: number,
+): void;
+export declare function decodeQuatOctXy1010R12ToArray(
+  word: number,
+  output: CodecOutput,
+  base?: number,
+  stride?: number,
+): void;
+export declare function encodeQuatOctXy1010R12(
+  qx: number,
+  qy: number,
+  qz: number,
+  qw: number,
+): number;
+export declare function tryEncodeQuatOctXy1010R12(
+  qx: number,
+  qy: number,
+  qz: number,
+  qw: number,
+): number | undefined;
 export {};