matterviz 0.4.1 → 0.4.2

package/dist/io/ExportPane.svelte

@@ -73,7 +73,9 @@
         {@attach section.tooltip
           ? tooltip({ allow_html: true, content: sanitize_html(section.tooltip) })
           : () => {}}
-      >{section.title}</h4>
+      >
+        {section.title}
+      </h4>
     {/if}
     <div class="export-grid">
       {#each section.items as item, item_idx (item.label)}
@@ -81,9 +83,9 @@
         <!-- not a <label>: it would forward label-text clicks to the first (download) button -->
         <span class="export-item">
           {#if item.hint}
-            <span
-              {@attach tooltip({ allow_html: true, content: sanitize_html(item.hint) })}
-            >{item.label}</span>
+            <span {@attach tooltip({ allow_html: true, content: sanitize_html(item.hint) })}
+              >{item.label}</span
+            >
           {:else}
             {item.label}
           {/if}
@@ -110,14 +112,16 @@
             </button>
           {/if}
           {#if item.show_dpi}
-            <span class="dpi-input">(DPI: <input
+            <span class="dpi-input"
+              >(DPI: <input
                 type="number"
                 min={dpi_range[0]}
                 max={dpi_range[1]}
                 bind:value={png_dpi}
                 onchange={clamp_dpi}
                 title="Export resolution in dots per inch"
-              />)</span>
+              />)</span
+            >
           {/if}
         </span>
       {/each}

package/dist/io/decompress.d.ts

@@ -1,11 +1,12 @@
 import type { COMPRESSION_EXTENSIONS } from '../constants';
 import { COMPRESSION_FORMATS } from '../constants';
+export declare function strip_compression_extensions(filename: string): string;
 export type CompressionFormat = keyof typeof COMPRESSION_FORMATS;
 export type CompressionExtension = (typeof COMPRESSION_EXTENSIONS)[number];
 export declare function detect_compression_format(filename: string): CompressionFormat | null;
 export declare function decompress_data(data: ArrayBuffer | ReadableStream<Uint8Array> | null, format: CompressionFormat): Promise<string>;
 export declare function decompress_data_binary(data: ArrayBuffer | ReadableStream<Uint8Array> | null, format: CompressionFormat): Promise<ArrayBuffer>;
 export declare function decompress_file(file: File): Promise<{
-    content: string;
+    content: string | ArrayBuffer;
     filename: string;
 }>;

package/dist/io/decompress.js

@@ -1,5 +1,13 @@
 import { COMPRESSION_EXTENSIONS_REGEX, COMPRESSION_FORMATS } from '../constants';
-import { to_error } from '../utils';
+import { is_binary_payload } from './is-binary';
+// Lowercase a filename and strip all trailing compression extensions (.gz, .zip, ...)
+export function strip_compression_extensions(filename) {
+    let base_name = filename.toLowerCase();
+    while (COMPRESSION_EXTENSIONS_REGEX.test(base_name)) {
+        base_name = base_name.replace(COMPRESSION_EXTENSIONS_REGEX, ``);
+    }
+    return base_name;
+}
 export function detect_compression_format(filename) {
     const lower = filename.toLowerCase();
     for (const [format, extensions] of Object.entries(COMPRESSION_FORMATS)) {
@@ -37,39 +45,18 @@ export async function decompress_data_binary(data, format) {
         throw new Error(`Failed to decompress ${format} file: ${error}`, { cause: error });
     }
 }
-export function decompress_file(file) {
+const to_content = (filename, buffer) => is_binary_payload(filename, buffer) ? buffer : new TextDecoder().decode(buffer);
+// Read a dropped file, decompressing supported formats. Binary payloads (by extension or
+// magic bytes) return as ArrayBuffer so parsers get raw bytes; text decodes to string.
+export async function decompress_file(file) {
     const format = detect_compression_format(file.name);
-    const is_supported = format !== null && format !== `zip` && format !== `xz` && format !== `bz2`;
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.addEventListener(`load`, () => {
-            try {
-                const result = reader.result;
-                // strict null check: empty files legitimately read as '' (falsy)
-                if (result === null)
-                    throw new Error(`Failed to read file`);
-                if (is_supported && format) {
-                    if (!(result instanceof ArrayBuffer))
-                        throw new Error(`Expected binary file data`);
-                    decompress_data(result, format).then((content) => {
-                        const filename = file.name.replace(COMPRESSION_EXTENSIONS_REGEX, ``);
-                        resolve({ content, filename });
-                    }, reject);
-                }
-                else {
-                    if (typeof result !== `string`)
-                        throw new Error(`Expected text file data`);
-                    resolve({ content: result, filename: file.name });
-                }
-            }
-            catch (error) {
-                reject(to_error(error));
-            }
-        }, { once: true });
-        reader.addEventListener(`error`, () => reject(new Error(`Failed to read file ${file.name}`)));
-        if (is_supported)
-            reader.readAsArrayBuffer(file);
-        else
-            reader.readAsText(file);
-    });
+    // zip/xz/bz2 are handled by their own code paths; null = not compressed
+    const decompressible = format !== null && format !== `zip` && format !== `xz` && format !== `bz2` ? format : null;
+    const buffer = await file.arrayBuffer();
+    if (decompressible) {
+        const filename = file.name.replace(COMPRESSION_EXTENSIONS_REGEX, ``);
+        const decompressed = await decompress_data_binary(buffer, decompressible);
+        return { content: to_content(filename, decompressed), filename };
+    }
+    return { content: to_content(file.name, buffer), filename: file.name };
 }

package/dist/io/export.d.ts

@@ -1,6 +1,10 @@
 import type { AnyStructure } from '../structure';
 import { type Camera, type Scene, type WebGLRenderer } from 'three';
 export declare const renderer_registry: WeakMap<HTMLCanvasElement, WebGLRenderer>;
+export declare const scene_registry: WeakMap<HTMLCanvasElement, {
+    scene: Scene;
+    camera: Camera;
+}>;
 export declare const dpi_to_scale: (png_dpi: number) => number;
 export declare function canvas_to_png_blob(canvas: HTMLCanvasElement, png_dpi?: number, scene?: Scene | null, camera?: Camera | null): Promise<Blob>;
 export declare function export_canvas_as_png(canvas: HTMLCanvasElement | null, structure_or_filename: AnyStructure | string | undefined, png_dpi?: number, scene?: Scene | null, camera?: Camera | null): void;

package/dist/io/export.js

@@ -5,6 +5,10 @@ import { Vector2 } from 'three';
 // Maps a Threlte canvas to its WebGLRenderer so PNG export can look up the renderer for a
 // given canvas without mutating the DOM element. Populated by bind_renderer (scene/).
 export const renderer_registry = new WeakMap();
+// Companion scene+camera mapping: WebGL buffers are cleared after present
+// (preserveDrawingBuffer is off), so any capture of a live canvas must
+// re-render synchronously first — which needs the scene and active camera.
+export const scene_registry = new WeakMap();
 // PNG DPI -> render scale relative to the 72 DPI baseline, capped at 10x. DPI floors
 // at 1 (non-finite -> 72) so bad inputs can't yield 0x0 canvases or NaN pixel ratios.
 export const dpi_to_scale = (png_dpi) => Math.min(Math.max(1, Number.isFinite(png_dpi) ? png_dpi : 72) / 72, 10);
@@ -303,7 +307,7 @@ export async function export_trajectory_video(canvas, filename, options = {}) {
             is_resolved = true;
             try {
                 const blob = new Blob(chunks, { type: `video/webm` });
-                const webm_filename = filename.replace(/\.(mp4|webm)$/i, `.webm`);
+                const webm_filename = filename.replace(/\.(?:mp4|webm)$/i, `.webm`);
                 download(blob, webm_filename, `video/webm`);
                 on_progress?.(100);
                 resolve();

package/dist/io/fetch.d.ts

@@ -1,6 +1,3 @@
 export declare const to_query: (params: Record<string, string | number | undefined>) => string;
-export declare function fetch_zipped<T>(url: string, { unzip }?: {
-    unzip?: boolean | undefined;
-}): Promise<T | null>;
 export type DownloadData = string | Blob | ArrayBuffer | ArrayBufferView<ArrayBuffer>;
 export declare function download(data: DownloadData, filename: string, type: string): void;

package/dist/io/fetch.js

@@ -1,19 +1,8 @@
-import { decompress_data } from './decompress';
 // Convert params object to URL query string, omitting empty/undefined values.
 // Example: {foo: "bar", baz: 42, empty: ""} → "foo=bar&baz=42"
 export const to_query = (params) => new URLSearchParams(Object.entries(params)
     .filter(([, val]) => val !== `` && val !== undefined)
     .map(([key, val]) => [key, String(val)])).toString();
-export async function fetch_zipped(url, { unzip = true } = {}) {
-    const response = await fetch(url);
-    if (!response.ok) {
-        console.error(`${response.status} ${response.statusText} for ${response.url}`);
-        return null;
-    }
-    if (!unzip)
-        return (await response.blob());
-    return JSON.parse(await decompress_data(response.body, `gzip`));
-}
 // Original download implementation
 function default_download(data, filename, type) {
     const file = new Blob([data], { type });

package/dist/io/index.d.ts

@@ -6,4 +6,3 @@ export * from './file-drop';
 export * from './is-binary';
 export type * from './types';
 export * from './url-drop';
-export declare function strip_compression_extensions(filename: string): string;

package/dist/io/index.js

@@ -1,16 +1,9 @@
-import { COMPRESSION_EXTENSIONS_REGEX } from '../constants';
 export { default as ExportPane } from './ExportPane.svelte';
+// strip_compression_extensions lives in ./decompress (Svelte-free) so parser
+// modules can import it inside Web Workers; re-exported here.
 export * from './decompress';
 export * from './export';
 export * from './fetch';
 export * from './file-drop';
 export * from './is-binary';
 export * from './url-drop';
-// Lowercase a filename and strip all trailing compression extensions (.gz, .zip, ...)
-export function strip_compression_extensions(filename) {
-    let base_name = filename.toLowerCase();
-    while (COMPRESSION_EXTENSIONS_REGEX.test(base_name)) {
-        base_name = base_name.replace(COMPRESSION_EXTENSIONS_REGEX, ``);
-    }
-    return base_name;
-}

package/dist/io/is-binary.d.ts

@@ -1 +1,10 @@
 export declare const is_binary: (content: string) => boolean;
+export declare const has_gzip_magic: (bytes: Uint8Array) => boolean;
+export declare const has_hdf5_magic: (bytes: Uint8Array) => boolean;
+export declare const has_binary_magic: (bytes: Uint8Array) => boolean;
+export declare const ext_of: (name: string) => string;
+export declare const BINARY_EXTENSIONS: Set<string>;
+export declare const is_known_text_file: (basename: string) => boolean;
+export declare const strip_gz_ext: (filename: string) => string;
+export declare const has_binary_inner_ext: (filename: string) => boolean;
+export declare const is_binary_payload: (filename: string, buffer: ArrayBuffer) => boolean;

package/dist/io/is-binary.js

@@ -1,4 +1,8 @@
-// Simplified binary detection
+// Single source of truth for binary-vs-text detection in the io layer (used by
+// decompress.ts and url-drop.ts): (1) is_binary string heuristic, (2) has_*_magic byte
+// signatures, (3) extension/filename classification.
+// === (1) string-content heuristic ===
+// Detect binary from decoded text: a NUL byte or a high ratio of non-printable chars.
 export const is_binary = (content) => {
     if (!content)
         return false;
@@ -18,3 +22,43 @@ export const is_binary = (content) => {
     }
     return (binary_char_count / content.length > 0.1 || printable_ascii_count / content.length < 0.7);
 };
+// === (2) magic-byte signatures ===
+const starts_with = (bytes, sig) => bytes.length >= sig.length && sig.every((byte, idx) => bytes[idx] === byte);
+// gzip member header
+export const has_gzip_magic = (bytes) => starts_with(bytes, [0x1f, 0x8b]);
+// Full 8-byte HDF5 superblock signature "\x89HDF\r\n\x1a\n" — used to validate that a file
+// claiming a .h5/.hdf5 extension really is HDF5 (stricter than the binary sniff below).
+export const has_hdf5_magic = (bytes) => starts_with(bytes, [0x89, 0x48, 0x44, 0x46, 0x0d, 0x0a, 0x1a, 0x0a]);
+// Leading bytes that mark a payload as binary so a lossy UTF-8 decode would corrupt it.
+// HDF5 is matched by its 4-byte "\x89HDF" prefix (the non-ASCII 0x89 already rules out text
+// starting with "HDF"); the full 4-byte ZIP signatures rule out text merely starting "PK".
+export const has_binary_magic = (bytes) => has_gzip_magic(bytes) ||
+    starts_with(bytes, [0x89, 0x48, 0x44, 0x46]) || // HDF5 "\x89HDF"
+    starts_with(bytes, [0x50, 0x4b, 0x03, 0x04]) || // ZIP local file
+    starts_with(bytes, [0x50, 0x4b, 0x05, 0x06]) || // ZIP empty archive (EOCD)
+    starts_with(bytes, [0x50, 0x4b, 0x07, 0x08]) || // ZIP spanned
+    starts_with(bytes, [0x2d, 0x20, 0x6f, 0x66, 0x20, 0x55, 0x6c, 0x6d]); // ASE .traj "- of Ulm"
+// === (3) extension / filename classification ===
+export const ext_of = (name) => name.split(`.`).pop()?.toLowerCase() ?? ``;
+// Binary data formats whose lossy UTF-8 decode would corrupt bytes (post-decompression)
+const BINARY_DATA_EXTENSIONS = new Set(`h5 hdf5 traj npz pkl dat brml raw`.split(` `));
+// All extensions treated as binary: data formats + compressed wrappers that must be
+// downloaded/kept as raw bytes (used for binary-fetch mode and .gz inner-format checks)
+export const BINARY_EXTENSIONS = new Set([
+    ...BINARY_DATA_EXTENSIONS,
+    ...`gz gzip zip bz2 xz`.split(` `),
+]);
+// Known text formats (plus extensionless VASP files) — safe to fetch/sniff as text
+const TEXT_EXTENSIONS = new Set(`xyz extxyz json cif poscar yaml yml txt md py js ts css html xml`.split(` `));
+const VASP_BASENAME_RE = /^(?:poscar|xdatcar|contcar)$/i;
+export const is_known_text_file = (basename) => TEXT_EXTENSIONS.has(ext_of(basename)) || VASP_BASENAME_RE.test(basename);
+const GZ_EXT_RE = /\.(?:gz|gzip)$/i;
+// Strip a trailing .gz/.gzip wrapper extension, leaving any inner extension intact
+export const strip_gz_ext = (filename) => filename.replace(GZ_EXT_RE, ``);
+// Whether the file inside a .gz/.gzip wrapper is a known binary format that a lossy text
+// decode would corrupt (bytes >= 0x80 -> U+FFFD)
+export const has_binary_inner_ext = (filename) => BINARY_EXTENSIONS.has(ext_of(strip_gz_ext(filename)));
+// Binary if the (post-decompression) extension is a known binary data format or the leading
+// bytes match a magic signature
+export const is_binary_payload = (filename, buffer) => BINARY_DATA_EXTENSIONS.has(ext_of(filename)) ||
+    has_binary_magic(new Uint8Array(buffer.slice(0, 8)));

package/dist/io/url-drop.js

@@ -1,9 +1,6 @@
 import { load_binary_traj } from '../trajectory/parse';
 import { decompress_data_binary } from './decompress';
-const BINARY_EXTENSIONS = new Set(`h5 hdf5 traj npz pkl dat gz gzip zip bz2 xz brml raw`.split(` `));
-const TEXT_EXTENSIONS = new Set(`xyz extxyz json cif poscar yaml yml txt md py js ts css html xml`.split(` `));
-const VASP_BASENAME_RE = /^(poscar|xdatcar|contcar)$/i;
-const GZ_EXT_RE = /\.(gz|gzip)$/i;
+import { BINARY_EXTENSIONS, ext_of, has_binary_inner_ext, has_binary_magic, has_gzip_magic, has_hdf5_magic, is_known_text_file, strip_gz_ext, } from './is-binary';
 // Extract filename from Content-Disposition header, falling back to url_basename.
 function extract_filename(headers, fallback) {
     if (!headers)
@@ -11,11 +8,11 @@ function extract_filename(headers, fallback) {
     const content_disposition_str = headers.get(`content-disposition`);
     if (!content_disposition_str)
         return fallback;
-    const star_match = /filename\*=([^;]+)/i.exec(content_disposition_str);
+    const star_match = /filename\*=(?<value>[^;]+)/i.exec(content_disposition_str);
     if (star_match?.[1]) {
         let raw = star_match[1].trim().replaceAll(/^"|"$/g, ``);
         // Strip any RFC 5987 charset'language' prefix; bare values pass through unchanged
-        const ext_value_match = /^[\w!#$%&+^`{}~-]+'[\w-]*'(.*)$/.exec(raw);
+        const ext_value_match = /^[\w!#$%&+^`{}~-]+'[\w-]*'(?<value>.*)$/.exec(raw);
         if (ext_value_match)
             raw = ext_value_match[1];
         try {
@@ -25,17 +22,13 @@ function extract_filename(headers, fallback) {
             return raw;
         }
     }
-    const plain_match = /filename\s*=\s*"?([^";]+)"?/i.exec(content_disposition_str);
+    const plain_match = /filename\s*=\s*"?(?<value>[^";]+)"?/i.exec(content_disposition_str);
     // truthiness check (not ??) so whitespace-only `filename=` values fall back too
     const name = plain_match?.[1]?.trim();
     if (!name)
         return fallback;
     return name;
 }
-const ext_of = (name) => name.split(`.`).pop()?.toLowerCase() ?? ``;
-// Whether the file inside a .gz/.gzip wrapper is a known binary format that a
-// lossy text decode would corrupt (bytes >= 0x80 → U+FFFD)
-const has_binary_inner_ext = (filename) => BINARY_EXTENSIONS.has(ext_of(filename.replace(GZ_EXT_RE, ``)));
 // Gunzip a fetched payload → [content, filename] with .gz/.gzip stripped; content
 // stays an ArrayBuffer for binary inner formats, decoded string otherwise
 async function decompress_gz_payload(buffer, filename) {
@@ -43,7 +36,7 @@ async function decompress_gz_payload(buffer, filename) {
     const content = has_binary_inner_ext(filename)
         ? decompressed
         : new TextDecoder().decode(decompressed);
-    return [content, filename.replace(GZ_EXT_RE, ``)];
+    return [content, strip_gz_ext(filename)];
 }
 // Handle URL-based file drop data by fetching content lazily
 export async function handle_url_drop(drag_event, callback) {
@@ -87,12 +80,10 @@ export async function load_from_url(url, callback) {
         if (ext === `h5` || ext === `hdf5`) {
             const result = await load_binary_traj(resp, `H5`, true);
             // Log warning if signature doesn't match (only for ArrayBuffer results)
-            if (result instanceof ArrayBuffer && result.byteLength >= 8) {
-                const view = new Uint8Array(result.slice(0, 8));
-                const hdf5_signature = [0x89, 0x48, 0x44, 0x46, 0x0d, 0x0a, 0x1a, 0x0a];
-                if (!hdf5_signature.every((byte, idx) => view[idx] === byte)) {
-                    console.warn(`File has .h5/.hdf5 extension but missing HDF5 signature`);
-                }
+            if (result instanceof ArrayBuffer &&
+                result.byteLength >= 8 &&
+                !has_hdf5_magic(new Uint8Array(result.slice(0, 8)))) {
+                console.warn(`File has .h5/.hdf5 extension but missing HDF5 signature`);
             }
             return callback(result, filename);
         }
@@ -108,7 +99,7 @@ export async function load_from_url(url, callback) {
     }
     // Skip Range requests for known text formats to avoid production server issues
     // Include VASP files that don't have extensions (POSCAR, XDATCAR, CONTCAR)
-    const is_known_text = TEXT_EXTENSIONS.has(ext) || VASP_BASENAME_RE.test(url_basename);
+    const is_known_text = is_known_text_file(url_basename);
     let sniffed_callback_args;
     if (!is_known_text) {
         // Only the Range sniff is guarded (failure → plain text fetch). Once magic bytes
@@ -121,13 +112,10 @@ export async function load_from_url(url, callback) {
             const head = await fetch(url, { headers: { Range: `bytes=0-15` } });
             if (head.ok) {
                 const buf = new Uint8Array(await head.arrayBuffer());
-                const is_gzip = buf[0] === 0x1f && buf[1] === 0x8b;
-                const is_hdf5 = buf[0] === 0x89 && buf[1] === 0x48 && buf[2] === 0x44 && buf[3] === 0x46;
-                // ASE .traj files start with the Ulm signature "- of Ulm"
-                const is_ase_traj = [0x2d, 0x20, 0x6f, 0x66, 0x20, 0x55, 0x6c, 0x6d].every((byte, idx) => buf[idx] === byte);
-                if (is_gzip)
+                // gzip is gunzipped downstream; other binary magic (HDF5, ZIP, ASE Ulm) stays raw
+                if (has_gzip_magic(buf))
                     sniffed = `gzip`;
-                else if (is_hdf5 || is_ase_traj)
+                else if (has_binary_magic(buf))
                     sniffed = `binary`;
             }
         }

package/dist/isosurface/Isosurface.svelte

@@ -14,13 +14,12 @@
     Uint32BufferAttribute,
   } from 'three'
   import type { IsosurfaceLayer, IsosurfaceSettings, VolumetricData } from './types'
-  import {
-    DEFAULT_ISOSURFACE_SETTINGS,
-    downsample_grid,
-    pad_periodic_grid,
-  } from './types'
+  import { DEFAULT_ISOSURFACE_SETTINGS, downsample_grid, pad_periodic_grid } from './types'
 
-  let { volume, settings = DEFAULT_ISOSURFACE_SETTINGS }: {
+  let {
+    volume,
+    settings = DEFAULT_ISOSURFACE_SETTINGS,
+  }: {
     volume: VolumetricData
     settings?: IsosurfaceSettings
   } = $props()
@@ -28,23 +27,22 @@
   // 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,
-    }]
+    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: Vec3[],
-    faces: number[][],
-  ): BufferGeometry | null {
+  function build_geometry(vertices: Vec3[], faces: number[][]): BufferGeometry | null {
     if (vertices.length === 0 || faces.length === 0) return null
 
     // Flatten vertices: Vec3[] → Float32Array
@@ -242,11 +240,7 @@
     </T.Mesh>
   {:else if entry.opacity < 1}
     <!-- Two-pass rendering for correct transparency -->
-    <T.Mesh
-      geometry={entry.geometry}
-      renderOrder={entry.render_order}
-      frustumCulled={false}
-    >
+    <T.Mesh geometry={entry.geometry} renderOrder={entry.render_order} frustumCulled={false}>
       <T.MeshStandardMaterial
         color={entry.color}
         transparent

package/dist/isosurface/IsosurfaceControls.svelte

@@ -45,7 +45,7 @@
   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
+      layer_idx === idx ? { ...layer, ...updates } : layer,
     )
   }
 </script>
@@ -68,7 +68,9 @@
   <div class="pane-row compact-row">
     {#if volumes.length > 1}
       <label
-        {@attach tooltip({ content: `Select which volume to display (e.g. charge vs magnetization)` })}
+        {@attach tooltip({
+          content: `Select which volume to display (e.g. charge vs magnetization)`,
+        })}
       >
         <span>Volume:</span>
         <select bind:value={active_volume_idx}>
@@ -79,13 +81,14 @@
       </label>
     {/if}
     <label
-      {@attach tooltip({ content: `Number of isosurface shells at different density thresholds` })}
+      {@attach tooltip({
+        content: `Number of isosurface shells at different density thresholds`,
+      })}
     >
       <span>Layers:</span>
       <select
         value={n_layers}
-        onchange={(event) =>
-        set_layer_count(Number(event.currentTarget.value))}
+        onchange={(event) => set_layer_count(Number(event.currentTarget.value))}
       >
         {#each [1, 2, 3, 4, 5] as count (count)}
           <option value={count}>{count}</option>
@@ -95,14 +98,16 @@
     <!-- Sync both settings.show_negative (single-layer fallback) and all layer entries
     so the toggle works consistently regardless of which mode is active -->
     <label
-      {@attach tooltip({ content: `Show negative lobe at −isovalue (for orbitals, ESP, magnetization)` })}
+      {@attach tooltip({
+        content: `Show negative lobe at −isovalue (for orbitals, ESP, magnetization)`,
+      })}
     >
       <span>Neg. lobe</span>
       <input
         type="checkbox"
         checked={is_multi_layer
-        ? settings.layers?.some((layer) => layer.show_negative) ?? false
-        : settings.show_negative}
+          ? (settings.layers?.some((layer) => layer.show_negative) ?? false)
+          : settings.show_negative}
         onchange={(event) => {
           const checked = event.currentTarget.checked
           settings.show_negative = checked
@@ -115,9 +120,7 @@
         }}
       />
     </label>
-    <label
-      {@attach tooltip({ content: `Render as wireframe mesh instead of solid surface` })}
-    >
+    <label {@attach tooltip({ content: `Render as wireframe mesh instead of solid surface` })}>
       <span>Wireframe</span>
       <input type="checkbox" bind:checked={settings.wireframe} />
     </label>
@@ -135,8 +138,7 @@
         <input
           type="color"
           value={layer.color}
-          onchange={(event) =>
-          update_layer(idx, { color: event.currentTarget.value })}
+          onchange={(event) => update_layer(idx, { color: event.currentTarget.value })}
         />
         <input
           type="range"
@@ -145,9 +147,9 @@
           {step}
           value={layer.isovalue}
           oninput={(event) =>
-          update_layer(idx, {
-            isovalue: Number(event.currentTarget.value),
-          })}
+            update_layer(idx, {
+              isovalue: Number(event.currentTarget.value),
+            })}
           style="flex: 1; min-width: 60px"
         />
         <span class="layer-value">{format_num(layer.isovalue, `.3~g`)}</span>
@@ -158,9 +160,9 @@
           step={0.05}
           value={layer.opacity}
           oninput={(event) =>
-          update_layer(idx, {
-            opacity: Number(event.currentTarget.value),
-          })}
+            update_layer(idx, {
+              opacity: Number(event.currentTarget.value),
+            })}
           style="width: 50px"
           title="Opacity: {format_num(layer.opacity, `.2f`)}"
         />
@@ -169,23 +171,21 @@
   {:else}
     <!-- Single-layer: isovalue slider full width -->
     <label
-      {@attach tooltip({ content: `Density threshold — surface is drawn where grid values equal this` })}
+      {@attach tooltip({
+        content: `Density threshold — surface is drawn where grid values equal this`,
+      })}
     >
       <span>Isovalue:</span>
-      <input
-        type="range"
-        min={step}
-        max={slider_max}
-        {step}
-        bind:value={settings.isovalue}
-      />
+      <input type="range" min={step} max={slider_max} {step} bind:value={settings.isovalue} />
       <span class="value">{format_num(settings.isovalue, `.4~g`)}</span>
     </label>
 
     <!-- Opacity + colors on one row -->
     <div class="pane-row compact-row">
       <label
-        {@attach tooltip({ content: `Surface transparency — lower values reveal inner structure` })}
+        {@attach tooltip({
+          content: `Surface transparency — lower values reveal inner structure`,
+        })}
       >
         <span>Opacity:</span>
         <input
@@ -203,9 +203,7 @@
         <input type="color" bind:value={settings.positive_color} />
       </label>
       {#if settings.show_negative}
-        <label
-          {@attach tooltip({ content: `Color for the negative (−isovalue) surface` })}
-        >
+        <label {@attach tooltip({ content: `Color for the negative (−isovalue) surface` })}>
           <span>&minus; Color</span>
           <input type="color" bind:value={settings.negative_color} />
         </label>
@@ -215,24 +213,21 @@
 
   {#if volumes?.[active_volume_idx]?.periodic}
     <label
-      {@attach tooltip({ content: `Extend isosurface beyond cell boundaries to close partial spheres (fraction of cell)` })}
+      {@attach tooltip({
+        content: `Extend isosurface beyond cell boundaries to close partial spheres (fraction of cell)`,
+      })}
     >
       Halo: {format_num(settings.halo, `.2f`)}
-      <input
-        type="range"
-        min={0}
-        max={0.5}
-        step={0.01}
-        bind:value={settings.halo}
-      />
+      <input type="range" min={0} max={0.5} step={0.01} bind:value={settings.halo} />
     </label>
   {/if}
 
   {#if volumes[active_volume_idx]}
     <div class="grid-info">
-      {volumes[active_volume_idx].grid_dims.join(` × `)} grid &nbsp;|&nbsp; [{
-        format_num(data_range.min, `.3~g`)
-      }, {format_num(data_range.max, `.3~g`)}]
+      {volumes[active_volume_idx].grid_dims.join(` × `)} grid &nbsp;|&nbsp; [{format_num(
+        data_range.min,
+        `.3~g`,
+      )}, {format_num(data_range.max, `.3~g`)}]
     </div>
   {/if}
 </SettingsSection>

package/dist/isosurface/parse-vaspwave.d.ts

@@ -0,0 +1,3 @@
+import type { VolumetricFileData } from './types';
+export declare const is_vaspwave_filename: (filename: string) => boolean;
+export declare function parse_vaspwave_charge(buffer: ArrayBuffer, filename?: string): Promise<VolumetricFileData>;