matterviz 0.3.2 → 0.3.4

package/dist/isosurface/Isosurface.svelte

@@ -1,178 +1,232 @@
-<script lang="ts">// Threlte component that renders isosurface meshes from volumetric data using marching cubes.
-// Supports multiple layers at different isovalues with independent colors,
-// plus positive/negative lobes and two-pass transparency.
-import { marching_cubes } from '../marching-cubes';
-import { T } from '@threlte/core';
-import { BackSide, BufferAttribute, BufferGeometry, DoubleSide, FrontSide, Uint32BufferAttribute, } from 'three';
-import { DEFAULT_ISOSURFACE_SETTINGS, downsample_grid, pad_periodic_grid, } from './types';
-let { volume, settings = DEFAULT_ISOSURFACE_SETTINGS, } = $props();
-// Resolve layers: use explicit layers array if provided, else build from single-isovalue settings
-let resolved_layers = $derived.by(() => {
-    if (settings.layers?.length)
-        return settings.layers;
+<script lang="ts">
+  // Threlte component that renders isosurface meshes from volumetric data using marching cubes.
+  // Supports multiple layers at different isovalues with independent colors,
+  // plus positive/negative lobes and two-pass transparency.
+  import { marching_cubes } from '../marching-cubes'
+  import type { Matrix3x3, Vec3 } from '../math'
+  import { T } from '@threlte/core'
+  import {
+    BackSide,
+    BufferAttribute,
+    BufferGeometry,
+    DoubleSide,
+    FrontSide,
+    Uint32BufferAttribute,
+  } from 'three'
+  import type { IsosurfaceLayer, IsosurfaceSettings, VolumetricData } from './types'
+  import {
+    DEFAULT_ISOSURFACE_SETTINGS,
+    downsample_grid,
+    pad_periodic_grid,
+  } from './types'
+
+  let { volume, settings = DEFAULT_ISOSURFACE_SETTINGS }: {
+    volume: VolumetricData
+    settings?: IsosurfaceSettings
+  } = $props()
+
+  // Resolve layers: use explicit layers array if provided, else build from single-isovalue settings
+  let resolved_layers = $derived.by((): IsosurfaceLayer[] => {
+    if (settings.layers?.length) return settings.layers
     return [{
-            isovalue: settings.isovalue,
-            color: settings.positive_color,
-            opacity: settings.opacity,
-            visible: true,
-            show_negative: settings.show_negative,
-            negative_color: settings.negative_color,
-        }];
-});
-// Build indexed BufferGeometry from marching cubes output.
-// Uses Three.js index buffer to avoid tripling vertex data, and
-// computeVertexNormals() for fast GPU-friendly normals.
-function build_geometry(vertices, faces) {
-    if (vertices.length === 0 || faces.length === 0)
-        return null;
+      isovalue: settings.isovalue,
+      color: settings.positive_color,
+      opacity: settings.opacity,
+      visible: true,
+      show_negative: settings.show_negative,
+      negative_color: settings.negative_color,
+    }]
+  })
+
+  // Build indexed BufferGeometry from marching cubes output.
+  // Uses Three.js index buffer to avoid tripling vertex data, and
+  // computeVertexNormals() for fast GPU-friendly normals.
+  function build_geometry(
+    vertices: Vec3[],
+    faces: number[][],
+  ): BufferGeometry | null {
+    if (vertices.length === 0 || faces.length === 0) return null
+
     // Flatten vertices: Vec3[] → Float32Array
-    const positions = new Float32Array(vertices.length * 3);
+    const positions = new Float32Array(vertices.length * 3)
     for (let idx = 0; idx < vertices.length; idx++) {
-        const vert = vertices[idx];
-        positions[idx * 3] = vert[0];
-        positions[idx * 3 + 1] = vert[1];
-        positions[idx * 3 + 2] = vert[2];
+      const vert = vertices[idx]
+      positions[idx * 3] = vert[0]
+      positions[idx * 3 + 1] = vert[1]
+      positions[idx * 3 + 2] = vert[2]
     }
+
     // Flatten face indices: number[][] → Uint32Array
-    const indices = new Uint32Array(faces.length * 3);
+    const indices = new Uint32Array(faces.length * 3)
     for (let idx = 0; idx < faces.length; idx++) {
-        const face = faces[idx];
-        indices[idx * 3] = face[0];
-        indices[idx * 3 + 1] = face[1];
-        indices[idx * 3 + 2] = face[2];
+      const face = faces[idx]
+      indices[idx * 3] = face[0]
+      indices[idx * 3 + 1] = face[1]
+      indices[idx * 3 + 2] = face[2]
     }
-    const geometry = new BufferGeometry();
-    geometry.setAttribute(`position`, new BufferAttribute(positions, 3));
-    geometry.setIndex(new Uint32BufferAttribute(indices, 1));
-    geometry.computeVertexNormals();
-    geometry.computeBoundingSphere();
-    return geometry;
-}
-// Downsample large grids once when volume changes to keep marching cubes interactive
-let ds_result = $derived.by(() => {
-    if (!volume)
-        return undefined;
-    return downsample_grid(volume.grid, volume.grid_dims);
-});
-// Run marching cubes at the given isovalue with pre-prepared grid/lattice/shift.
-function extract_surface(isovalue, mc_grid, mc_lattice, origin_shift) {
-    if (isovalue === 0)
-        return null;
+
+    const geometry = new BufferGeometry()
+    geometry.setAttribute(`position`, new BufferAttribute(positions, 3))
+    geometry.setIndex(new Uint32BufferAttribute(indices, 1))
+    geometry.computeVertexNormals()
+    geometry.computeBoundingSphere()
+    return geometry
+  }
+
+  // Downsample large grids once when volume changes to keep marching cubes interactive
+  let ds_result = $derived.by(() => {
+    if (!volume) return undefined
+    return downsample_grid(volume.grid, volume.grid_dims)
+  })
+
+  // Run marching cubes at the given isovalue with pre-prepared grid/lattice/shift.
+  function extract_surface(
+    isovalue: number,
+    mc_grid: number[][][],
+    mc_lattice: Matrix3x3,
+    origin_shift: Vec3 | null,
+  ): BufferGeometry | null {
+    if (isovalue === 0) return null
+
     const result = marching_cubes(mc_grid, isovalue, mc_lattice, {
-        periodic: false,
-        interpolate: true,
-        centered: false,
-        normals: false,
-    });
+      periodic: false,
+      interpolate: true,
+      centered: false,
+      normals: false,
+    })
+
     if (origin_shift) {
-        for (const vert of result.vertices) {
-            vert[0] += origin_shift[0];
-            vert[1] += origin_shift[1];
-            vert[2] += origin_shift[2];
-        }
+      for (const vert of result.vertices) {
+        vert[0] += origin_shift[0]
+        vert[1] += origin_shift[1]
+        vert[2] += origin_shift[2]
+      }
     }
-    return build_geometry(result.vertices, result.faces);
-}
-let active_geometries = $state([]);
-let raf_id = 0;
-let debounce_id = 0;
-// Dispose all current geometries
-function dispose_all() {
-    for (const entry of active_geometries)
-        entry.geometry.dispose();
-    active_geometries = [];
-}
-// Dispose on unmount
-$effect(() => () => dispose_all());
-function rebuild_geometries(layers) {
-    if (!volume || !ds_result)
-        return;
-    const old = active_geometries;
-    const entries = [];
+
+    return build_geometry(result.vertices, result.faces)
+  }
+
+  // === Multi-layer geometry management ===
+  // Each layer produces up to 2 geometries (positive + optional negative lobe).
+  // Keyed by "layer_idx:sign" for cache invalidation.
+  type GeoEntry = {
+    geometry: BufferGeometry
+    color: string
+    opacity: number
+    render_order: number
+  }
+  let active_geometries = $state<GeoEntry[]>([])
+  let raf_id = 0
+  let debounce_id = 0
+
+  // Dispose all current geometries
+  function dispose_all() {
+    for (const entry of active_geometries) entry.geometry.dispose()
+    active_geometries = []
+  }
+
+  // Dispose on unmount
+  $effect(() => () => dispose_all())
+
+  function rebuild_geometries(layers: IsosurfaceLayer[]) {
+    if (!volume || !ds_result) return
+    const old = active_geometries
+    const entries: GeoEntry[] = []
+
     // Prepare grid/lattice/shift once for all layers.
     // When halo > 0 for periodic volumes, the downsampled grid is padded with
     // halo cells from the opposite face so isosurfaces extend beyond the unit
     // cell and close into complete enclosed shapes around boundary atoms.
-    let mc_grid = ds_result.grid;
-    let mc_lattice = volume.lattice;
-    let origin_shift = null;
+    let mc_grid = ds_result.grid
+    let mc_lattice: Matrix3x3 = volume.lattice
+    let origin_shift: Vec3 | null = null
+
     if (settings.halo > 0 && volume.periodic) {
-        const padded = pad_periodic_grid(ds_result.grid, ds_result.dims, settings.halo);
-        mc_grid = padded.grid;
-        // marching_cubes maps [0,1] fractional -> Cartesian via lattice.
-        // The padded grid covers a wider fractional range, so scale the lattice
-        // to match. Then shift all vertices by the fractional offset.
-        const [la, lb, lc] = volume.lattice;
-        const sx = padded.dims[0] / ds_result.dims[0];
-        const sy = padded.dims[1] / ds_result.dims[1];
-        const sz = padded.dims[2] / ds_result.dims[2];
-        mc_lattice = [
-            [la[0] * sx, la[1] * sx, la[2] * sx],
-            [lb[0] * sy, lb[1] * sy, lb[2] * sy],
-            [lc[0] * sz, lc[1] * sz, lc[2] * sz],
-        ];
-        const [ox, oy, oz] = padded.offset;
-        origin_shift = [
-            ox * la[0] + oy * lb[0] + oz * lc[0],
-            ox * la[1] + oy * lb[1] + oz * lc[1],
-            ox * la[2] + oy * lb[2] + oz * lc[2],
-        ];
+      const padded = pad_periodic_grid(ds_result.grid, ds_result.dims, settings.halo)
+      mc_grid = padded.grid
+      // marching_cubes maps [0,1] fractional -> Cartesian via lattice.
+      // The padded grid covers a wider fractional range, so scale the lattice
+      // to match. Then shift all vertices by the fractional offset.
+      const [la, lb, lc] = volume.lattice
+      const sx = padded.dims[0] / ds_result.dims[0]
+      const sy = padded.dims[1] / ds_result.dims[1]
+      const sz = padded.dims[2] / ds_result.dims[2]
+      mc_lattice = [
+        [la[0] * sx, la[1] * sx, la[2] * sx],
+        [lb[0] * sy, lb[1] * sy, lb[2] * sy],
+        [lc[0] * sz, lc[1] * sz, lc[2] * sz],
+      ]
+      const [ox, oy, oz] = padded.offset
+      origin_shift = [
+        ox * la[0] + oy * lb[0] + oz * lc[0],
+        ox * la[1] + oy * lb[1] + oz * lc[1],
+        ox * la[2] + oy * lb[2] + oz * lc[2],
+      ]
     }
-    const surface_at = (isovalue) => extract_surface(isovalue, mc_grid, mc_lattice, origin_shift);
+
+    const surface_at = (isovalue: number) =>
+      extract_surface(isovalue, mc_grid, mc_lattice, origin_shift)
+
     // Render lower-isovalue (outer) shells earlier so per-layer back/front passes
     // interleave back-to-front across shells and reduce transparency artefacts.
-    const layer_render_rank = new Map(layers
+    const layer_render_rank = new Map<number, number>(
+      layers
         .map((layer, layer_idx) => ({ layer_idx, isovalue: layer.isovalue }))
         .sort((layer_a, layer_b) => layer_a.isovalue - layer_b.isovalue)
-        .map(({ layer_idx }, rank) => [layer_idx, rank]));
+        .map(({ layer_idx }, rank) => [layer_idx, rank]),
+    )
+
     for (let layer_idx = 0; layer_idx < layers.length; layer_idx++) {
-        const layer = layers[layer_idx];
-        if (!layer.visible || layer.isovalue <= 0)
-            continue;
-        // Each layer gets 4 slots (positive back/front + negative back/front).
-        const base_order = (layer_render_rank.get(layer_idx) ?? layer_idx) * 4;
-        const pos_geo = surface_at(layer.isovalue);
-        if (pos_geo) {
-            entries.push({
-                geometry: pos_geo,
-                color: layer.color,
-                opacity: layer.opacity,
-                render_order: base_order,
-            });
-        }
-        if (layer.show_negative) {
-            const neg_geo = surface_at(-layer.isovalue);
-            if (neg_geo) {
-                entries.push({
-                    geometry: neg_geo,
-                    color: layer.negative_color,
-                    opacity: layer.opacity,
-                    render_order: base_order + 2,
-                });
-            }
+      const layer = layers[layer_idx]
+      if (!layer.visible || layer.isovalue <= 0) continue
+
+      // Each layer gets 4 slots (positive back/front + negative back/front).
+      const base_order = (layer_render_rank.get(layer_idx) ?? layer_idx) * 4
+
+      const pos_geo = surface_at(layer.isovalue)
+      if (pos_geo) {
+        entries.push({
+          geometry: pos_geo,
+          color: layer.color,
+          opacity: layer.opacity,
+          render_order: base_order,
+        })
+      }
+
+      if (layer.show_negative) {
+        const neg_geo = surface_at(-layer.isovalue)
+        if (neg_geo) {
+          entries.push({
+            geometry: neg_geo,
+            color: layer.negative_color,
+            opacity: layer.opacity,
+            render_order: base_order + 2,
+          })
         }
+      }
     }
-    active_geometries = entries;
-    for (const entry of old)
-        entry.geometry.dispose();
-}
-// Rebuild all layer geometries when layers or volume change.
-// Debounces rapid changes (e.g. slider drags) to avoid repeated expensive marching cubes.
-$effect(() => {
-    const layers = resolved_layers;
-    void settings.halo;
+
+    active_geometries = entries
+    for (const entry of old) entry.geometry.dispose()
+  }
+
+  // Rebuild all layer geometries when layers or volume change.
+  // Debounces rapid changes (e.g. slider drags) to avoid repeated expensive marching cubes.
+  $effect(() => {
+    const layers = resolved_layers
+    void settings.halo
     if (!ds_result) {
-        dispose_all();
-        return;
+      dispose_all()
+      return
     }
     debounce_id = window.setTimeout(() => {
-        raf_id = requestAnimationFrame(() => rebuild_geometries(layers));
-    }, 50);
+      raf_id = requestAnimationFrame(() => rebuild_geometries(layers))
+    }, 50)
     return () => {
-        clearTimeout(debounce_id);
-        cancelAnimationFrame(raf_id);
-    };
-});
+      clearTimeout(debounce_id)
+      cancelAnimationFrame(raf_id)
+    }
+  })
 </script>
 
 <!-- Render each geometry entry with appropriate material -->

package/dist/isosurface/IsosurfaceControls.svelte

@@ -1,35 +1,53 @@
-<script lang="ts">// Controls panel for isosurface visualization settings (isovalue, opacity, colors, etc.)
-// Supports both single-isovalue mode and multi-layer mode.
-import { format_num } from '../labels';
-import { SettingsSection } from '../layout';
-import { tooltip } from 'svelte-multiselect/attachments';
-import { DEFAULT_ISOSURFACE_SETTINGS, generate_layers } from './types';
-let { settings = $bindable({ ...DEFAULT_ISOSURFACE_SETTINGS }), volumes = [], active_volume_idx = $bindable(0), } = $props();
-// Clamp active_volume_idx when volumes list changes (e.g. dataset swap)
-$effect(() => {
+<script lang="ts">
+  // Controls panel for isosurface visualization settings (isovalue, opacity, colors, etc.)
+  // Supports both single-isovalue mode and multi-layer mode.
+  import { format_num } from '../labels'
+  import { SettingsSection } from '../layout'
+  import { tooltip } from 'svelte-multiselect/attachments'
+  import type { IsosurfaceLayer, IsosurfaceSettings, VolumetricData } from './types'
+  import { DEFAULT_ISOSURFACE_SETTINGS, generate_layers } from './types'
+
+  let {
+    settings = $bindable({ ...DEFAULT_ISOSURFACE_SETTINGS }),
+    volumes = [],
+    active_volume_idx = $bindable(0),
+  }: {
+    settings?: IsosurfaceSettings
+    volumes?: VolumetricData[]
+    active_volume_idx?: number
+  } = $props()
+
+  // Clamp active_volume_idx when volumes list changes (e.g. dataset swap)
+  $effect(() => {
     if (volumes.length > 0 && active_volume_idx >= volumes.length) {
-        active_volume_idx = 0;
+      active_volume_idx = 0
     }
-});
-// Use precomputed data_range from the active volume
-let data_range = $derived(volumes[active_volume_idx]?.data_range ?? { min: 0, max: 1, abs_max: 1, mean: 0 });
-let slider_max = $derived(Math.max(data_range.abs_max, 0.001));
-let step = $derived(slider_max / 200);
-let is_multi_layer = $derived((settings.layers?.length ?? 0) > 0);
-let n_layers = $derived(settings.layers?.length ?? 1);
-function set_layer_count(count) {
+  })
+
+  // Use precomputed data_range from the active volume
+  let data_range = $derived(
+    volumes[active_volume_idx]?.data_range ?? { min: 0, max: 1, abs_max: 1, mean: 0 },
+  )
+
+  let slider_max = $derived(Math.max(data_range.abs_max, 0.001))
+  let step = $derived(slider_max / 200)
+  let is_multi_layer = $derived((settings.layers?.length ?? 0) > 0)
+  let n_layers = $derived(settings.layers?.length ?? 1)
+
+  function set_layer_count(count: number) {
     if (count <= 1) {
-        settings.layers = undefined;
+      settings.layers = undefined
+    } else {
+      settings.layers = generate_layers(data_range, count)
     }
-    else {
-        settings.layers = generate_layers(data_range, count);
-    }
-}
-function update_layer(idx, updates) {
-    if (!settings.layers)
-        return;
-    settings.layers = settings.layers.map((layer, layer_idx) => layer_idx === idx ? { ...layer, ...updates } : layer);
-}
+  }
+
+  function update_layer(idx: number, updates: Partial<IsosurfaceLayer>) {
+    if (!settings.layers) return
+    settings.layers = settings.layers.map((layer, layer_idx) =>
+      layer_idx === idx ? { ...layer, ...updates } : layer
+    )
+  }
 </script>
 
 <SettingsSection

package/dist/isosurface/parse.js

@@ -1,11 +1,10 @@
 // Parsers for volumetric data file formats (VASP CHGCAR, Gaussian .cube)
-import { VASP_VOLUMETRIC_REGEX } from '../constants';
+import { COMPRESSION_EXTENSIONS_REGEX, VASP_VOLUMETRIC_REGEX } from '../constants';
 import { ELEM_SYMBOLS } from '../labels';
 import * as math from '../math';
+import { wrap_to_unit_cell } from '../structure/pbc';
 // Bohr radius in Angstroms (for Gaussian .cube unit conversion)
 const BOHR_TO_ANGSTROM = 0.529177249;
-// Wrap a value to [0, 1) range for fractional coordinates
-const wrap_frac = (val) => val - Math.floor(val);
 // === Fast number parsing utilities ===
 // Parse whitespace-separated numbers directly from a string, starting at `pos`.
 // Writes into a pre-allocated Float64Array and returns { count, end_pos }.
@@ -87,11 +86,9 @@ function read_lines(text, pos, count) {
     }
     return { lines: result, next: pos };
 }
-function build_grid({ data, nx, ny, nz, divisor = 1, data_order = `z_fastest` }) {
+function build_grid({ data, nx, ny, nz, divisor = 1, data_order = `z_fastest`, }) {
     const grid = new Array(nx);
-    let min_val = Infinity;
-    let max_val = -Infinity;
-    let sum = 0;
+    let [min_val, max_val, sum] = [Infinity, -Infinity, 0];
     const total = nx * ny * nz;
     const data_len = Math.min(data.length, total);
     if (data_len === 0) {
@@ -135,8 +132,7 @@ function build_grid({ data, nx, ny, nz, divisor = 1, data_order = `z_fastest` })
                 plane[iy] = new Array(nz).fill(0);
             grid[ix] = plane;
         }
-        let flat_idx = 0;
-        let data_exhausted = false;
+        let [flat_idx, data_exhausted] = [0, false];
         for (let iz = 0; iz < nz; iz++) {
             for (let iy = 0; iy < ny; iy++) {
                 for (let ix = 0; ix < nx; ix++) {
@@ -165,8 +161,8 @@ function build_grid({ data, nx, ny, nz, divisor = 1, data_order = `z_fastest` })
     return { grid, data_range };
 }
 // === CHGCAR Parser ===
-// Parse VASP CHGCAR/AECCAR/ELFCAR/LOCPOT file format.
-// CHGCAR consists of a POSCAR header followed by volumetric data on a 3D grid.
+// Parse VASP CHGCAR/AECCAR/ELFCAR/LOCPOT/PARCHG file format.
+// CHGCAR/PARCHG consists of a POSCAR header followed by volumetric data on a 3D grid.
 // Spin-polarized files contain two data blocks (total charge + magnetization).
 export function parse_chgcar(content) {
     // Strip leading whitespace
@@ -240,8 +236,16 @@ export function parse_chgcar(content) {
     const is_direct = cur.line.trim().toUpperCase().startsWith(`D`);
     pos = cur.next;
     // Parse atomic positions
-    const lattice_transposed = math.transpose_3x3_matrix(lattice);
-    const lattice_inv = math.matrix_inverse_3x3(lattice_transposed);
+    let cart_to_frac;
+    let frac_to_cart;
+    try {
+        ;
+        ({ cart_to_frac, frac_to_cart } = math.create_lattice_converters(lattice));
+    }
+    catch {
+        console.error(`CHGCAR: lattice matrix is singular; cannot convert coordinates`);
+        return null;
+    }
     const sites = [];
     let atom_idx = 0;
     for (let elem_idx = 0; elem_idx < element_symbols.length; elem_idx++) {
@@ -259,13 +263,13 @@ export function parse_chgcar(content) {
             let abc;
             let xyz;
             if (is_direct) {
-                abc = [wrap_frac(coords[0]), wrap_frac(coords[1]), wrap_frac(coords[2])];
-                xyz = math.mat3x3_vec3_multiply(lattice_transposed, abc);
+                abc = wrap_to_unit_cell(coords);
+                xyz = frac_to_cart(abc);
             }
             else {
                 xyz = math.scale(coords, scale_factor);
-                const raw = math.mat3x3_vec3_multiply(lattice_inv, xyz);
-                abc = [wrap_frac(raw[0]), wrap_frac(raw[1]), wrap_frac(raw[2])];
+                const raw = cart_to_frac(xyz);
+                abc = wrap_to_unit_cell(raw);
             }
             sites.push({
                 species: [{ element, occu: 1, oxidation_state: 0 }],
@@ -414,21 +418,22 @@ export function parse_cube(content, options = {}) {
     const is_periodic = options.periodic ?? Math.hypot(...origin) < 1e-6;
     // Parse atomic positions
     const sites = [];
-    const lattice_transposed = math.transpose_3x3_matrix(lattice);
-    let lattice_inv;
+    let cube_cart_to_frac;
     try {
-        lattice_inv = math.matrix_inverse_3x3(lattice_transposed);
+        cube_cart_to_frac = math.create_cart_to_frac(lattice);
     }
     catch {
         // Non-periodic system (molecule), use identity
-        lattice_inv = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
+        cube_cart_to_frac = (v) => [v[0], v[1], v[2]];
     }
     for (let atom_idx = 0; atom_idx < n_atoms; atom_idx++) {
         const cur = read_line(content, pos);
         const atom_line = cur.line.trim().split(/\s+/).map(Number);
         pos = cur.next;
         // Validate: need atomic_number, charge, x, y, z (5 tokens, indices 2-4 finite)
-        if (atom_line.length < 5 || !isFinite(atom_line[2]) || !isFinite(atom_line[3]) ||
+        if (atom_line.length < 5 ||
+            !isFinite(atom_line[2]) ||
+            !isFinite(atom_line[3]) ||
             !isFinite(atom_line[4])) {
             console.warn(`.cube atom ${atom_idx}: malformed line "${cur.line.trim()}", skipping`);
             continue;
@@ -438,7 +443,7 @@ export function parse_cube(content, options = {}) {
         // Convert Cartesian to fractional, accounting for origin offset.
         // Store lattice-frame xyz (shifted) so abc and xyz stay consistent.
         const xyz = math.subtract(raw_xyz, origin);
-        const abc = math.mat3x3_vec3_multiply(lattice_inv, xyz);
+        const abc = cube_cart_to_frac(xyz);
         const element = atomic_number_to_symbol(atom_line[0]);
         sites.push({
             species: [{ element, occu: 1, oxidation_state: 0 }],
@@ -481,7 +486,8 @@ export function parse_cube(content, options = {}) {
         nz: n_grid[2],
         data_order: `z_fastest`,
     });
-    const volumes = [{
+    const volumes = [
+        {
             grid,
             grid_dims: n_grid,
             lattice,
@@ -490,21 +496,20 @@ export function parse_cube(content, options = {}) {
             data_order: `z_fastest`,
             periodic: is_periodic, // periodic systems wrap; molecular .cube files include both endpoints
             label: `volumetric data`,
-        }];
+        },
+    ];
     return { structure, volumes };
 }
 // Convert atomic number to element symbol using ELEM_SYMBOLS (1-indexed: H=1, He=2, ...)
 function atomic_number_to_symbol(atomic_number) {
     // ELEM_SYMBOLS is 0-indexed (H at index 0), atomic numbers are 1-indexed
     const idx = atomic_number - 1;
-    return (idx >= 0 && idx < ELEM_SYMBOLS.length
-        ? ELEM_SYMBOLS[idx]
-        : `H`);
+    return (idx >= 0 && idx < ELEM_SYMBOLS.length ? ELEM_SYMBOLS[idx] : `H`);
 }
 // Auto-detect and parse volumetric file format based on filename and content
 export function parse_volumetric_file(content, filename) {
     // Strip compression suffixes so "CHGCAR.gz" and "molecule.cube.bz2" match correctly
-    const lower_name = (filename ?? ``).toLowerCase().replace(/\.(gz|bz2|xz|zst)$/, ``);
+    const lower_name = (filename ?? ``).toLowerCase().replace(COMPRESSION_EXTENSIONS_REGEX, ``);
     // Extension-based detection
     if (lower_name.endsWith(`.cube`))
         return parse_cube(content);