matterviz 0.3.7 → 0.4.0

package/dist/io/decompress.js

@@ -1,4 +1,5 @@
 import { COMPRESSION_EXTENSIONS_REGEX, COMPRESSION_FORMATS } from '../constants';
+import { to_error } from '../utils';
 export function detect_compression_format(filename) {
     const lower = filename.toLowerCase();
     for (const [format, extensions] of Object.entries(COMPRESSION_FORMATS)) {
@@ -45,7 +46,8 @@ export function decompress_file(file) {
         reader.addEventListener(`load`, () => {
             try {
                 const result = reader.result;
-                if (!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))
@@ -62,7 +64,7 @@ export function decompress_file(file) {
                 }
             }
             catch (error) {
-                reject(error);
+                reject(to_error(error));
             }
         }, { once: true });
         reader.addEventListener(`error`, () => reject(new Error(`Failed to read file ${file.name}`)));

package/dist/io/export.d.ts

@@ -2,10 +2,10 @@ import type { AnyStructure } from '../structure';
 import { type Camera, type Scene } from 'three';
 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;
-export declare function svg_to_svg_string(svg_element: SVGElement): string;
-export declare function export_svg_as_svg(svg_element: SVGElement | null, filename: string): void;
-export declare function svg_to_png_blob(svg_element: SVGElement, png_dpi?: number): Promise<Blob>;
-export declare function export_svg_as_png(svg_element: SVGElement | null, filename: string, png_dpi?: number): void;
+export declare function svg_to_svg_string(svg_element: SVGElement, inline_styles?: readonly string[]): string;
+export declare function export_svg_as_svg(svg_element: SVGElement | null, filename: string, inline_styles?: readonly string[]): void;
+export declare function svg_to_png_blob(svg_element: SVGElement, png_dpi?: number, inline_styles?: readonly string[]): Promise<Blob>;
+export declare function export_svg_as_png(svg_element: SVGElement | null, filename: string, png_dpi?: number, inline_styles?: readonly string[]): void;
 export declare function get_ffmpeg_conversion_command(input_filename: string): string;
 export declare function export_trajectory_video(canvas: HTMLCanvasElement | null, filename: string, options?: {
     fps?: number;

package/dist/io/export.js

@@ -1,5 +1,6 @@
 import { download } from './fetch';
 import { create_structure_filename } from '../structure/export';
+import { to_error } from '../utils';
 import { Vector2 } from 'three';
 function is_webgl_renderer_like(value) {
     if (typeof value !== `object` || !value)
@@ -12,7 +13,8 @@ function is_webgl_renderer_like(value) {
         typeof renderer_obj.setSize === `function`);
 }
 function get_canvas_renderer(canvas) {
-    const renderer_val = canvas[`__renderer`];
+    // oxlint-disable-next-line no-underscore-dangle -- three.js stores its renderer here
+    const renderer_val = canvas.__renderer;
     return is_webgl_renderer_like(renderer_val) ? renderer_val : undefined;
 }
 // Capture a WebGL canvas as a PNG Blob at the given DPI.
@@ -36,7 +38,7 @@ export function canvas_to_png_blob(canvas, png_dpi = 150, scene = null, camera =
                 }, `image/png`);
             }
             catch (error) {
-                reject(error);
+                reject(to_error(error));
             }
         });
     }
@@ -63,7 +65,7 @@ export function canvas_to_png_blob(canvas, png_dpi = 150, scene = null, camera =
         }
         catch (error) {
             restore();
-            reject(error);
+            reject(to_error(error));
         }
     });
 }
@@ -90,34 +92,56 @@ export function export_canvas_as_png(canvas, structure_or_filename, png_dpi = 15
 }
 // Helper to ensure font-family is set on SVG root
 function set_svg_font_family(svg) {
-    const style = svg.getAttribute(`style`) || ``;
+    const style = svg.getAttribute(`style`) ?? ``;
     if (!style.includes(`font-family`)) {
         svg.setAttribute(`style`, `${style}${style ? `;` : ``}font-family:sans-serif;`);
     }
     // Also set as attribute for extra robustness
     svg.setAttribute(`font-family`, `sans-serif`);
 }
-// Serialize an SVG element to a standalone SVG string with proper XML headers.
-// Clones the element to avoid mutation, sets font-family/xmlns, and
-// prepends XML declaration + SVG DOCTYPE. Returns a complete SVG document string
-// suitable for saving to file or further processing.
-export function svg_to_svg_string(svg_element) {
-    const cloned_svg = svg_element.cloneNode(true);
-    set_svg_font_family(cloned_svg);
-    if (!cloned_svg.hasAttribute(`xmlns`)) {
-        cloned_svg.setAttribute(`xmlns`, `http://www.w3.org/2000/svg`);
+// Copy the given computed-style props from each live SVG element to its clone counterpart;
+// identical structure lets querySelectorAll(`*`) walk both in lockstep. Writes clone-only.
+function inline_computed_styles(live, clone, properties) {
+    const live_els = [live, ...live.querySelectorAll(`*`)];
+    const clone_els = [clone, ...clone.querySelectorAll(`*`)];
+    for (const [idx, live_el] of live_els.entries()) {
+        const computed = getComputedStyle(live_el);
+        for (const prop of properties) {
+            const val = computed.getPropertyValue(prop);
+            if (val)
+                clone_els[idx].setAttribute(prop, val);
+        }
+    }
+}
+// Clone, inline the given computed-style props, ensure font-family + xmlns, then serialize
+// to a standalone SVG string. Never mutates the live element.
+function serialize_svg_for_export(svg_element, inline_styles = []) {
+    const clone = svg_element.cloneNode(true);
+    if (inline_styles.length)
+        inline_computed_styles(svg_element, clone, inline_styles);
+    set_svg_font_family(clone);
+    if (!clone.hasAttribute(`xmlns`)) {
+        clone.setAttribute(`xmlns`, `http://www.w3.org/2000/svg`);
     }
-    const svg_string = new XMLSerializer().serializeToString(cloned_svg);
+    return new XMLSerializer().serializeToString(clone);
+}
+// Wrap serialize_svg_for_export's output as a full SVG document string (XML declaration +
+// DOCTYPE + SVG), suitable for saving to file.
+export function svg_to_svg_string(svg_element, 
+// CSS props to inline from computed styles as presentation attributes; a standalone SVG
+// drops page stylesheets (e.g. Svelte component styles), so class-based styling is lost.
+inline_styles = []) {
+    const svg_string = serialize_svg_for_export(svg_element, inline_styles);
     return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n${svg_string}`;
 }
 // Export SVG element as SVG file (triggers browser download)
-export function export_svg_as_svg(svg_element, filename) {
+export function export_svg_as_svg(svg_element, filename, inline_styles = []) {
     if (!svg_element) {
         console.warn(`SVG element not found for export`);
         return;
     }
     try {
-        const svg_content = svg_to_svg_string(svg_element);
+        const svg_content = svg_to_svg_string(svg_element, inline_styles);
         download(svg_content, filename, `image/svg+xml;charset=utf-8`);
     }
     catch (error) {
@@ -129,7 +153,7 @@ export function export_svg_as_svg(svg_element, filename) {
 // Image element, and returns the resulting PNG Blob. Rejects if viewBox is
 // missing or dimensions are invalid (zero width/height).
 // DPI is converted to a resolution multiplier relative to 72 DPI baseline, capped at 10x.
-export function svg_to_png_blob(svg_element, png_dpi = 150) {
+export function svg_to_png_blob(svg_element, png_dpi = 150, inline_styles = []) {
     const viewBox = svg_element.getAttribute(`viewBox`)?.trim();
     if (!viewBox)
         return Promise.reject(new Error(`SVG viewBox not found for PNG export`));
@@ -153,9 +177,7 @@ export function svg_to_png_blob(svg_element, png_dpi = 150) {
         return Promise.reject(new Error(`Canvas 2D context not available`));
     canvas.width = pixel_width;
     canvas.height = pixel_height;
-    const cloned_svg = svg_element.cloneNode(true);
-    set_svg_font_family(cloned_svg);
-    const serialized = new XMLSerializer().serializeToString(cloned_svg);
+    const serialized = serialize_svg_for_export(svg_element, inline_styles);
     const svg_blob = new Blob([serialized], { type: `image/svg+xml;charset=utf-8` });
     const svg_data_url = URL.createObjectURL(svg_blob);
     return new Promise((resolve, reject) => {
@@ -172,7 +194,7 @@ export function svg_to_png_blob(svg_element, png_dpi = 150) {
                 }, `image/png`, 1);
             }
             catch (error) {
-                reject(error);
+                reject(to_error(error));
             }
             finally {
                 URL.revokeObjectURL(svg_data_url);
@@ -186,12 +208,12 @@ export function svg_to_png_blob(svg_element, png_dpi = 150) {
     });
 }
 // Export SVG element as PNG (triggers browser download)
-export function export_svg_as_png(svg_element, filename, png_dpi = 150) {
+export function export_svg_as_png(svg_element, filename, png_dpi = 150, inline_styles = []) {
     if (!svg_element) {
         console.warn(`SVG element not found for PNG export`);
         return;
     }
-    svg_to_png_blob(svg_element, png_dpi)
+    svg_to_png_blob(svg_element, png_dpi, inline_styles)
         .then((blob) => download(blob, filename, `image/png`))
         .catch((error) => console.error(`Error exporting PNG:`, error));
 }
@@ -283,7 +305,7 @@ export async function export_trajectory_video(canvas, filename, options = {}) {
                 resolve();
             }
             catch (error) {
-                reject(error);
+                reject(to_error(error));
             }
         });
         recorder.addEventListener(`error`, (event) => {
@@ -309,7 +331,7 @@ export async function export_trajectory_video(canvas, filename, options = {}) {
         catch (error) {
             if (!is_resolved) {
                 is_resolved = true;
-                reject(error);
+                reject(to_error(error));
             }
         }
     });

package/dist/io/fetch.js

@@ -22,7 +22,11 @@ function default_download(data, filename, type) {
     link.style.display = `none`;
     link.href = url;
     link.download = filename;
-    document.body.appendChild(link);
+    // keep the synthetic download click from bubbling to document-level handlers
+    // (e.g. DraggablePane's click-outside) that would dismiss an open pane the export
+    // button lives in
+    link.addEventListener(`click`, (evt) => evt.stopPropagation());
+    document.body.append(link);
     link.click();
     link.remove();
     URL.revokeObjectURL(url);

package/dist/io/file-drop.d.ts

@@ -4,4 +4,4 @@ export interface FileDropOptions {
     on_error?: (msg: string) => void;
     set_loading?: (loading: boolean) => void;
 }
-export declare function create_file_drop_handler(opts: FileDropOptions): (event: DragEvent) => Promise<void>;
+export declare const create_file_drop_handler: (opts: FileDropOptions) => ((event: DragEvent) => Promise<void>);

package/dist/io/file-drop.js

@@ -1,43 +1,42 @@
 // Shared file-drop handler composable for drag-and-drop file loading.
 import { decompress_file } from './decompress';
 import { handle_url_drop } from './url-drop';
+import { to_error } from '../utils';
 // Handles URL drops (from FilePicker), direct file drops with decompression,
 // loading state, and error reporting.
-export function create_file_drop_handler(opts) {
-    return async (event) => {
-        event.preventDefault();
-        if (!opts.allow())
+export const create_file_drop_handler = (opts) => async (event) => {
+    event.preventDefault();
+    if (!opts.allow())
+        return;
+    opts.set_loading?.(true);
+    let drop_filename = ``;
+    try {
+        let url_error;
+        const handled = await handle_url_drop(event, opts.on_drop).catch((exc) => {
+            url_error = to_error(exc).message;
+            return false;
+        });
+        if (handled)
+            return;
+        const file = event.dataTransfer?.files[0];
+        if (!file) {
+            if (url_error)
+                opts.on_error?.(`Failed to load from URL: ${url_error}`);
             return;
-        opts.set_loading?.(true);
-        let drop_filename = ``;
-        try {
-            let url_error;
-            const handled = await handle_url_drop(event, opts.on_drop).catch((exc) => {
-                url_error = exc instanceof Error ? exc.message : String(exc);
-                return false;
-            });
-            if (handled)
-                return;
-            const file = event.dataTransfer?.files[0];
-            if (!file) {
-                if (url_error)
-                    opts.on_error?.(`Failed to load from URL: ${url_error}`);
-                return;
-            }
-            drop_filename = file.name;
-            const { content, filename } = await decompress_file(file);
-            if (content)
-                await opts.on_drop(content, filename);
-        }
-        catch (exc) {
-            const detail = exc instanceof Error ? exc.message : String(exc);
-            const msg = drop_filename
-                ? `Failed to load file ${drop_filename}: ${detail}`
-                : `Failed to load file: ${detail}`;
-            opts.on_error?.(msg);
-        }
-        finally {
-            opts.set_loading?.(false);
         }
-    };
-}
+        drop_filename = file.name;
+        const { content, filename } = await decompress_file(file);
+        if (content)
+            await opts.on_drop(content, filename);
+    }
+    catch (exc) {
+        const detail = to_error(exc).message;
+        const msg = drop_filename
+            ? `Failed to load file ${drop_filename}: ${detail}`
+            : `Failed to load file: ${detail}`;
+        opts.on_error?.(msg);
+    }
+    finally {
+        opts.set_loading?.(false);
+    }
+};

package/dist/io/url-drop.js

@@ -1,7 +1,9 @@
 import { load_binary_traj } from '../trajectory/parse';
-const BINARY_EXTENSIONS = new Set(`h5 hdf5 traj npz pkl dat gz gzip zip bz2 xz brml`.split(` `));
+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;
 // Extract filename from Content-Disposition header, falling back to url_basename.
 function extract_filename(headers, fallback) {
     if (!headers)
@@ -9,9 +11,13 @@ function extract_filename(headers, fallback) {
     const content_disposition_str = headers.get(`content-disposition`);
     if (!content_disposition_str)
         return fallback;
-    const star_match = /filename\*=(?:UTF-8''|)([^;]+)/i.exec(content_disposition_str);
+    const star_match = /filename\*=([^;]+)/i.exec(content_disposition_str);
     if (star_match?.[1]) {
-        const raw = star_match[1].trim().replace(/^"|"$/g, ``);
+        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);
+        if (ext_value_match)
+            raw = ext_value_match[1];
         try {
             return decodeURIComponent(raw);
         }
@@ -20,7 +26,24 @@ function extract_filename(headers, fallback) {
         }
     }
     const plain_match = /filename\s*=\s*"?([^";]+)"?/i.exec(content_disposition_str);
-    return plain_match?.[1]?.trim() || fallback;
+    // 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) {
+    const decompressed = await decompress_data_binary(buffer, `gzip`);
+    const content = has_binary_inner_ext(filename)
+        ? decompressed
+        : new TextDecoder().decode(decompressed);
+    return [content, filename.replace(GZ_EXT_RE, ``)];
 }
 // Handle URL-based file drop data by fetching content lazily
 export async function handle_url_drop(drag_event, callback) {
@@ -40,8 +63,10 @@ export async function handle_url_drop(drag_event, callback) {
     return true;
 }
 export async function load_from_url(url, callback) {
-    const url_basename = url.split(`/`).pop() || url;
-    const ext = url_basename.split(`.`).pop()?.toLowerCase() || ``;
+    // Strip query string/hash before basename/extension detection so pre-signed
+    // URLs like traj.h5?X-Amz-Expires=300 still hit the right format path
+    const url_basename = url.split(/[?#]/)[0].split(`/`).pop() ?? url;
+    const ext = ext_of(url_basename);
     if (BINARY_EXTENSIONS.has(ext)) {
         // Force binary mode for known binary files to handle GitHub Pages content-type issues
         const resp = await fetch(url);
@@ -51,17 +76,11 @@ export async function load_from_url(url, callback) {
         // Handle gzipped files with proper content-encoding detection
         if (ext === `gz` || ext === `gzip`) {
             if (resp.headers.get(`content-encoding`) === `gzip`) {
-                // Browser automatically decompressed it, so it's text
-                return callback(await resp.text(), filename);
-            }
-            else {
-                // Need to decompress manually
-                const { decompress_data } = await import(`./decompress`);
-                const buffer = await resp.arrayBuffer();
-                const content = await decompress_data(buffer, `gzip`);
-                // Remove .gz extension when manually decompressing
-                return callback(content, filename.replace(/\.gz$/, ``));
+                // Browser already decompressed the stored .gz (GitHub Pages-style serving), so
+                // the body is the inner file — keep binary inner formats (.h5.gz, ...) binary
+                return callback(await (has_binary_inner_ext(filename) ? resp.arrayBuffer() : resp.text()), filename);
             }
+            return callback(...(await decompress_gz_payload(await resp.arrayBuffer(), filename)));
         }
         // For H5 files, always load as binary regardless of signature
         // to handle files that have .h5/.hdf5 extensions but may not have the proper HDF5 signature
@@ -82,40 +101,52 @@ export async function load_from_url(url, callback) {
             const buffer = await load_binary_traj(resp, `.traj`);
             return callback(buffer, filename);
         }
-        if (resp.headers.get(`content-encoding`) === `gzip`) {
-            return callback(await resp.text(), filename);
-        }
+        // Content-Encoding is transparent transport compression: fetch already
+        // decompressed the body, so binary formats (npz, pkl, brml, ...) must still
+        // be read as ArrayBuffer — .text() would corrupt them via lossy UTF-8 decode
         return callback(await resp.arrayBuffer(), filename);
     }
     // 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);
-    let binary_callback_args;
+    let sniffed_callback_args;
     if (!is_known_text) {
+        // Only the Range sniff is guarded (failure → plain text fetch). Once magic bytes
+        // commit to a binary format, download/decompress errors must propagate instead of
+        // falling through to a text fetch that would parse the binary bytes as garbage.
+        let sniffed = null;
         try {
-            // Check for magic bytes only for unknown formats
+            // Check for magic bytes only for unknown formats (covers extensionless URLs
+            // like blob: object URLs whose basenames are UUIDs)
             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;
-                if (is_gzip || is_hdf5) {
-                    const resp = await fetch(url);
-                    if (!resp.ok)
-                        throw new Error(`Fetch failed: ${resp.status}`);
-                    binary_callback_args = [
-                        await resp.arrayBuffer(),
-                        extract_filename(resp.headers, url_basename),
-                    ];
-                }
+                // 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)
+                    sniffed = `gzip`;
+                else if (is_hdf5 || is_ase_traj)
+                    sniffed = `binary`;
             }
         }
         catch {
-            // Fall through to text fetch if HEAD request fails
+            // Fall through to text fetch if the Range HEAD request fails
+        }
+        if (sniffed) {
+            const resp = await fetch(url);
+            if (!resp.ok)
+                throw new Error(`Fetch failed: ${resp.status}`);
+            const filename = extract_filename(resp.headers, url_basename);
+            const buffer = await resp.arrayBuffer();
+            // Gunzip sniffed gzip — downstream parsers can't handle raw gzip bytes
+            sniffed_callback_args =
+                sniffed === `gzip` ? await decompress_gz_payload(buffer, filename) : [buffer, filename];
         }
     }
-    if (binary_callback_args)
-        return callback(...binary_callback_args);
+    if (sniffed_callback_args)
+        return callback(...sniffed_callback_args);
     const resp = await fetch(url);
     if (!resp.ok)
         throw new Error(`Fetch failed: ${resp.status}`);

package/dist/isosurface/parse.js

@@ -43,8 +43,8 @@ function parse_float_block(text, pos, max_count, data, data_offset = 0) {
         const start = pos;
         while (pos < len && text.charCodeAt(pos) > 32)
             pos++;
-        // Parse number using unary + (handles scientific notation)
-        const num = +text.substring(start, pos);
+        // Parse number (handles scientific notation)
+        const num = Number(text.slice(start, pos));
         if (!Number.isNaN(num)) {
             data[idx++] = num;
         }
@@ -68,7 +68,7 @@ function read_line(text, pos) {
     let end = pos;
     while (end < text.length && text.charCodeAt(end) !== 10 && text.charCodeAt(end) !== 13)
         end++;
-    const line = text.substring(pos, end);
+    const line = text.slice(pos, end);
     let next = end;
     if (next < text.length && text.charCodeAt(next) === 13)
         next++; // skip \r
@@ -200,7 +200,7 @@ export function parse_chgcar(content) {
     }
     // Detect VASP 5+ format (has element symbols before counts)
     const first_token = cur.line.trim().split(/\s+/)[0];
-    const has_element_symbols = isNaN(parseInt(first_token));
+    const has_element_symbols = isNaN(parseInt(first_token, 10));
     if (has_element_symbols) {
         element_symbols = cur.line.trim().split(/\s+/);
         pos = cur.next;
@@ -210,14 +210,13 @@ export function parse_chgcar(content) {
             return null;
         }
         atom_counts = cur.line.trim().split(/\s+/).map(Number);
-        pos = cur.next;
     }
     else {
         atom_counts = cur.line.trim().split(/\s+/).map(Number);
         const fallback_elements = [`H`, `He`, `Li`, `Be`, `B`, `C`, `N`, `O`, `F`, `Ne`];
         element_symbols = atom_counts.map((_count, idx) => fallback_elements[idx % fallback_elements.length]);
-        pos = cur.next;
     }
+    pos = cur.next;
     if (pos >= content.length) {
         console.error(`CHGCAR: file ends before coordinate mode line`);
         return null;
@@ -519,7 +518,7 @@ export function parse_volumetric_file(content, filename) {
     // Content-based detection (only parse first few lines, not the whole file)
     // Find enough lines for detection without splitting the entire string
     const detection_end = find_line_offset(content, 10);
-    const detection_text = content.substring(0, detection_end);
+    const detection_text = content.slice(0, detection_end);
     const lines = detection_text.split(/\r?\n/);
     // .cube detection: line 3 has 4 numbers (n_atoms + origin), line 4 has 4 numbers (grid dim + voxel)
     if (lines.length > 4) {

package/dist/isosurface/slice.js

@@ -32,9 +32,10 @@ export function trilinear_interpolate(grid, fx, fy, fz, periodic) {
     const x1 = periodic ? (x0 + 1) % nx : Math.min(x0 + 1, nx - 1);
     const y1 = periodic ? (y0 + 1) % ny : Math.min(y0 + 1, ny - 1);
     const z1 = periodic ? (z0 + 1) % nz : Math.min(z0 + 1, nz - 1);
-    const xd = gx - Math.floor(gx);
-    const yd = gy - Math.floor(gy);
-    const zd = gz - Math.floor(gz);
+    // deltas from clamped lower index (non-periodic x0 clamps to nx-2 so floor(gx) may != x0)
+    const xd = periodic ? gx - Math.floor(gx) : gx - x0;
+    const yd = periodic ? gy - Math.floor(gy) : gy - y0;
+    const zd = periodic ? gz - Math.floor(gz) : gz - z0;
     // 8-point interpolation
     const c000 = grid[x0][y0][z0];
     const c001 = grid[x0][y0][z1];
@@ -71,7 +72,7 @@ export function sample_hkl_slice(volume, miller_indices, distance, n_points) {
     ];
     if (Math.hypot(...plane_normal) < 1e-12)
         return null; // degenerate normal
-    const unit_normal = math.normalize_vec3(plane_normal);
+    const unit_normal = math.normalize_vec(plane_normal);
     // In-plane basis vectors
     const [u_vec, v_vec] = math.compute_in_plane_basis(unit_normal);
     const cart_to_frac = math.create_cart_to_frac(lattice);

package/dist/isosurface/types.js

@@ -13,7 +13,7 @@ export const LAYER_COLORS = [
 // Compute min/max/abs_max/mean of a 3D grid.
 // Prefer using the precomputed `data_range` field on VolumetricData when available.
 export function grid_data_range(grid) {
-    if (!grid.length || !grid[0]?.length || !grid[0][0]?.length) {
+    if (grid.length === 0 || !grid[0]?.length || !grid[0][0]?.length) {
         return { min: 0, max: 0, abs_max: 0, mean: 0 };
     }
     let [min_val, max_val] = [Infinity, -Infinity];

package/dist/keyboard.d.ts

@@ -0,0 +1,3 @@
+export type KeydownHandler = (event: KeyboardEvent) => boolean;
+export declare const handle_and_prevent: (handle: KeydownHandler) => (event: KeyboardEvent) => void;
+export declare const forward_window_keydown: (is_hovered: () => boolean, handle: KeydownHandler) => (event: KeyboardEvent) => void;

package/dist/keyboard.js

@@ -0,0 +1,23 @@
+// Shared helpers for wiring viewer keyboard shortcuts consistently across
+// components (Structure, Trajectory, ...). A handler returns `true` when it
+// handled the event, so the browser default is suppressed in exactly one place
+// instead of scattered `preventDefault()` calls.
+// Wrap a handler for an element-level `onkeydown` binding: run it and suppress
+// the browser default (page scroll, find, ...) when it reports it handled the key.
+export const handle_and_prevent = (handle) => (event) => {
+    if (handle(event))
+        event.preventDefault();
+};
+// Wrap a handler for a `<svelte:window onkeydown>` binding: forward keydowns to a
+// viewer only while it's hovered and focus is on <body>. This lets shortcuts work
+// without first clicking the viewer, while keeping multiple viewers on one page
+// from all responding and never hijacking keys from a focused input/pane.
+// Suppresses the browser default when the handler reports it handled the key.
+export const forward_window_keydown = (is_hovered, handle) => {
+    const run = handle_and_prevent(handle);
+    return (event) => {
+        const active = document.activeElement;
+        if (is_hovered() && (!active || active === document.body))
+            run(event);
+    };
+};

package/dist/labels.d.ts

@@ -11,7 +11,7 @@ export declare const ELEM_PROPERTY_LABELS: Partial<Record<keyof ChemicalElement,
 export declare const ELEM_HEATMAP_KEYS: (keyof ChemicalElement)[];
 export declare const ELEM_HEATMAP_LABELS: Partial<Record<string, keyof ChemicalElement>>;
 export declare const DEFAULT_FMT: [string, string];
-export declare const FRACTION_GLYPHS: ReadonlyArray<readonly [number, string]>;
+export declare const FRACTION_GLYPHS: readonly (readonly [number, string])[];
 export declare const format_num: (num: number, fmt?: string | number) => string;
 export declare const format_vec3: (vec: Readonly<Vec3>, fmt_spec?: string) => string;
 export declare const format_bytes: (bytes?: number) => string;

package/dist/labels.js

@@ -5,7 +5,7 @@ const is_d3_symbol_name = (name) => Object.hasOwn(d3_symbols, `symbol${name}`);
 function name_for_symbol(sym) {
     for (const [key, symbol] of Object.entries(d3_symbols)) {
         if (symbol === sym && /^symbol[A-Z]/.test(key)) {
-            const name = key.substring(6);
+            const name = key.slice(6);
             if (is_d3_symbol_name(name))
                 return name;
         }
@@ -34,7 +34,7 @@ export function format_value(value, formatter) {
     if (Number.isNaN(value))
         return `NaN`;
     // Format and normalize unicode minus
-    const formatted = format(formatter)(value).replace(/−/g, `-`);
+    const formatted = format(formatter)(value).replaceAll('−', `-`);
     // Handle percentage formatting - remove trailing zeros
     if (formatter.includes(`%`)) {
         return formatted.includes(`.`)
@@ -157,9 +157,10 @@ export function parse_si_float(value) {
     if (typeof value !== `string`)
         return value;
     // Remove whitespace and commas
-    const cleaned = value.trim().replace(/(\d),(\d)/g, `$1$2`);
-    // Check if the value is a SI-formatted number (e.g. "1.23k", "4.56M", "789µ", "12n")
-    const match = /^([-+]?\d*\.?\d+)\s*([yzafpnµmkMGTPEZY])?$/i.exec(cleaned);
+    const cleaned = value.trim().replaceAll(/(\d),(\d)/g, `$1$2`);
+    // SI-formatted number (e.g. "1.23k", "789µ"). Suffixes are case-sensitive (m=milli vs
+    // M=mega), so no `i` flag: mismatched-case suffixes return the string as-is.
+    const match = /^([-+]?\d*\.?\d+)\s*([yzafpnµmkMGTPEZY])?$/.exec(cleaned);
     if (match) {
         const [, num_part, suffix] = match;
         let multiplier = 1;
@@ -167,7 +168,7 @@ export function parse_si_float(value) {
             const suffixes = `yzafpnµm kMGTPEZY`;
             const index = suffixes.indexOf(suffix);
             if (index !== -1) {
-                multiplier = Math.pow(1000, index - 8);
+                multiplier = 1000 ** (index - 8);
             }
         }
         return parseFloat(num_part) * multiplier;
@@ -232,7 +233,7 @@ export const SUBSCRIPT_MAP = {
     '9': `₉`,
 };
 // replaces all signs and digits with their unicode superscript equivalent
-export const superscript_digits = (input) => input.replace(/[\d+-]/g, (match) => is_superscript_key(match) ? SUPERSCRIPT_MAP[match] : match);
+export const superscript_digits = (input) => input.replaceAll(/[\d+-]/g, (match) => is_superscript_key(match) ? SUPERSCRIPT_MAP[match] : match);
 // Trajectory property configuration: clean labels and units as structured data
 export const trajectory_property_config = {
     // Energy properties