matterviz 0.4.0 → 0.4.1

package/dist/scene/SceneCamera.svelte

@@ -0,0 +1,62 @@
+<script lang="ts">
+  // Dual perspective/orthographic camera with OrbitControls + axis Gizmo, shared by BrillouinZoneScene, FermiSurfaceScene and StructureScene
+  import type { Vec3 } from '../math'
+  import { type CameraProjection, DEFAULTS } from '../settings'
+  import { T } from '@threlte/core'
+  import * as extras from '@threlte/extras'
+  import type { ComponentProps } from 'svelte'
+  import { build_gizmo_props, build_orbit_props } from './props'
+
+  let {
+    camera_projection = `perspective`,
+    position,
+    fov = DEFAULTS.structure.fov,
+    zoom = DEFAULTS.structure.initial_zoom,
+    near = undefined,
+    far = undefined,
+    orbit_props,
+    gizmo = false,
+    orbit_controls = $bindable(undefined),
+  }: {
+    camera_projection?: CameraProjection
+    position: Vec3 // camera position
+    fov?: number // perspective field of view
+    zoom?: number // orthographic zoom level
+    near?: number // perspective near plane (orthographic always uses -100)
+    far?: number // far plane (applied to either projection when provided)
+    orbit_props: ReturnType<typeof build_orbit_props>
+    gizmo?: boolean | ComponentProps<typeof extras.Gizmo>
+    orbit_controls?: ComponentProps<typeof extras.OrbitControls>[`ref`]
+  } = $props()
+
+  const gizmo_props = $derived(build_gizmo_props(gizmo))
+  // Only pass clipping planes that were explicitly provided so three.js defaults apply otherwise
+  const persp_planes = $derived({
+    ...(near !== undefined && { near }),
+    ...(far !== undefined && { far }),
+  })
+  const ortho_far = $derived(far !== undefined ? { far } : {})
+</script>
+
+{#snippet camera_contents()}
+  <extras.OrbitControls bind:ref={orbit_controls} {...orbit_props}>
+    {#if gizmo}<extras.Gizmo {...gizmo_props} />{/if}
+  </extras.OrbitControls>
+{/snippet}
+
+{#if camera_projection === `perspective`}
+  <T.PerspectiveCamera makeDefault {position} {fov} {...persp_planes}>
+    {@render camera_contents()}
+  </T.PerspectiveCamera>
+{:else}
+  <T.OrthographicCamera makeDefault {position} {zoom} near={-100} {...ortho_far}>
+    {@render camera_contents()}
+  </T.OrthographicCamera>
+{/if}
+
+<style>
+  :global(.responsive-gizmo) {
+    width: clamp(70px, 18cqmin, 100px) !important;
+    height: clamp(70px, 18cqmin, 100px) !important;
+  }
+</style>

package/dist/scene/SceneCamera.svelte.d.ts

@@ -0,0 +1,19 @@
+import type { Vec3 } from '../math';
+import { type CameraProjection } from '../settings';
+import * as extras from '@threlte/extras';
+import type { ComponentProps } from 'svelte';
+import { build_orbit_props } from './props';
+type $$ComponentProps = {
+    camera_projection?: CameraProjection;
+    position: Vec3;
+    fov?: number;
+    zoom?: number;
+    near?: number;
+    far?: number;
+    orbit_props: ReturnType<typeof build_orbit_props>;
+    gizmo?: boolean | ComponentProps<typeof extras.Gizmo>;
+    orbit_controls?: ComponentProps<typeof extras.OrbitControls>[`ref`];
+};
+declare const SceneCamera: import("svelte").Component<$$ComponentProps, {}, "orbit_controls">;
+type SceneCamera = ReturnType<typeof SceneCamera>;
+export default SceneCamera;

package/dist/scene/bind-renderer.svelte.d.ts

@@ -0,0 +1,2 @@
+import type { Camera, Scene, WebGLRenderer } from 'three';
+export declare function bind_renderer(on_bind: (scene: Scene, camera: Camera) => void, on_renderer?: (renderer: WebGLRenderer) => void): import("@threlte/core").ThrelteContext<WebGLRenderer>;

package/dist/scene/bind-renderer.svelte.js

@@ -0,0 +1,14 @@
+import { renderer_registry } from '../io/export';
+import { useThrelte } from '@threlte/core';
+// Mirror the Threlte scene + active camera into bindable props (for export panes etc.) and register the canvas->renderer mapping so PNG-export helpers can find it. Creates an $effect (call during component init). Returns the Threlte context for further use (e.g. clipping planes).
+export function bind_renderer(on_bind, on_renderer) {
+    const threlte = useThrelte();
+    $effect(() => {
+        on_bind(threlte.scene, threlte.camera.current);
+        if (threlte.renderer) {
+            on_renderer?.(threlte.renderer);
+            renderer_registry.set(threlte.renderer.domElement, threlte.renderer);
+        }
+    });
+    return threlte;
+}

package/dist/scene/index.d.ts

@@ -0,0 +1,4 @@
+export * from './bind-renderer.svelte';
+export * from './props';
+export { default as SceneCamera } from './SceneCamera.svelte';
+export type * from './types';

package/dist/scene/index.js

@@ -0,0 +1,5 @@
+// Shared Three.js/Threlte scene boilerplate (cameras, orbit controls, gizmo,
+// renderer binding) used by BrillouinZoneScene, FermiSurfaceScene and StructureScene.
+export * from './bind-renderer.svelte';
+export * from './props';
+export { default as SceneCamera } from './SceneCamera.svelte';

package/dist/scene/props.js

@@ -0,0 +1,52 @@
+import { AXIS_COLORS, NEG_AXIS_COLORS } from '../colors';
+// ScatterPlot3DScene keeps its own gizmo/orbit props on purpose: its gizmo offset is
+// ColorBar-aware (build_gizmo_props' fixed offset would clobber it) and its orbit controls
+// differ by design (no zoom-to-cursor / ortho zoom-doubling / camera-moving tracking).
+// Shared Gizmo config: colored +/- axis handles, transparent background, responsive sizing. An object `gizmo` overrides the per-axis defaults.
+export function build_gizmo_props(gizmo) {
+    return {
+        background: { enabled: false },
+        className: `responsive-gizmo`,
+        ...Object.fromEntries([...AXIS_COLORS, ...NEG_AXIS_COLORS].map(([axis, color, hover]) => [
+            axis,
+            {
+                color,
+                labelColor: `#111`,
+                opacity: axis.startsWith(`n`) ? 0.9 : 0.8,
+                hover: {
+                    color: hover,
+                    labelColor: `#222`,
+                    opacity: axis.startsWith(`n`) ? 1 : 0.9,
+                },
+            },
+        ])),
+        ...(typeof gizmo === `object` ? gizmo : {}),
+        offset: { left: 5, bottom: 5 },
+    };
+}
+// Shared OrbitControls config; `onstart_extra` runs extra cleanup when the camera starts moving (e.g. StructureScene closes hover tooltips/context menus)
+export function build_orbit_props(opts) {
+    const is_ortho = opts.camera_projection === `orthographic`;
+    return {
+        position: [0, 0, 0],
+        target: opts.target,
+        enableRotate: opts.rotate_speed > 0,
+        rotateSpeed: opts.rotate_speed,
+        enableZoom: opts.zoom_speed > 0,
+        zoomSpeed: is_ortho ? opts.zoom_speed * 2 : opts.zoom_speed,
+        zoomToCursor: opts.zoom_to_cursor,
+        enablePan: opts.pan_speed > 0,
+        panSpeed: opts.pan_speed,
+        maxZoom: opts.max_zoom,
+        minZoom: opts.min_zoom,
+        autoRotate: Boolean(opts.auto_rotate),
+        autoRotateSpeed: opts.auto_rotate,
+        enableDamping: Boolean(opts.rotation_damping),
+        dampingFactor: opts.rotation_damping,
+        onstart: () => {
+            opts.set_camera_is_moving?.(true);
+            opts.onstart_extra?.();
+        },
+        onend: () => opts.set_camera_is_moving?.(false),
+    };
+}

package/dist/scene/types.d.ts

@@ -0,0 +1,26 @@
+import type { CameraProjection } from '../settings';
+import type { Gizmo } from '@threlte/extras';
+import type { ComponentProps } from 'svelte';
+import type { Camera, Scene, Vector3 } from 'three';
+export type ThreltePointerEvent = {
+    point: Vector3;
+    nativeEvent: PointerEvent;
+};
+export type SceneControlProps = {
+    camera_projection?: CameraProjection;
+    rotation_damping?: number;
+    max_zoom?: number;
+    min_zoom?: number;
+    rotate_speed?: number;
+    zoom_speed?: number;
+    pan_speed?: number;
+    zoom_to_cursor?: boolean;
+    fov?: number;
+    initial_zoom?: number;
+    ambient_light?: number;
+    directional_light?: number;
+    gizmo?: boolean | ComponentProps<typeof Gizmo>;
+    auto_rotate?: number;
+    scene?: Scene;
+    camera?: Camera;
+};

package/dist/scene/types.js

@@ -0,0 +1 @@
+export {};

package/dist/settings.d.ts

@@ -1,9 +1,10 @@
 import type { ColorScaleType, D3InterpolateName } from './colors';
 import type { HullFaceColorMode } from './convex-hull/types';
 import type { D3SymbolName } from './labels';
-import type { Vec3 } from './math';
+import type { Vec2, Vec3 } from './math';
 import type { BandwidthOption, Orientation, SankeyNodeAlign, SankeyOrientation, SunburstLabelRotation, SunburstLabelText, SunburstShape, SunburstValueMode, ViolinKind, ViolinSide, WhiskerMode } from './plot';
 import type { BondingStrategy } from './structure/bonding';
+import type { PolyhedraColorMode } from './structure/polyhedra';
 export interface SettingType<T = unknown> {
     value: T;
     description: string;
@@ -130,6 +131,17 @@ export interface SettingsConfig {
         show_bonds: SettingType<ShowBonds>;
         bond_color: SettingType<string>;
         bonding_strategy: SettingType<BondingStrategy>;
+        show_polyhedra: SettingType<ShowBonds>;
+        polyhedra_opacity: SettingType<number>;
+        polyhedra_show_edges: SettingType<boolean>;
+        polyhedra_edge_color: SettingType<string>;
+        polyhedra_color_mode: SettingType<PolyhedraColorMode>;
+        polyhedra_color: SettingType<string>;
+        polyhedra_hide_center_atoms: SettingType<boolean>;
+        polyhedra_min_neighbors: SettingType<number>;
+        polyhedra_max_neighbors: SettingType<number>;
+        polyhedra_excluded_elements: SettingType<readonly string[]>;
+        polyhedra_included_elements: SettingType<readonly string[]>;
         atom_color_mode: SettingType<AtomColorMode>;
         atom_color_scale: SettingType<D3InterpolateName>;
         atom_color_scale_type: SettingType<ColorScaleType>;
@@ -179,7 +191,7 @@ export interface SettingsConfig {
     trajectory: {
         auto_play: SettingType<boolean>;
         fps: SettingType<number>;
-        fps_range: SettingType<[number, number]>;
+        fps_range: SettingType<Vec2>;
         display_mode: SettingType<`structure+scatter` | `structure` | `scatter` | `histogram` | `structure+histogram`>;
         show_controls: SettingType<boolean>;
         fullscreen_toggle: SettingType<boolean>;

package/dist/settings.js

@@ -3,6 +3,8 @@
 import { symbol_names } from './labels';
 import { merge_nested } from './utils';
 export const SHOW_BONDS_OPTIONS = [`never`, `always`, `crystals`, `molecules`];
+// Shared enum labels for never|always|crystals|molecules settings (bonds, polyhedra)
+const SHOW_BONDS_ENUM = Object.fromEntries(SHOW_BONDS_OPTIONS.map((key) => [key, key[0].toUpperCase() + key.slice(1)]));
 export const VECTOR_COLOR_MODES = [
     `auto`,
     `element`,
@@ -122,7 +124,7 @@ export const SETTINGS_CONFIG = {
         show_bonds: {
             value: `always`,
             description: `When to display bonds between atoms`,
-            enum: Object.fromEntries(SHOW_BONDS_OPTIONS.map((key) => [key, key[0].toUpperCase() + key.slice(1)])),
+            enum: SHOW_BONDS_ENUM,
         },
         bond_color: {
             value: `#666666`,
@@ -136,6 +138,62 @@ export const SETTINGS_CONFIG = {
                 solid_angle: `Solid Angle`,
             },
         },
+        show_polyhedra: {
+            value: `crystals`,
+            description: `When to render coordination polyhedra around cation-like centers`,
+            enum: SHOW_BONDS_ENUM,
+        },
+        polyhedra_opacity: {
+            value: 0.2,
+            description: `Opacity of coordination polyhedra faces`,
+            minimum: 0,
+            maximum: 1,
+        },
+        polyhedra_show_edges: {
+            value: true,
+            description: `Draw outlines along coordination polyhedra edges`,
+        },
+        polyhedra_edge_color: {
+            value: `#222222`,
+            description: `Color of coordination polyhedra edge lines`,
+        },
+        polyhedra_color_mode: {
+            value: `vertex`,
+            description: `Color polyhedra by the atoms at their corners, the center atom, or a single custom color`,
+            enum: {
+                vertex: `Vertex Atoms`,
+                center: `Center Atom`,
+                uniform: `Custom Color`,
+            },
+        },
+        polyhedra_color: {
+            value: `#4a90d9`,
+            description: `Custom polyhedra color (used when color mode is Custom Color)`,
+        },
+        polyhedra_hide_center_atoms: {
+            value: false,
+            description: `Hide the central atom of each rendered polyhedron`,
+        },
+        polyhedra_min_neighbors: {
+            value: 4,
+            description: `Minimum number of bonded neighbors (coordination number) to form a polyhedron`,
+            minimum: 4, // hulls of <4 points are degenerate and render nothing
+            maximum: 12,
+        },
+        polyhedra_max_neighbors: {
+            value: 8,
+            description: `Maximum number of bonded neighbors for a polyhedron (skips e.g. CN-12 cuboctahedra around large A-site cations)`,
+            minimum: 4,
+            maximum: 16,
+        },
+        polyhedra_excluded_elements: {
+            value: [],
+            description: `Elements excluded from acting as polyhedra centers`,
+        },
+        polyhedra_included_elements: {
+            value: [],
+            description: `Elements always allowed as polyhedra centers (overrides automatic hiding of spectator cations like alkali metals and the max neighbors cap)`,
+        },
         atom_color_mode: {
             value: `element`,
             description: `Property to use for atom coloring`,

package/dist/spectral/Bands.svelte

@@ -3,6 +3,7 @@
   import EmptyState from '../EmptyState.svelte'
   import { format_num } from '../labels'
   import { sanitize_html } from '../sanitize'
+  import { is_plain_object } from '../utils'
   import { SettingsSection } from '../layout'
   import type { Vec2 } from '../math'
   import ScatterPlot from '../plot/scatter/ScatterPlot.svelte'
@@ -56,7 +57,7 @@
     path_mode?: PathMode
     band_type?: BandStructureType
     show_legend?: boolean
-    x_positions?: Record<string, [number, number]>
+    x_positions?: Record<string, Vec2>
     reference_frequency?: number | null
     // Q-point index to highlight with a vertical line (synced from BZ k-path hover)
     highlighted_qpoint_index?: number | null
@@ -104,12 +105,12 @@
       }
     }
 
-    if (typeof line_kwargs === `object` && line_kwargs !== null) {
+    if (is_plain_object(line_kwargs)) {
       const mode_key = is_acoustic ? `acoustic` : `optical`
-      const mode_kwargs = (line_kwargs as Record<string, unknown>)[mode_key] as
-        | Record<string, unknown>
-        | undefined
-      const source = (mode_kwargs ?? line_kwargs) as Record<string, unknown>
+      const mode_kwargs = line_kwargs[mode_key]
+      const source: Record<string, unknown> = is_plain_object(mode_kwargs)
+        ? mode_kwargs
+        : line_kwargs
       return {
         stroke: (source.stroke as string) ?? defaults.stroke,
         stroke_width: (source.stroke_width as number) ?? defaults.stroke_width,
@@ -287,7 +288,7 @@
       x_positions = {}
       return
     }
-    const positions: Record<string, [number, number]> = {}
+    const positions: Record<string, Vec2> = {}
     let current_x = 0
 
     // Preserve physical path order using the first available structure

package/dist/spectral/Bands.svelte.d.ts

@@ -1,3 +1,4 @@
+import type { Vec2 } from '../math';
 import ScatterPlot from '../plot/scatter/ScatterPlot.svelte';
 import type { AxisConfig } from '../plot/core/types';
 import type { BandsSpinMode, BandStructureType, BaseBandStructure, FrequencyUnit, LineKwargs, PathMode, RibbonConfig } from './types';
@@ -10,7 +11,7 @@ type $$ComponentProps = ComponentProps<typeof ScatterPlot> & {
     path_mode?: PathMode;
     band_type?: BandStructureType;
     show_legend?: boolean;
-    x_positions?: Record<string, [number, number]>;
+    x_positions?: Record<string, Vec2>;
     reference_frequency?: number | null;
     highlighted_qpoint_index?: number | null;
     ribbon_config?: RibbonConfig | Record<string, RibbonConfig>;
@@ -34,6 +35,6 @@ type $$ComponentProps = ComponentProps<typeof ScatterPlot> & {
     id?: string;
     'data-testid'?: string;
 };
-declare const Bands: import("svelte").Component<$$ComponentProps, {}, "y_axis" | "units" | "x_positions" | "band_spin_mode">;
+declare const Bands: import("svelte").Component<$$ComponentProps, {}, "y_axis" | "x_positions" | "units" | "band_spin_mode">;
 type Bands = ReturnType<typeof Bands>;
 export default Bands;

package/dist/spectral/BandsAndDos.svelte

@@ -74,31 +74,29 @@
     if (result !== undefined) synced_zoom_range = result
   })
 
-  // Propagate synced range to bands y-axis (untrack current to avoid overwriting child zoom)
-  $effect(() => {
-    const base_range = synced_zoom_range ?? shared_frequency_range
-    const current_range = untrack(() => bands_y_axis.range) as Vec2 | undefined
-    // Skip if current range already matches base, or is valid but differs (child zoom in progress)
-    if (ranges_equal(current_range, base_range)) return
-    if (is_valid_range(current_range) && !ranges_equal(current_range, base_range)) {
-      return
-    }
-    // Only include range if it's valid (don't override child's auto-range with undefined)
-    bands_y_axis = bands_default_axis(base_range)
-  })
-
-  // Propagate synced range to DOS y-axis (untrack current to avoid overwriting child zoom)
-  $effect(() => {
+  // Propagate the synced range to a child y-axis (untrack current to avoid overwriting
+  // child zoom). Skips when the current range already matches base, or is valid but
+  // differs (child zoom in progress).
+  const propagate_synced_range = (
+    current_range: Vec2 | undefined,
+    apply: (base_range: Vec2 | undefined) => void,
+  ) => {
     const base_range = synced_zoom_range ?? shared_frequency_range
-    const current_range = untrack(() => dos_y_axis.range) as Vec2 | undefined
-    // Skip if current range already matches base, or is valid but differs (child zoom in progress)
-    if (ranges_equal(current_range, base_range)) return
-    if (is_valid_range(current_range) && !ranges_equal(current_range, base_range)) {
-      return
-    }
-    // Only include range if it's valid (don't override child's auto-range with undefined)
-    dos_y_axis = dos_default_axis(base_range)
-  })
+    if (ranges_equal(current_range, base_range) || is_valid_range(current_range)) return
+    apply(base_range)
+  }
+  $effect(() =>
+    propagate_synced_range(
+      untrack(() => bands_y_axis.range) as Vec2 | undefined,
+      (base_range) => bands_y_axis = bands_default_axis(base_range),
+    )
+  )
+  $effect(() =>
+    propagate_synced_range(
+      untrack(() => dos_y_axis.range) as Vec2 | undefined,
+      (base_range) => dos_y_axis = dos_default_axis(base_range),
+    )
+  )
 
   let hovered_frequency = $state<number | null>(null)
 

package/dist/spectral/BrillouinBandsDos.svelte

@@ -73,7 +73,7 @@
   })
 
   let hovered_band_point = $state<InternalPoint | null>(null)
-  let bands_x_positions = $state<Record<string, [number, number]>>({})
+  let bands_x_positions = $state<Record<string, Vec2>>({})
   let hovered_qpoint_index = $derived(
     hovered_band_point && first_band_struct &&
       Object.keys(bands_x_positions).length > 0
@@ -199,11 +199,11 @@
     style="grid-area: bz; min-width: 0; min-height: 0; overflow: hidden; height: 100%"
     {structure}
     {k_path_points}
-    k_path_labels={first_band_struct?.qpoints?.flatMap((q, idx) =>
+    k_path_labels={first_band_struct?.qpoints?.flatMap((qpoint, idx) =>
       k_path_points[idx]
         ? [{
           position: k_path_points[idx],
-          label: q.label ? helpers.pretty_sym_point(q.label) : null,
+          label: qpoint.label ? helpers.pretty_sym_point(qpoint.label) : null,
         }]
         : []
     ) ?? []}

package/dist/spectral/Dos.svelte

@@ -2,6 +2,7 @@
   import { PLOT_COLORS } from '../colors'
   import EmptyState from '../EmptyState.svelte'
   import { SettingsSection } from '../layout'
+  import type { Vec2 } from '../math'
   import ScatterPlot from '../plot/scatter/ScatterPlot.svelte'
   import type { AxisConfig, DataSeries } from '../plot/core/types'
   import type { ComponentProps } from 'svelte'
@@ -78,7 +79,7 @@
     show_sigma_control?: boolean // Show sigma/smearing control
     show_normalize_control?: boolean // Show normalization selector
     show_units_control?: boolean // Show units selector (phonon DOS only)
-    sigma_range?: [number, number] // Min/max range for sigma slider (auto-detected if not provided)
+    sigma_range?: Vec2 // Min/max range for sigma slider (auto-detected if not provided)
   } = $props()
 
   const is_horizontal = $derived(orientation === `horizontal`)
@@ -307,7 +308,7 @@
     effective_spin_mode === `mirror` && has_spin_polarized,
   )
 
-  let x_range = $derived.by((): [number, number] | undefined => {
+  let x_range = $derived.by((): Vec2 | undefined => {
     if (series_data.length === 0) return undefined
     const all_x = series_data.flatMap((srs) => srs.x)
     const min_x = Math.min(...all_x), max_x = Math.max(...all_x)
@@ -317,7 +318,7 @@
     return [min_x, max_x]
   })
 
-  let y_range = $derived.by((): [number, number] | undefined => {
+  let y_range = $derived.by((): Vec2 | undefined => {
     if (series_data.length === 0) return undefined
     const all_y = series_data.flatMap((srs) => srs.y)
     const min_y = Math.min(...all_y), max_y = Math.max(...all_y)
@@ -377,7 +378,7 @@
   let has_valid_data = $derived(series_data.length > 0)
 
   // Auto-detect sigma range based on frequency/energy range
-  let effective_sigma_range = $derived.by((): [number, number] => {
+  let effective_sigma_range = $derived.by((): Vec2 => {
     if (sigma_range) return sigma_range
     if (all_freqs.length === 0) return [0, 1]
     const freq_range = Math.max(...all_freqs) - Math.min(...all_freqs)

package/dist/spectral/Dos.svelte.d.ts

@@ -1,3 +1,4 @@
+import type { Vec2 } from '../math';
 import ScatterPlot from '../plot/scatter/ScatterPlot.svelte';
 import type { AxisConfig } from '../plot/core/types';
 import type { ComponentProps } from 'svelte';
@@ -22,7 +23,7 @@ type $$ComponentProps = ComponentProps<typeof ScatterPlot> & {
     show_sigma_control?: boolean;
     show_normalize_control?: boolean;
     show_units_control?: boolean;
-    sigma_range?: [number, number];
+    sigma_range?: Vec2;
 };
 declare const Dos: import("svelte").Component<$$ComponentProps, {}, "normalize" | "y_axis" | "units" | "sigma" | "hovered_frequency" | "spin_mode">;
 type Dos = ReturnType<typeof Dos>;

package/dist/spectral/helpers.d.ts

@@ -22,7 +22,7 @@ export declare function extract_spin_channels<T>(data: unknown): {
     up: T;
     down: T | null;
 } | null;
-export declare function normalize_band_structure(bs: unknown): types.BaseBandStructure | null;
+export declare function normalize_band_structure(band_struct: unknown): types.BaseBandStructure | null;
 export declare function normalize_dos(dos: unknown, options?: {
     auto_convert_units?: boolean;
 }): types.DosData | null;
@@ -30,8 +30,8 @@ export declare function extract_k_path_points(band_struct: types.BaseBandStructu
     wrap_to_bz?: boolean;
 }): Vec3[];
 export declare function find_qpoint_at_distance(band_struct: types.BaseBandStructure, target: number): number | null;
-export declare function qpoint_x_position(band_struct: types.BaseBandStructure, qpoint_index: number, x_positions: Record<string, [number, number]>): number | null;
-export declare function find_qpoint_at_rescaled_x(band_struct: types.BaseBandStructure, rescaled_x: number, x_positions: Record<string, [number, number]>): number | null;
+export declare function qpoint_x_position(band_struct: types.BaseBandStructure, qpoint_index: number, x_positions: Record<string, Vec2>): number | null;
+export declare function find_qpoint_at_rescaled_x(band_struct: types.BaseBandStructure, rescaled_x: number, x_positions: Record<string, Vec2>): number | null;
 type SpinDensities = Record<string, number[]>;
 export interface PymatgenDos {
     '@class': string;
@@ -52,7 +52,7 @@ export declare function shift_to_fermi(dos: PymatgenCompleteDos): PymatgenComple
 export declare function generate_ribbon_path(x_values: number[], y_values: number[], width_values: number[], x_scale_fn: (x: number) => number, y_scale_fn: (y: number) => number, max_width_px: number, scale?: number): string;
 export declare function extract_efermi(data: unknown): number | undefined;
 export declare function negative_fraction(values: number[]): number;
-export declare function compute_frequency_range(band_structs: unknown, doses: unknown, padding_factor?: number): [number, number] | undefined;
+export declare function compute_frequency_range(band_structs: unknown, doses: unknown, padding_factor?: number): Vec2 | undefined;
 export declare function format_dos_tooltip(x_formatted: string, y_formatted: string, label: string | null, is_horizontal: boolean, is_phonon: boolean, units: types.FrequencyUnit, x_axis_label: string, y_axis_label: string, num_series: number): {
     title?: string;
     lines: string[];
@@ -93,8 +93,8 @@ export declare const DEFAULT_SIGMA = 0;
 export declare const DEFAULT_NORMALIZE: types.NormalizationMode;
 export declare const DEFAULT_UNITS: types.FrequencyUnit;
 export declare function format_sigma(val: number): string;
-export declare const validate_sigma_range: ([min, max]: [number, number]) => [number, number];
-export declare function calculate_sigma_step(range: [number, number]): number;
+export declare const validate_sigma_range: ([min, max]: Vec2) => Vec2;
+export declare function calculate_sigma_step(range: Vec2): number;
 export interface BandPointMeta extends Record<string, unknown> {
     band_idx: number;
     spin: `up` | `down`;