@equinor/videx-3d 5.1.0-beta

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

@@ -0,0 +1,39 @@
+/**
+ * @module sdk
+ */
+export * from './data/DataLoader';
+export * from './data/GeneratorRegistry';
+export * from './data/helpers/formations-helpers';
+export * from './data/helpers/well-helpers';
+export * from './data/Store';
+export * from './data/types';
+export * from './geometries/curve/curve-3d';
+export * from './geometries/curve/tube-geometry';
+export * from './geometries/delatin';
+export * from './geometries/fence';
+export * from './geometries/packing';
+export * from './geometries/triangulate-grid';
+export * from './geometries/triangulate-grid-delaunay';
+export * from './managers/CameraManager';
+export * from './managers/WellboreManager';
+export * from './projection/crs';
+export * from './types/common';
+export * from './utils/colors';
+export * from './utils/conversions';
+export * from './utils/depth-reader';
+export * from './utils/elevation-map';
+export * from './utils/glyphs';
+export * from './utils/irapbin-parser';
+export * from './utils/num-array';
+export * from './utils/numbers';
+export * from './utils/scene';
+export * from './utils/segments';
+export * from './utils/strings';
+export * from './utils/trajectory';
+export * from './utils/trigonometry';
+export * from './utils/typed-2d-array';
+export * from './utils/typed-array';
+export * from './utils/vector-operations';
+export * from './materials/depth-material';
+export * from './materials/tube-material';
+export * from './materials/uv-material';

package/dist/types/sdk/managers/CameraManager.d.ts

@@ -0,0 +1,11 @@
+import { CameraControls } from '@react-three/drei';
+import { Vec3 } from '../types/common';
+export declare class CameraManager {
+    controls: CameraControls | null;
+    removeEventlisteners: (() => void) | null;
+    constructor();
+    private addEventListeners;
+    setTarget(target: Vec3): Promise<void | null>;
+    setControls(controls: CameraControls): void;
+    dispose(): void;
+}

package/dist/types/sdk/managers/WellboreManager.d.ts

@@ -0,0 +1,18 @@
+import { Object3D } from 'three';
+import { Vec3 } from '../types/common';
+export type WellboreManagerRecord = {
+    wellboreId: string;
+    object: Object3D;
+};
+export declare class WellboreManager {
+    private map;
+    constructor();
+    private onWellboreAdded;
+    private onWellboreRemoved;
+    getInfo(id: string): {
+        position: Vec3;
+        wellboreId: string;
+        object: Object3D;
+    } | undefined;
+    dispose(): void;
+}

package/dist/types/sdk/materials/depth-material.d.ts

@@ -0,0 +1,4 @@
+import { ShaderMaterial } from 'three';
+export declare class DepthReadMaterial extends ShaderMaterial {
+    constructor();
+}

package/dist/types/sdk/materials/ribbon-material.d.ts

@@ -0,0 +1,24 @@
+import { Color, MeshLambertMaterialParameters, ShaderMaterial, Texture } from 'three';
+export type RibonMaterialParams = MeshLambertMaterialParameters & {
+    angle?: number;
+    width?: number;
+    offset?: number;
+    ignoreLight?: boolean;
+};
+export declare class RibbonMaterial extends ShaderMaterial {
+    isRibbonMaterial: boolean;
+    constructor(parameters?: RibonMaterialParams);
+    get color(): Color;
+    set color(color: Color);
+    get angle(): number;
+    set angle(a: number);
+    get offset(): number;
+    set offset(o: number);
+    get width(): number;
+    set width(w: number);
+    get map(): Texture | null;
+    set map(m: Texture | null);
+    get ignoreLight(): boolean;
+    set ignoreLight(f: boolean);
+    onBeforeCompile(): void;
+}

package/dist/types/sdk/materials/tube-material.d.ts

@@ -0,0 +1,7 @@
+import { Color, MeshBasicMaterialParameters, ShaderMaterial } from 'three';
+export declare class TubeMaterial extends ShaderMaterial {
+    isTubeMaterial: boolean;
+    constructor(parameters?: MeshBasicMaterialParameters);
+    get color(): Color;
+    set color(color: Color);
+}

package/dist/types/sdk/materials/uv-material.d.ts

@@ -0,0 +1,2 @@
+import { ShaderMaterial } from 'three';
+export declare const uvMaterial: ShaderMaterial;

package/dist/types/sdk/projection/crs.d.ts

@@ -0,0 +1,37 @@
+import { Converter } from 'proj4';
+export declare const wgs84Def = "+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs";
+/**
+ * Maps between real world UTM coordinates and 3d world coordinates by assigning a known real world
+ * position to the center of the 3d world and specifying an UTM zone.
+ */
+export declare class CRS {
+    utmDef: string;
+    originWgs84: [number, number];
+    originUtm: [number, number];
+    _projection: Converter;
+    constructor(utmDef: string, origin: [number, number], originUnits?: 'utm' | 'lnglat');
+    utmToWgs84(eastingNorthing: [number, number]): [number, number];
+    wgs84ToUtm(lngLat: [number, number]): [number, number];
+    utmToWorld(easting: number, northing: number, altitude: number): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    worldToUtm(x: number, y: number, z: number): {
+        easting: number;
+        altitude: number;
+        northing: number;
+    };
+    wgs84ToWorld(lng: number, lat: number, altitude?: number): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    worldToWgs84(x: number, y: number, z: number): {
+        lng: number;
+        lat: number;
+        alt: number;
+    };
+}
+export declare function getProjectionDefFromUtmZone(utmZone: string): string;
+export declare function getUtmZoneFromLatLng([lng, lat]: [number, number]): string;

package/dist/types/sdk/types/common.d.ts

@@ -0,0 +1,4 @@
+export type Vec2 = [number, number];
+export type Vec3 = [number, number, number];
+export type Vec4 = [number, number, number, number];
+export type Tuplet<T> = [T, T];

package/dist/types/sdk/utils/colors.d.ts

@@ -0,0 +1,2 @@
+export declare const idToHexColor: (num: number) => string;
+export declare function randomColor(): string;

package/dist/types/sdk/utils/conversions.d.ts

@@ -0,0 +1,5 @@
+import { Vec2 } from '../types/common';
+export declare function feetToMeters(feet: number): number;
+export declare function degreesToRadians(deg: number): number;
+export declare const screenToNormalizedDevice: (pos: Vec2, width?: number, height?: number) => Vec2;
+export declare const normalizedDeviceToScreen: (pos: Vec2, width?: number, height?: number) => Vec2;

package/dist/types/sdk/utils/depth-reader.d.ts

@@ -0,0 +1,5 @@
+import { PerspectiveCamera, Texture, WebGLRenderer } from 'three';
+/**
+ * Read-back the normalized device coordinates from a depth texture
+ */
+export declare function readDepth(depthTexture: Texture, renderer: WebGLRenderer, camera: PerspectiveCamera, idx?: number): Promise<number | number[] | null>;

package/dist/types/sdk/utils/elevation-map.d.ts

@@ -0,0 +1,15 @@
+import { DataTexture } from 'three';
+import { Vec3 } from '../../sdk';
+export declare function triangleNormal(p0: Vec3, p1: Vec3, p2: Vec3): Vec3;
+/**
+ * Calcukate and encode surface normals from an elevation grid as RGBA image values.
+ */
+export declare function elevationMapNormalsToRGBA(data: Float32Array, columns: number, xScale: number, yScale: number, rotation?: number, nullValue?: number): Uint8Array<ArrayBuffer>;
+/**
+ * Create a data texture from RGBA encoded normals
+ */
+export declare function createNormalTexture(buffer: Uint8Array, width: number, height: number): DataTexture;
+/**
+ * Create a data texture from RGBA encoded depth values
+ */
+export declare function createElevationTexture(buffer: Float32Array, width: number, height: number): DataTexture;

package/dist/types/sdk/utils/glyphs.d.ts

@@ -0,0 +1,50 @@
+import { DataTexture, UniformsGroup } from 'three';
+export type Glyph = {
+    position: [number, number];
+    dimension: [number, number];
+    offset: [number, number];
+    spacing: number;
+};
+export type EncodedTextSegment = {
+    indices: number[];
+    width: number;
+};
+export type EncodedTextTexture = {
+    texture: DataTexture;
+    textPointersOffset: number;
+    textPointersCount: number;
+};
+export type GlyphConfig = {
+    glyphsCount: number;
+    glyphData: UniformsGroup;
+    encodeText: (text: string) => EncodedTextSegment;
+    encodeTextTexture: (textSegments: string[] | string) => EncodedTextTexture;
+    dispose: () => void;
+};
+export interface MsdfFontJson {
+    info: {
+        size: number;
+    };
+    common: {
+        scaleW: number;
+        scaleH: number;
+        lineHeight: number;
+        base: number;
+    };
+    chars: {
+        id: number;
+        index: number;
+        char: string;
+        width: number;
+        height: number;
+        xoffset: number;
+        yoffset: number;
+        xadvance: number;
+        x: number;
+        y: number;
+    }[];
+    distanceField: {
+        distanceRange: number;
+    };
+}
+export declare function createConfig(json: MsdfFontJson): GlyphConfig;

package/dist/types/sdk/utils/irapbin-parser.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Parses irabin surface/horizon binary files and return the header information and elevation data
+ */
+export declare function parseIrapbin(blob: Blob, nullValue?: number, refDepth?: number | null): Promise<{
+    header: {
+        ny: number;
+        xori: number;
+        xmax: number;
+        yori: number;
+        ymax: number;
+        xinc: number;
+        yinc: number;
+        nx: number;
+        rot: number;
+    };
+    data: Float32Array<ArrayBuffer>;
+}>;

package/dist/types/sdk/utils/num-array.d.ts

@@ -0,0 +1,2 @@
+export declare function negate(numArray: number[]): number[];
+export declare function multiply(numArray: number[], factor: number): number[];

package/dist/types/sdk/utils/numbers.d.ts

@@ -0,0 +1,5 @@
+export declare function clamp(value: number, min?: number, max?: number): number;
+export declare function lerp(from: number, to: number, t: number): number;
+export declare function inverseLerp(v: number, minValue: number, maxValue: number): number;
+export declare function remap(v: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
+export declare const toRGB: (v: number) => number[];

package/dist/types/sdk/utils/packing.d.ts

@@ -0,0 +1 @@
+export declare function unpackRGBAToDepth(r: number, g: number, b: number, a: number): number;

package/dist/types/sdk/utils/scene.d.ts

@@ -0,0 +1,2 @@
+import { Object3D, Scene } from 'three';
+export declare function getObjectByCustomProperty(propName: string, value: any, scene: Scene): Object3D<import('three').Object3DEventMap> | null;

package/dist/types/sdk/utils/segments.d.ts

@@ -0,0 +1,4 @@
+export declare function toSegments<T>(intervals: T[], start: (item: T) => number, end: (item: T) => number): {
+    start: number;
+    end: number;
+}[];

package/dist/types/sdk/utils/strings.d.ts

@@ -0,0 +1,2 @@
+export declare function calculateHashValue(str?: string): number;
+export declare function titleCase(str: string): string;

package/dist/types/sdk/utils/trajectory.d.ts

@@ -0,0 +1,59 @@
+import { PositionLog } from '../data/types/PositionLog';
+import { Curve3D } from '../geometries/curve/curve-3d';
+import { Vec2, Vec3 } from '../types/common';
+/**
+ * Interface for defining a trajectory. This can be used to work with wellbore trajectories,
+ * where the measured top, termination point and length are known. The measured length should
+ * be used when calculating positions of data given in MD, so that the position on the curve is
+ * given by:
+ *
+ * @example
+ * const pos = (md - trajectory.measuredTop) / trajectory.measuredLength
+ *
+ * @remarks
+ * Avoid using the calculated length of the curve for this purpose, as this may potentially be less precise/consistant.
+ * The `getPointAtDepth` function in this interface is calculated as in the above example when created using the `getTrajectory` function.
+ *
+ * @see {@link getTrajectory}
+ * @see {@link Curve3D}
+ */
+export interface Trajectory {
+    id: string | number;
+    measuredLength: number;
+    measuredTop: number;
+    measuredBottom: number;
+    curve: Curve3D;
+    getPointAtDepth: (md: number, clamped?: boolean) => Vec3 | null;
+    getPositionAtDepth: (md: number, clamped?: boolean) => number | null;
+}
+export type ProjectedTrajectory = {
+    positions: Vec2[];
+    length: number;
+    top: number;
+    bottom: number;
+} | null;
+/**
+ * Creates an instance conforming to the `Trajectory` interface, given an id and a position log normalized to MSL depths.
+ *
+ * @see {@link Trajectory}
+ */
+export declare function getTrajectory(id: string, poslogMsl: PositionLog | null): Trajectory | null;
+/**
+ * Simplifies a linear 2d curve by comparing direction changes to a threshold value.
+ * @param array input array
+ * @param accessor accessor to array coordinate element
+ * @param threshold threshold value (default 1e-7)
+ * @returns T[] array of same type as input array
+ */
+export declare function simplifyCurve2D<T>(array: Array<T>, accessor?: (e: T) => Vec2, threshold?: number): T[];
+/**
+ * Generate a equaly spaced trajectory along XZ plane from a linear 3d curve
+ * where the distance between coordinates corresponds to stepSize.
+ * @param path 3d curve
+ * @param stepSize distance between corrdinates in output trajectory
+ * @param extension optional extension of original path (extrapolation)
+ * @param minSize a minimum size of the output. If less, points will be extrapolated in both ends
+ * @param defaultExtensionAngle if there is not enough deviation in the input path to determine an extrapolation angle, this angle will be used (default: 0 radians)
+ * @returns 2d curve along the XZ plane
+ */
+export declare function getProjectedTrajectory(path: Vec3[], stepSize: number, extension?: number, minSize?: number, defaultExtensionAngle?: number): ProjectedTrajectory;

package/dist/types/sdk/utils/trigonometry.d.ts

@@ -0,0 +1,12 @@
+import { Vec2 } from '../types/common';
+export declare const PI: number;
+export declare const TAU: number;
+export declare const PI2: number;
+export declare const PI4: number;
+export declare const PI8: number;
+/**
+ * Given a 2D rectangle and an angle off the center, find the point
+ * of the closest corner. Used for anchoring connector lines
+ * to annotation labels.
+ */
+export declare function edgeOfRectangle(rect: Vec2, theta: number): Vec2;

package/dist/types/sdk/utils/typed-2d-array.d.ts

@@ -0,0 +1,52 @@
+/**
+ * This class makes it easier to worked with typed arrray used in a 2d grid.
+ * It allow you to read from and write to a flat typed array using columns, rows
+ * and blocks. It alow you to specify the stride per grid cell, so if you need
+ * a grid og RGB colors, you set the stride to 3.
+ *
+ * Another useful feature of this class is that it will use bilinear interpolation
+ * if you reference columns and/or rows with decimal indexes.
+ *
+ * @author Kjerand Pedersen
+ */
+export type TypedArrayArrayType = Float32Array | Uint8Array | Uint16Array | Uint32Array;
+export type TypedArrayOutputArray = TypedArrayArrayType | undefined;
+export type TypedArrayInputArray = number[];
+export type TypedArrayMapFunction = (input: number | TypedArrayArrayType) => number | TypedArrayArrayType;
+export type InterpolationFunction = (a: number, b: number, c: number, d: number, t1: number, t2: number) => number;
+export declare class Typed2DArray {
+    data: TypedArrayArrayType;
+    columns: number;
+    rows: number;
+    stride: number;
+    private _rowLength;
+    private _lerpFn;
+    private arrayConstructor;
+    constructor(data: TypedArrayArrayType, columns: number, stride?: number);
+    static readWriteBlock(source: Typed2DArray, sourceCol: number, sourceRow: number, sourceColumns: number, sourceRows: number, target: Typed2DArray, targetCol: number, targetRow: number, targetColumns: number, targetRows: number, mapFunction?: TypedArrayMapFunction | null): typeof Typed2DArray;
+    static logInterp(a: number, b: number, c: number, d: number, t1: number, t2: number): number;
+    static linearInterp(a: number, b: number, c: number, d: number, t1: number, t2: number): number;
+    static nearestInterp(a: number, b: number, c: number, d: number, t1: number, t2: number): number;
+    get width(): number;
+    get height(): number;
+    index(col: number, row: number): number;
+    positionOf(index: number): {
+        row: number;
+        col: number;
+    } | undefined;
+    setInterpolator(...interpolatorFunction: InterpolationFunction[]): this;
+    getInterpolator(component: number): InterpolationFunction;
+    col(col: number, out: TypedArrayOutputArray): TypedArrayArrayType;
+    row(row: number, out: TypedArrayOutputArray): Float32Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>;
+    setValue(col: number, row: number, ...value: TypedArrayInputArray): this;
+    readBlock(fromCol: number, fromRow: number, columns: number, rows: number, targetColumns?: number, targetRows?: number, out?: TypedArrayOutputArray): TypedArrayArrayType;
+    upscale(newColumns: number, newRows: number): this;
+    writeBlock(fromCol: number, fromRow: number, columns: number, rows: number, values: number[]): this;
+    fillBlock(fromCol: number, fromRow: number, cols: number, rows: number, value: number | ((c: number, r: number, i: number) => number | number[])): this;
+    valueOf(index: number, out?: TypedArrayOutputArray): number | TypedArrayArrayType;
+    valueAt(col: number, row: number, out?: TypedArrayOutputArray): number | TypedArrayArrayType;
+    swapRows(r1: number, r2: number, temp: TypedArrayArrayType): this;
+    invertRows(): this;
+    copyInto(target: TypedArrayArrayType, fromCol?: number, fromRow?: number, columns?: number, rows?: number): this;
+    toJsArray(): any[];
+}

package/dist/types/sdk/utils/typed-array.d.ts

@@ -0,0 +1,2 @@
+import { Vec3 } from '../types/common';
+export declare function toFloat32Array(arrayOfVectors: Vec3[]): Float32Array<ArrayBuffer>;

package/dist/types/sdk/utils/vector-operations.d.ts

@@ -0,0 +1,29 @@
+import { Vec2, Vec3 } from '../types/common';
+export declare function negateVec3(vec: Vec3): Vec3;
+export declare function getVec3(buffer: number[], id: number): Vec3;
+export declare function setVec3(buffer: number[], id: number, value: Vec3): void;
+export declare function addVec3(v1: Vec3, v2: Vec3): Vec3;
+export declare function subVec3(v1: Vec3, v2: Vec3): Vec3;
+export declare function scaleVec3(vec: Vec3, factor: number): Vec3;
+export declare function lengthVec3(vec: Vec3): number;
+export declare function crossVec3(v1: Vec3, v2: Vec3): Vec3;
+export declare function dotVec3(v1: Vec3, v2: Vec3): number;
+export declare function normalizeVec3(v: Vec3): Vec3;
+export declare function mixVec3(v1: Vec3, v2: Vec3, t?: number): Vec3;
+export declare function copyVec3(vec: Vec3): Vec3;
+export declare function angleVec3(v1: Vec3, v2: Vec3): number;
+export declare function rotateVec3(vector: Vec3, axis?: Vec3, angle?: number): Vec3;
+export declare function directionVec3(v1: Vec3, v2: Vec3): Vec3;
+export declare function distanceVec3(v1: Vec3, v2: Vec3): number;
+export declare function getVec2(buffer: number[], id: number): Vec2;
+export declare function setVec2(buffer: number[], id: number, value: Vec2): void;
+export declare function normalizeVec2(v: Vec2): Vec2;
+export declare function addVec2(v1: Vec2, v2: Vec2): Vec2;
+export declare function subVec2(v1: Vec2, v2: Vec2): Vec2;
+export declare function dotVec2(v1: Vec2, v2: Vec2): number;
+export declare function negateVec2(vec: Vec2): Vec2;
+export declare function scaleVec2(vec: Vec2, factor: number): Vec2;
+export declare function lengthVec2(vec: Vec2): number;
+export declare function mixVec2(v1: Vec2, v2: Vec2, t?: number): Vec2;
+export declare function directionVec2(v1: Vec2, v2: Vec2): Vec2;
+export declare function distanceVec2(v1: Vec2, v2: Vec2): number;

package/package.json

@@ -0,0 +1,127 @@
+{
+  "name": "@equinor/videx-3d",
+  "version": "5.1.0-beta",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "description": "React 3D component library designed for sub surface visualizations in the browser",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/equinor/videx-3d.git"
+  },
+  "keywords": [
+    "3d",
+    "React",
+    "threejs",
+    "Subsurface",
+    "visualization"
+  ],
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "npm": "^11.7.0"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/main.js",
+      "types": "./dist/types/main.d.ts"
+    },
+    "./sdk": {
+      "import": "./dist/sdk.js",
+      "types": "./dist/types/sdk/index.d.ts"
+    },
+    "./generators": {
+      "import": "./dist/generators.js",
+      "types": "./dist/types/generators/index.d.ts"
+    }
+  },
+  "scripts": {
+    "start": "npm run storybook",
+    "build": "npm run build-lib && npm run build-static",
+    "build-lib": "tsc && vite build",
+    "build-static": "node scripts/generate-story-args.js && storybook build -o static && typedoc",
+    "lint": "eslint .",
+    "storybook": "node scripts/generate-story-args.js && storybook dev -p 6006",
+    "test": "vitest",
+    "coverage": "vitest --coverage"
+  },
+  "dependencies": {
+    "curve-interpolator": "^3.3.1",
+    "d3-array": "^3.2.4",
+    "d3-axis": "^3.0.0",
+    "d3-drag": "^3.0.0",
+    "d3-format": "^3.1.2",
+    "d3-interpolate": "^3.0.1",
+    "d3-path": "^3.1.0",
+    "d3-scale": "^4.0.2",
+    "d3-selection": "^3.0.0",
+    "lodash.filter": "^4.6.0",
+    "nanoid": "^5.1.2",
+    "p-limit": "^6.2.0",
+    "p-queue": "^8.1.0",
+    "proj4": "^2.20.3",
+    "rbush": "^4.0.1",
+    "react-use-measure": "^2.1.7",
+    "use-zustand": "^0.2.0",
+    "zustand": "^5.0.3"
+  },
+  "devDependencies": {
+    "@chromatic-com/storybook": "^5.0.1",
+    "@eslint/js": "^9.39.3",
+    "@react-three/drei": "^10.7.7",
+    "@react-three/fiber": "^9.5.0",
+    "@storybook/addon-docs": "^10.2.13",
+    "@storybook/react-vite": "^10.2.13",
+    "@types/d3-array": "^3.2.1",
+    "@types/d3-axis": "^3.0.6",
+    "@types/d3-drag": "^3.0.7",
+    "@types/d3-format": "^3.0.4",
+    "@types/d3-interpolate": "^3.0.4",
+    "@types/d3-path": "^3.1.0",
+    "@types/d3-scale": "^4.0.8",
+    "@types/d3-selection": "^3.0.11",
+    "@types/lodash.filter": "^4.6.9",
+    "@types/node": "^22.19.13",
+    "@types/proj4": "^2.5.5",
+    "@types/rbush": "^3.0.3",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.0.4",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "8.56.1",
+    "@vitejs/plugin-react": "^5.1.4",
+    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/ui": "^4.0.18",
+    "eslint": "^9.39.3",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "eslint-plugin-storybook": "^10.2.13",
+    "globals": "^17.4.0",
+    "lodash": "^4.17.23",
+    "minimist": "^1.2.8",
+    "prettier": "^3.8.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "rimraf": "^6.1.3",
+    "sass": "^1.97.3",
+    "storybook": "^10.2.13",
+    "typedoc": "^0.28.17",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.1",
+    "unplugin-dts": "^1.0.0-beta.6",
+    "vite": "^7.3.1",
+    "vite-plugin-css-injected-by-js": "^4.0.1",
+    "vite-plugin-externalize-deps": "^0.10.0",
+    "vite-plugin-glsl": "^1.5.5",
+    "vite-plugin-static-copy": "^3.2.0",
+    "vitest": "^4.0.18"
+  },
+  "peerDependencies": {
+    "@react-three/drei": ">=9",
+    "@react-three/fiber": ">=8",
+    "comlink": ">=4.4",
+    "react": ">=18",
+    "react-dom": ">=18",
+    "three": ">=0.179"
+  }
+}