matterviz 0.4.1 → 0.4.3

package/dist/heatmap-matrix/HeatmapMatrix.svelte.d.ts

@@ -4,7 +4,7 @@ import type { AxisConfig } from '../plot';
 import { type ComponentProps, type Snippet } from 'svelte';
 import type { HTMLAttributes } from 'svelte/elements';
 import HeatmapMatrixControls from './HeatmapMatrixControls.svelte';
-import type { AxisItem, CellContext, DomainMode, HeatmapExportFormat, HeatmapTooltipProp, LegendPosition, NormalizeMode, SymmetricMode } from './index';
+import type { AxisItem, CellContext, DomainMode, HeatmapExportFormat, HeatmapTooltipProp, LegendPosition, MissingCellStyle, NormalizeMode, SymmetricMode } from './index';
 type CellValue = number | string | null;
 type SelectionMode = `single` | `multi` | `range`;
 type AxisOrderKey = `label` | `key` | `sort_value`;
@@ -20,7 +20,7 @@ type $$ComponentProps = Omit<HTMLAttributes<HTMLDivElement>, `onclick` | `ondblc
     color_scale?: D3InterpolateName | ((val: number) => string);
     color_scale_range?: [number | null, number | null];
     color_overrides?: Record<string, string>;
-    missing_color?: string;
+    missing?: MissingCellStyle;
     log?: boolean;
     value_transform?: (value: number, ctx: {
         x_item: AxisItem;

package/dist/heatmap-matrix/HeatmapMatrixControls.svelte

@@ -2,11 +2,15 @@
   import type { PaneProps, PaneToggleProps } from '../overlays'
   import DraggablePane from '../overlays/DraggablePane.svelte'
   import type { ComponentProps, Snippet } from 'svelte'
-  import {
-    ELEMENT_ORDERINGS,
-    ORDERING_LABELS,
+  import { ELEMENT_ORDERINGS, ORDERING_LABELS } from './index'
+  import type {
+    ElementAxisOrderingKey,
+    DomainMode,
+    HeatmapExportFormat,
+    LegendPosition,
+    NormalizeMode,
+    SymmetricMode,
   } from './index'
-  import type { ElementAxisOrderingKey, DomainMode, HeatmapExportFormat, LegendPosition, NormalizeMode, SymmetricMode } from './index'
 
   let {
     ordering = $bindable(`atomic_number`),
@@ -53,9 +57,7 @@
   } = $props()
 
   function merge_styles(base_style: string, override_style: unknown): string {
-    const override_style_str = typeof override_style === `string`
-      ? override_style
-      : ``
+    const override_style_str = typeof override_style === `string` ? override_style : ``
     return override_style_str ? `${base_style}; ${override_style_str}` : base_style
   }
 

package/dist/heatmap-matrix/HeatmapMatrixControls.svelte.d.ts

@@ -25,6 +25,6 @@ type $$ComponentProps = {
         controls_open: boolean;
     }]>;
 };
-declare const HeatmapMatrixControls: import("svelte").Component<$$ComponentProps, {}, "normalize" | "show_values" | "show_legend" | "controls_open" | "ordering" | "theme" | "toggle_visible" | "domain_mode" | "legend_position" | "search_query" | "symmetric" | "show_row_summaries" | "show_col_summaries">;
+declare const HeatmapMatrixControls: import("svelte").Component<$$ComponentProps, {}, "normalize" | "theme" | "show_values" | "show_legend" | "controls_open" | "ordering" | "symmetric" | "search_query" | "toggle_visible" | "domain_mode" | "legend_position" | "show_row_summaries" | "show_col_summaries">;
 type HeatmapMatrixControls = ReturnType<typeof HeatmapMatrixControls>;
 export default HeatmapMatrixControls;

package/dist/heatmap-matrix/index.d.ts

@@ -17,6 +17,11 @@ export type CellContext = {
     value: number | string | null;
     bg_color: string | null;
 };
+export interface MissingCellStyle {
+    color?: `element-category` | (string & {});
+    label?: string;
+    style?: string;
+}
 export declare const ORDERING_LABELS: {
     readonly atomic_number: "Atomic Number";
     readonly mendeleev_number: "Pettifor Chemical Similarity";

package/dist/icons.d.ts

@@ -540,6 +540,10 @@ export declare const ICON_DATA: {
         readonly viewBox: "0 0 24 24";
         readonly path: "<path fill=\"currentColor\" d=\"M20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2M4 4h5v16H4zm7 0h9v8h-9zm0 10h9v6h-9z\"/>";
     };
+    readonly Grid2x2: {
+        readonly viewBox: "0 0 24 24";
+        readonly path: "<path fill=\"currentColor\" d=\"M20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2M4 4h7v7H4zm0 9h7v7H4zm9-9h7v7h-7zm0 9h7v7h-7z\"/>";
+    };
     readonly FermiSurface: {
         readonly viewBox: "0 0 24 24";
         readonly stroke: "currentColor";

package/dist/icons.js

@@ -620,6 +620,10 @@ export const ICON_DATA = {
         viewBox: `0 0 24 24`,
         path: `<path fill="currentColor" d="M20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2M4 4h5v16H4zm7 0h9v8h-9zm0 10h9v6h-9z"/>`,
     },
+    Grid2x2: {
+        viewBox: `0 0 24 24`,
+        path: `<path fill="currentColor" d="M20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2M4 4h7v7H4zm0 9h7v7H4zm9-9h7v7h-7zm0 9h7v7h-7z"/>`,
+    },
     FermiSurface: {
         viewBox: `0 0 24 24`,
         stroke: `currentColor`,

package/dist/index.d.ts

@@ -16,8 +16,8 @@ export { default as Icon } from './Icon.svelte';
 export * from './icons';
 export * from './io';
 export { default as MillerIndexInput } from './MillerIndexInput.svelte';
-export { auto_isosurface_settings, DEFAULT_ISOSURFACE_SETTINGS, generate_layers, grid_data_range, Isosurface as VolumetricIsosurface, IsosurfaceControls, LAYER_COLORS, parse_chgcar, parse_cube, parse_volumetric_file, sample_hkl_slice, tile_volumetric_data, trilinear_interpolate, } from './isosurface';
-export type { DataRange, IsosurfaceLayer, IsosurfaceSettings, SliceResult, VolumetricData, VolumetricFileData, } from './isosurface';
+export { auto_color_config, auto_isosurface_settings, auto_volume_layer, compare_volume_grids, compute_scalar_range, create_volume_sampler, DEFAULT_ISO_COLORMAP, DEFAULT_ISOSURFACE_SETTINGS, extract_volume_range, generate_layers, grid_data_range, is_signed_range, ISO_COLORMAPS, Isosurface as VolumetricIsosurface, IsosurfaceControls, label_file_volumes, lattices_match, LAYER_COLORS, materialize_layers, merge_imported_volumes, parse_chgcar, parse_cube, parse_volumetric_file, remove_volume, resolve_contour_thresholds, resolve_slice_color_range, resolve_volume_display_range, sample_hkl_slice, sample_plane_slice, sample_volume_at_positions, sanitize_display_range, scalars_to_vertex_colors, slice_to_rgba, tile_volumetric_data, trilinear_interpolate, VolumeSlice, } from './isosurface';
+export type { CartesianPlane, DataRange, DisplayRange, GridCompatibility, IsoColormap, IsosurfaceLayer, IsosurfaceSettings, OutOfBoundsPolicy, PlaneSliceOptions, SliceResult, VolumeSliceMode, VolumeMergeResult, VolumeDisplayRangeOptions, VolumeSamplerOptions, VolumetricData, VolumetricFileData, } from './isosurface';
 export * from './labels';
 export * from './layout';
 export * from './math';

package/dist/index.js

@@ -17,7 +17,7 @@ export * from './icons';
 export * from './io';
 export { default as MillerIndexInput } from './MillerIndexInput.svelte';
 // Explicit exports to avoid name clash with fermi-surface's Isosurface type
-export { auto_isosurface_settings, DEFAULT_ISOSURFACE_SETTINGS, generate_layers, grid_data_range, Isosurface as VolumetricIsosurface, IsosurfaceControls, LAYER_COLORS, parse_chgcar, parse_cube, parse_volumetric_file, sample_hkl_slice, tile_volumetric_data, trilinear_interpolate, } from './isosurface';
+export { auto_color_config, auto_isosurface_settings, auto_volume_layer, compare_volume_grids, compute_scalar_range, create_volume_sampler, DEFAULT_ISO_COLORMAP, DEFAULT_ISOSURFACE_SETTINGS, extract_volume_range, generate_layers, grid_data_range, is_signed_range, ISO_COLORMAPS, Isosurface as VolumetricIsosurface, IsosurfaceControls, label_file_volumes, lattices_match, LAYER_COLORS, materialize_layers, merge_imported_volumes, parse_chgcar, parse_cube, parse_volumetric_file, remove_volume, resolve_contour_thresholds, resolve_slice_color_range, resolve_volume_display_range, sample_hkl_slice, sample_plane_slice, sample_volume_at_positions, sanitize_display_range, scalars_to_vertex_colors, slice_to_rgba, tile_volumetric_data, trilinear_interpolate, VolumeSlice, } from './isosurface';
 export * from './labels';
 export * from './layout';
 export * from './math';

package/dist/io/ExportPane.svelte

@@ -3,7 +3,7 @@
   import type { ExportItem, ExportSection } from './types'
   import DraggablePane from '../overlays/DraggablePane.svelte'
   import { sanitize_html } from '../sanitize'
-  import { type ComponentProps, onDestroy, type Snippet } from 'svelte'
+  import { onDestroy, type Snippet } from 'svelte'
   import { tooltip } from 'svelte-multiselect/attachments'
   import type { HTMLAttributes } from 'svelte/elements'
 
@@ -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,14 @@
 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 type BrowserCompressionFormat = Exclude<CompressionFormat, `zip` | `xz` | `bz2`>;
+export declare const is_browser_decompressible_format: (format: CompressionFormat | null) => format is BrowserCompressionFormat;
 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,14 @@
 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 const is_browser_decompressible_format = (format) => format !== null && format !== `zip` && format !== `xz` && format !== `bz2`;
 export function detect_compression_format(filename) {
     const lower = filename.toLowerCase();
     for (const [format, extensions] of Object.entries(COMPRESSION_FORMATS)) {
@@ -16,7 +25,7 @@ export async function decompress_data(data, format) {
 // Decompress data and return as ArrayBuffer (for binary files like .brml.gz)
 export async function decompress_data_binary(data, format) {
     try {
-        if (format === `zip` || format === `xz` || format === `bz2`) {
+        if (!is_browser_decompressible_format(format)) {
             throw new Error(`${format.toUpperCase()} decompression is not supported in the browser. ` +
                 `Please extract the ${format.toUpperCase()} file first.`);
         }
@@ -37,39 +46,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 = is_browser_decompressible_format(format) ? 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,13 +1,20 @@
 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;
-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 interface SvgExportOptions {
+    viewbox_padding?: number | `stroke`;
+}
+export declare function svg_to_svg_string(svg_element: SVGElement, inline_styles?: readonly string[], options?: SvgExportOptions): string;
+export declare function export_svg_as_svg(svg_element: SVGElement | null, filename: string, inline_styles?: readonly string[], options?: SvgExportOptions): void;
+export declare function svg_to_png_blob(svg_element: SVGElement, png_dpi?: number, inline_styles?: readonly string[], options?: SvgExportOptions): Promise<Blob>;
+export declare function export_svg_as_png(svg_element: SVGElement | null, filename: string, png_dpi?: number, inline_styles?: readonly string[], options?: SvgExportOptions): void;
 export declare function observe_canvas_presence(wrapper: HTMLElement | undefined, set: (has_canvas: boolean) => void): (() => void) | undefined;
 export declare const estimate_video_bitrate: (pixel_count: number, fps: number) => number;
 export declare function get_ffmpeg_conversion_command(input_filename: string): string;

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);
@@ -90,6 +94,54 @@ function set_svg_font_family(svg) {
     // Also set as attribute for extra robustness
     svg.setAttribute(`font-family`, `sans-serif`);
 }
+function svg_viewbox(svg, padding = 0) {
+    const parts = svg
+        .getAttribute(`viewBox`)
+        ?.trim()
+        .split(/[\s,]+/)
+        .map(Number);
+    if (parts?.length !== 4 || !parts.every(Number.isFinite))
+        return null;
+    const [x, y, width, height] = parts;
+    if (width <= 0 || height <= 0)
+        return null;
+    const padded = [
+        x - padding,
+        y - padding,
+        width + 2 * padding,
+        height + 2 * padding,
+    ];
+    return padded.every(Number.isFinite) && padded[2] > 0 && padded[3] > 0 ? padded : null;
+}
+function resolve_viewbox_padding(svg, options) {
+    if (options.viewbox_padding !== `stroke`) {
+        return Number.isFinite(options.viewbox_padding)
+            ? Math.max(0, options.viewbox_padding ?? 0)
+            : 0;
+    }
+    let max_stroke_width = 0;
+    for (const element of [svg, ...svg.querySelectorAll(`*`)]) {
+        const computed = getComputedStyle(element);
+        const inline_style = element.style;
+        const stroke = [
+            inline_style.stroke,
+            computed.getPropertyValue(`stroke`),
+            element.getAttribute(`stroke`),
+        ].find(Boolean) ?? ``;
+        if (!stroke || stroke === `none` || stroke === `transparent`)
+            continue;
+        // oxlint-disable-next-line unicorn/prefer-number-coercion -- CSS lengths include units
+        const stroke_width = Number.parseFloat([
+            inline_style.strokeWidth,
+            computed.getPropertyValue(`stroke-width`),
+            element.getAttribute(`stroke-width`),
+        ].find(Boolean) ?? ``);
+        if (Number.isFinite(stroke_width)) {
+            max_stroke_width = Math.max(max_stroke_width, stroke_width);
+        }
+    }
+    return max_stroke_width / 2;
+}
 // 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) {
@@ -106,10 +158,17 @@ function inline_computed_styles(live, clone, properties) {
 }
 // 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 = []) {
+function serialize_svg_for_export(svg_element, inline_styles = [], viewbox_padding = 0, strip_dimensions = false) {
     const clone = svg_element.cloneNode(true);
     if (inline_styles.length)
         inline_computed_styles(svg_element, clone, inline_styles);
+    const padded_viewbox = viewbox_padding > 0 ? svg_viewbox(clone, viewbox_padding) : null;
+    if (padded_viewbox)
+        clone.setAttribute(`viewBox`, padded_viewbox.join(` `));
+    if (strip_dimensions) {
+        clone.removeAttribute(`width`);
+        clone.removeAttribute(`height`);
+    }
     set_svg_font_family(clone);
     if (!clone.hasAttribute(`xmlns`)) {
         clone.setAttribute(`xmlns`, `http://www.w3.org/2000/svg`);
@@ -121,18 +180,19 @@ function serialize_svg_for_export(svg_element, inline_styles = []) {
 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);
+inline_styles = [], options = {}) {
+    const viewbox_padding = resolve_viewbox_padding(svg_element, options);
+    const svg_string = serialize_svg_for_export(svg_element, inline_styles, viewbox_padding);
     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, inline_styles = []) {
+export function export_svg_as_svg(svg_element, filename, inline_styles = [], options = {}) {
     if (!svg_element) {
         console.warn(`SVG element not found for export`);
         return;
     }
     try {
-        const svg_content = svg_to_svg_string(svg_element, inline_styles);
+        const svg_content = svg_to_svg_string(svg_element, inline_styles, options);
         download(svg_content, filename, `image/svg+xml;charset=utf-8`);
     }
     catch (error) {
@@ -144,18 +204,14 @@ export function export_svg_as_svg(svg_element, filename, inline_styles = []) {
 // 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, inline_styles = []) {
-    const viewBox = svg_element.getAttribute(`viewBox`)?.trim();
-    if (!viewBox)
+export function svg_to_png_blob(svg_element, png_dpi = 150, inline_styles = [], options = {}) {
+    if (!svg_element.getAttribute(`viewBox`)?.trim())
         return Promise.reject(new Error(`SVG viewBox not found for PNG export`));
-    const parts = viewBox.split(/[\s,]+/).map(Number);
-    if (parts.length < 4 || !parts.every(Number.isFinite)) {
-        return Promise.reject(new Error(`Invalid SVG dimensions for PNG export`));
-    }
-    const [, , width, height] = parts;
-    if (!(width > 0) || !(height > 0)) {
+    const padding = resolve_viewbox_padding(svg_element, options);
+    const padded_viewbox = svg_viewbox(svg_element, padding);
+    if (!padded_viewbox)
         return Promise.reject(new Error(`Invalid SVG dimensions for PNG export`));
-    }
+    const [, , width, height] = padded_viewbox;
     if (!Number.isFinite(png_dpi) || png_dpi <= 0) {
         return Promise.reject(new Error(`Invalid PNG DPI for export`));
     }
@@ -169,7 +225,7 @@ export function svg_to_png_blob(svg_element, png_dpi = 150, inline_styles = [])
         return Promise.reject(new Error(`Canvas 2D context not available`));
     canvas.width = pixel_width;
     canvas.height = pixel_height;
-    const serialized = serialize_svg_for_export(svg_element, inline_styles);
+    const serialized = serialize_svg_for_export(svg_element, inline_styles, padding, padding > 0);
     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) => {
@@ -200,12 +256,12 @@ export function svg_to_png_blob(svg_element, png_dpi = 150, inline_styles = [])
     });
 }
 // Export SVG element as PNG (triggers browser download)
-export function export_svg_as_png(svg_element, filename, png_dpi = 150, inline_styles = []) {
+export function export_svg_as_png(svg_element, filename, png_dpi = 150, inline_styles = [], options = {}) {
     if (!svg_element) {
         console.warn(`SVG element not found for PNG export`);
         return;
     }
-    svg_to_png_blob(svg_element, png_dpi, inline_styles)
+    svg_to_png_blob(svg_element, png_dpi, inline_styles, options)
         .then((blob) => download(blob, filename, `image/png`))
         .catch((error) => console.error(`Error exporting PNG:`, error));
 }
@@ -303,7 +359,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/file-drop.js

@@ -1,6 +1,6 @@
 // Shared file-drop handler composable for drag-and-drop file loading.
 import { decompress_file } from './decompress';
-import { handle_url_drop } from './url-drop';
+import { dropped_file_url, load_from_url } from './url-drop';
 import { to_error } from '../utils';
 // Drag-over visual-state handlers for file-drop zones; spread onto the drop target
 // alongside `ondrop` from create_file_drop_handler
@@ -16,40 +16,65 @@ export const drag_over_handlers = (opts) => ({
     ondragleave: () => opts.set_dragover(false),
 });
 // Handles URL drops (from FilePicker), direct file drops with decompression,
-// loading state, and error reporting.
-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;
+// loading state, and error reporting. Multiple dropped files are processed
+// sequentially in drop order so e.g. several cube files can be imported at once.
+// Overlapping drops are queued: a batch starting while a previous one is still
+// processing would interleave on_drop state mutations (e.g. torn volume lists).
+export const create_file_drop_handler = (opts) => {
+    async function process_batch(url, files) {
+        opts.set_loading?.(true);
+        try {
+            // One failing item must not abort the rest of the batch
+            const failures = [];
+            if (url) {
+                try {
+                    await load_from_url(url, opts.on_drop);
+                }
+                catch (exc) {
+                    // URL failed; if plain files were also dropped, still process them
+                    // and fold the URL failure into the aggregate report
+                    if (files.length === 0) {
+                        opts.on_error?.(`Failed to load from URL: ${to_error(exc).message}`);
+                        return;
+                    }
+                    failures.push(`URL ${url}: ${to_error(exc).message}`);
+                }
+            }
+            if (files.length === 0)
+                return;
+            for (const file of files) {
+                try {
+                    const { content, filename } = await decompress_file(file);
+                    if (content)
+                        await opts.on_drop(content, filename);
+                    else
+                        failures.push(`${file.name}: file is empty`);
+                }
+                catch (exc) {
+                    failures.push(`${file.name}: ${to_error(exc).message}`);
+                }
+            }
+            if (failures.length > 0) {
+                opts.on_error?.(`Failed to load ${failures.length} file${failures.length > 1 ? `s` : ``} — ${failures.join(`; `)}`);
+            }
+        }
+        catch (exc) {
+            opts.on_error?.(`Failed to load file: ${to_error(exc).message}`);
+        }
+        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);
     }
+    let queue = Promise.resolve();
+    return (event) => {
+        event.preventDefault();
+        if (!opts.allow())
+            return Promise.resolve();
+        // DataTransfer contents are only readable during drop-event dispatch, so
+        // capture them before deferring to the queue
+        const url = dropped_file_url(event);
+        const files = Array.from(event.dataTransfer?.files ?? []);
+        queue = queue.then(() => process_batch(url, files)).catch(() => undefined);
+        return queue;
+    };
 };

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;