matterviz 0.3.7 → 0.4.1

package/dist/heatmap-matrix/HeatmapMatrix.svelte

@@ -1,11 +1,11 @@
 <script lang="ts">
   import type { D3InterpolateName } from '../colors'
-  import { is_color, pick_contrast_color } from '../colors'
+  import { get_d3_interpolator, is_color, pick_contrast_color } from '../colors'
   import { format_num } from '../labels'
+  import type { Vec2 } from '../math'
   import type { AxisConfig } from '../plot'
-  import ColorBar from '../plot/ColorBar.svelte'
-  import { make_change_detector } from '../utils'
-  import * as d3_sc from 'd3-scale-chromatic'
+  import ColorBar from '../plot/core/components/ColorBar.svelte'
+  import { quickselect } from '../plot/box/quantile'
   import { type ComponentProps, onDestroy, onMount, type Snippet } from 'svelte'
   import type { HTMLAttributes } from 'svelte/elements'
   import { SvelteMap, SvelteSet } from 'svelte/reactivity'
@@ -127,7 +127,7 @@
     ) => number | null
     normalize?: NormalizeMode
     domain_mode?: DomainMode
-    quantile_clip?: [number, number]
+    quantile_clip?: Vec2
     show_legend?: boolean
     legend_position?: LegendPosition
     legend_label?: string
@@ -146,8 +146,8 @@
     oncontextmenu?: (cell: CellContext, event: MouseEvent) => void
     enable_brush?: boolean
     onbrush?: (payload: {
-      x_range: [number, number]
-      y_range: [number, number]
+      x_range: Vec2
+      y_range: Vec2
       cells: CellContext[]
     }) => void
     tile_size?: string
@@ -213,7 +213,6 @@
   // === Value resolution ===
   let x_keys = $derived(x_items.map((item) => item.key ?? item.label))
   let y_keys = $derived(y_items.map((item) => item.key ?? item.label))
-  let interaction_axis_signature = $derived(JSON.stringify([x_keys, y_keys]))
   let highlight_x_key_set = $derived(new SvelteSet(highlight_x_keys))
   let highlight_y_key_set = $derived(new SvelteSet(highlight_y_keys))
   let search_query_norm = $derived(search_query.trim().toLowerCase())
@@ -290,11 +289,23 @@
 
     const col_has_data = Array(x_items.length).fill(false)
     const row_has_data = Array(y_items.length).fill(false)
+    // Early-exit: skip cells whose row+col are already non-empty, stop once all resolved (dense matrices touch ~n+m cells, not n*m)
+    let unknown_cols = x_items.length
+    let unknown_rows = y_items.length
     for (let y_idx = 0; y_idx < y_items.length; y_idx++) {
+      if (unknown_cols === 0 && unknown_rows === 0) break
       for (let x_idx = 0; x_idx < x_items.length; x_idx++) {
-        if (get_value(x_idx, y_idx) !== null) {
+        if (row_has_data[y_idx] && col_has_data[x_idx]) continue
+        // ignore cells hidden by symmetric rendering so emptiness reflects only visible cells
+        if (is_hidden_cell(x_idx, y_idx)) continue
+        if (get_value(x_idx, y_idx) === null) continue
+        if (!col_has_data[x_idx]) {
           col_has_data[x_idx] = true
+          unknown_cols--
+        }
+        if (!row_has_data[y_idx]) {
           row_has_data[y_idx] = true
+          unknown_rows--
         }
       }
     }
@@ -313,11 +324,9 @@
   })
 
   // === Color computation ===
-  let color_scale_fn = $derived.by(() => {
-    if (typeof color_scale === `function`) return color_scale
-    const named_scale = d3_sc[color_scale]
-    return typeof named_scale === `function` ? named_scale : d3_sc.interpolateViridis
-  })
+  let color_scale_fn = $derived(
+    typeof color_scale === `function` ? color_scale : get_d3_interpolator(color_scale),
+  )
 
   function get_transformed_value(x_idx: number, y_idx: number): number | null {
     const raw_value = get_value(x_idx, y_idx)
@@ -333,49 +342,53 @@
     return transformed_value
   }
 
-  function get_quantile(sorted_values: number[], quantile: number): number {
-    if (!sorted_values.length) return 0
+  // Interpolated quantile via quickselect (O(n) avg vs full sort); reorders `scratch_values` in place so callers must pass a copy they own
+  function get_quantile(scratch_values: number[], quantile: number): number {
+    if (scratch_values.length === 0) return 0
     const clipped_quantile = Math.max(0, Math.min(1, quantile))
-    const float_idx = (sorted_values.length - 1) * clipped_quantile
+    const float_idx = (scratch_values.length - 1) * clipped_quantile
     const low_idx = Math.floor(float_idx)
     const high_idx = Math.ceil(float_idx)
-    if (low_idx === high_idx) return sorted_values[low_idx]
+    const low_val = quickselect(scratch_values, low_idx)
+    if (low_idx === high_idx) return low_val
+    const high_val = quickselect(scratch_values, high_idx)
     const low_weight = high_idx - float_idx
     const high_weight = float_idx - low_idx
-    return sorted_values[low_idx] * low_weight + sorted_values[high_idx] * high_weight
+    return low_val * low_weight + high_val * high_weight
   }
 
-  let valid_numeric_values = $derived.by(() => {
+  // Single pass collecting transformed values + min/max (avoids spreading large arrays into
+  // Math.min/max). min_pos is the log-mode lower bound when domain min <= 0 (the old
+  // Number.MIN_VALUE floor gave log_min ~ -744, squashing all colors to the top)
+  let { valid_numeric_values, auto_min, auto_max, min_pos } = $derived.by(() => {
     const numeric_values: number[] = []
+    let [min, max, pos] = [Infinity, -Infinity, Infinity]
     for (let y_idx = 0; y_idx < y_items.length; y_idx++) {
       for (let x_idx = 0; x_idx < x_items.length; x_idx++) {
         if (is_hidden_cell(x_idx, y_idx)) continue
         const value = get_transformed_value(x_idx, y_idx)
         if (value === null) continue
         numeric_values.push(value)
+        if (value < min) min = value
+        if (value > max) max = value
+        if (value > 0 && value < pos) pos = value
       }
     }
-    return numeric_values
-  })
-
-  // Single-pass min/max to avoid spreading large arrays into Math.min/max
-  let [auto_min, auto_max] = $derived.by(() => {
-    let [min, max] = [Infinity, -Infinity]
-    for (const value of valid_numeric_values) {
-      if (value < min) min = value
-      if (value > max) max = value
+    return {
+      valid_numeric_values: numeric_values,
+      auto_min: min <= max ? min : 0,
+      auto_max: min <= max ? max : 1,
+      min_pos: Number.isFinite(pos) ? pos : null,
     }
-    return min <= max ? [min, max] as const : [0, 1] as const
   })
 
+  // Lazy derived: only evaluated while domain_mode === 'robust' reads it
   let [robust_min, robust_max] = $derived.by(() => {
-    if (!valid_numeric_values.length) return [0, 1] as const
-    const sorted_values = valid_numeric_values.toSorted((value_a, value_b) =>
-      value_a - value_b
-    )
+    if (valid_numeric_values.length === 0) return [0, 1] as const
+    const scratch = [...valid_numeric_values]
     const [q_low, q_high] = quantile_clip
-    const clipped_min = get_quantile(sorted_values, q_low)
-    const clipped_max = get_quantile(sorted_values, q_high)
+    const clipped_min = get_quantile(scratch, q_low)
+    const clipped_max = get_quantile(scratch, q_high)
     return clipped_min <= clipped_max
       ? [clipped_min, clipped_max] as const
       : [clipped_max, clipped_min] as const
@@ -418,7 +431,7 @@
       const lower_bound = Math.min(cs_min, cs_max)
       const upper_bound = Math.max(cs_min, cs_max)
       if (upper_bound <= 0) return missing_color || null
-      const safe_lower_bound = Math.max(lower_bound, Number.MIN_VALUE)
+      const safe_lower_bound = lower_bound > 0 ? lower_bound : (min_pos ?? upper_bound)
       const safe_value = Math.max(val, safe_lower_bound)
       const log_min = Math.log(safe_lower_bound)
       const log_max = Math.log(upper_bound)
@@ -460,7 +473,7 @@
     return colors
   })
 
-  const to_contrast_colors = (bg_values: Array<string | null>): Array<string | null> =>
+  const to_contrast_colors = (bg_values: (string | null)[]): (string | null)[] =>
     bg_values.map((bg_color) =>
       bg_color ? pick_contrast_color({ bg_color }) : null
     )
@@ -481,16 +494,14 @@
     bg_flat[get_flat_idx(x_idx, y_idx)]
 
   // === Cell context builder (only called for clicks, not per-hover) ===
-  function build_cell_context(x_idx: number, y_idx: number): CellContext {
-    return {
-      x_item: x_items[x_idx],
-      y_item: y_items[y_idx],
-      x_idx,
-      y_idx,
-      value: get_value(x_idx, y_idx),
-      bg_color: get_bg(x_idx, y_idx),
-    }
-  }
+  const build_cell_context = (x_idx: number, y_idx: number): CellContext => ({
+    x_item: x_items[x_idx],
+    y_item: y_items[y_idx],
+    x_idx,
+    y_idx,
+    value: get_value(x_idx, y_idx),
+    bg_color: get_bg(x_idx, y_idx),
+  })
 
   // === Fully imperative hover management ===
   // ZERO $state writes during mouseover — all DOM updates are direct.
@@ -777,7 +788,7 @@
       cell_pos_key(pos.x_idx, pos.y_idx) === clicked_key
     )
     const toggle_mode = selection_mode === `multi` && (event.metaKey || event.ctrlKey)
-    if (existing_idx >= 0 && toggle_mode) next_cells.splice(existing_idx, 1)
+    if (existing_idx !== -1 && toggle_mode) next_cells.splice(existing_idx, 1)
     else if (selection_mode === `multi` && toggle_mode) next_cells.push(clicked_cell)
     else next_cells.splice(0, next_cells.length, clicked_cell)
     selected_cells = next_cells
@@ -1012,7 +1023,7 @@
   }
 
   function compute_summary(summary_values: number[]): number | null {
-    if (!summary_values.length) return null
+    if (summary_values.length === 0) return null
     if (summary_fn) return summary_fn(summary_values)
     const total = summary_values.reduce((sum, value) => sum + value, 0)
     return total / summary_values.length
@@ -1087,9 +1098,15 @@
 
   // Tooltip state: only used for custom tooltip snippets (function tooltips)
   let tooltip_cell: CellContext | null = $state(null)
-  const axis_changed = make_change_detector()
+  // Reset interactions when axis keys change; element-wise compare beats JSON.stringify-ing every key on each x_items/y_items update
+  const keys_equal = (keys_a: string[], keys_b: string[]): boolean =>
+    keys_a.length === keys_b.length && keys_a.every((key, idx) => key === keys_b[idx])
+  let prev_axis_keys: { x: string[]; y: string[] } | null = null
   $effect(() => {
-    if (!axis_changed(interaction_axis_signature)) return
+    const changed = prev_axis_keys !== null &&
+      !(keys_equal(x_keys, prev_axis_keys.x) && keys_equal(y_keys, prev_axis_keys.y))
+    prev_axis_keys = { x: x_keys, y: y_keys }
+    if (!changed) return
     cancel_raf(active_cell_raf)
     // Cancel delayed clicks before old cell coordinates can fire on new axes.
     clear_pending_click()

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

@@ -1,4 +1,5 @@
 import type { D3InterpolateName } from '../colors';
+import type { Vec2 } from '../math';
 import type { AxisConfig } from '../plot';
 import { type ComponentProps, type Snippet } from 'svelte';
 import type { HTMLAttributes } from 'svelte/elements';
@@ -29,7 +30,7 @@ type $$ComponentProps = Omit<HTMLAttributes<HTMLDivElement>, `onclick` | `ondblc
     }) => number | null;
     normalize?: NormalizeMode;
     domain_mode?: DomainMode;
-    quantile_clip?: [number, number];
+    quantile_clip?: Vec2;
     show_legend?: boolean;
     legend_position?: LegendPosition;
     legend_label?: string;
@@ -51,8 +52,8 @@ type $$ComponentProps = Omit<HTMLAttributes<HTMLDivElement>, `onclick` | `ondblc
     oncontextmenu?: (cell: CellContext, event: MouseEvent) => void;
     enable_brush?: boolean;
     onbrush?: (payload: {
-        x_range: [number, number];
-        y_range: [number, number];
+        x_range: Vec2;
+        y_range: Vec2;
         cells: CellContext[];
     }) => void;
     tile_size?: string;

package/dist/heatmap-matrix/HeatmapMatrixControls.svelte

@@ -1,4 +1,5 @@
 <script lang="ts">
+  import type { PaneProps, PaneToggleProps } from '../overlays'
   import DraggablePane from '../overlays/DraggablePane.svelte'
   import type { ComponentProps, Snippet } from 'svelte'
   import {
@@ -46,8 +47,8 @@
     export_formats?: HeatmapExportFormat[]
     onexport?: (format: HeatmapExportFormat) => void
     show_pane?: boolean
-    pane_props?: ComponentProps<typeof DraggablePane>[`pane_props`]
-    toggle_props?: ComponentProps<typeof DraggablePane>[`toggle_props`]
+    pane_props?: PaneProps
+    toggle_props?: PaneToggleProps
     children?: Snippet<[{ controls_open: boolean }]>
   } = $props()
 

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

@@ -1,5 +1,5 @@
-import DraggablePane from '../overlays/DraggablePane.svelte';
-import type { ComponentProps, Snippet } from 'svelte';
+import type { PaneProps, PaneToggleProps } from '../overlays';
+import type { Snippet } from 'svelte';
 import type { ElementAxisOrderingKey, DomainMode, HeatmapExportFormat, LegendPosition, NormalizeMode, SymmetricMode } from './index';
 type $$ComponentProps = {
     ordering?: ElementAxisOrderingKey;
@@ -19,12 +19,12 @@ type $$ComponentProps = {
     export_formats?: HeatmapExportFormat[];
     onexport?: (format: HeatmapExportFormat) => void;
     show_pane?: boolean;
-    pane_props?: ComponentProps<typeof DraggablePane>[`pane_props`];
-    toggle_props?: ComponentProps<typeof DraggablePane>[`toggle_props`];
+    pane_props?: PaneProps;
+    toggle_props?: PaneToggleProps;
     children?: Snippet<[{
         controls_open: boolean;
     }]>;
 };
-declare const HeatmapMatrixControls: import("svelte").Component<$$ComponentProps, {}, "normalize" | "theme" | "show_legend" | "controls_open" | "show_values" | "ordering" | "toggle_visible" | "domain_mode" | "legend_position" | "search_query" | "symmetric" | "show_row_summaries" | "show_col_summaries">;
+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">;
 type HeatmapMatrixControls = ReturnType<typeof HeatmapMatrixControls>;
 export default HeatmapMatrixControls;

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

@@ -1,4 +1,5 @@
 import type { ChemicalElement, ElementSymbol } from '../element';
+import type { Vec2 } from '../math';
 import type { Snippet } from 'svelte';
 export { COLOR_OVERRIDE_KEY_SEPARATOR, make_color_override_key } from './shared';
 export type AxisItem<T = Record<string, unknown>> = {
@@ -41,8 +42,8 @@ export type HeatmapSelection = {
 };
 export type HeatmapExportFormat = `csv` | `json`;
 export type HeatmapBrushPayload = {
-    x_range: [number, number];
-    y_range: [number, number];
+    x_range: Vec2;
+    y_range: Vec2;
     cells: CellContext[];
 };
 export declare const ELEMENT_ORDERINGS: ElementAxisOrderingKey[];

package/dist/heatmap-matrix/index.js

@@ -40,7 +40,7 @@ function escape_csv_field(value) {
     return `"${field.replaceAll(`"`, `""`)}"`;
 }
 export function rows_to_csv(rows) {
-    if (!rows.length)
+    if (rows.length === 0)
         return ``;
     const headers = Object.keys(rows[0]);
     const lines = [

package/dist/index.d.ts

@@ -27,6 +27,7 @@ export * from './phase-diagram';
 export * from './plot';
 export * from './rdf';
 export * from './sanitize';
+export * from './scene';
 export * from './settings';
 export * from './spectral';
 export * from './structure';

package/dist/index.js

@@ -27,6 +27,7 @@ export * from './phase-diagram';
 export * from './plot';
 export * from './rdf';
 export * from './sanitize';
+export * from './scene';
 export * from './settings';
 export * from './spectral';
 export * from './structure';

package/dist/io/ExportPane.svelte

@@ -0,0 +1,166 @@
+<script lang="ts">
+  import type { PaneProps, PaneToggleProps } from '../overlays'
+  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 { tooltip } from 'svelte-multiselect/attachments'
+  import type { HTMLAttributes } from 'svelte/elements'
+
+  let {
+    export_pane_open = $bindable(false),
+    sections = [],
+    png_dpi = $bindable(150),
+    dpi_range = [50, 600],
+    icon_style = ``,
+    toggle_props = {},
+    pane_props = {},
+    children = undefined,
+    ...rest
+  }: HTMLAttributes<HTMLDivElement> & {
+    export_pane_open?: boolean
+    sections?: ExportSection[]
+    png_dpi?: number
+    dpi_range?: readonly [number, number]
+    icon_style?: string
+    toggle_props?: PaneToggleProps
+    pane_props?: PaneProps
+    // Pane-specific extras rendered below the sections (e.g. video export controls)
+    children?: Snippet
+  } = $props()
+
+  // Clamp DPI into dpi_range on input change (fires on blur, before any download click)
+  function clamp_dpi(): void {
+    const [min_dpi, max_dpi] = dpi_range
+    if (typeof png_dpi !== `number` || !Number.isFinite(png_dpi)) png_dpi = 150
+    else png_dpi = Math.round(Math.min(max_dpi, Math.max(min_dpi, png_dpi)))
+  }
+
+  // Copy-to-clipboard with temporary ✅ feedback; copy_text runs only on click
+  let copied_key = $state<string | null>(null)
+  let copied_timeout: ReturnType<typeof setTimeout> | undefined
+  async function handle_copy(item: ExportItem, key: string): Promise<void> {
+    if (item.disabled) return
+    const text = item.copy_text?.()
+    if (!text) return
+    try {
+      await navigator.clipboard.writeText(text)
+      copied_key = key
+      clearTimeout(copied_timeout)
+      copied_timeout = setTimeout(() => (copied_key = null), 1000)
+    } catch (error) {
+      console.error(`Failed to copy ${item.label} to clipboard`, error)
+    }
+  }
+  onDestroy(() => clearTimeout(copied_timeout))
+</script>
+
+<DraggablePane
+  bind:show={export_pane_open}
+  open_icon="Cross"
+  closed_icon="Export"
+  {icon_style}
+  pane_props={{
+    ...rest,
+    ...pane_props,
+    class: `export-pane ${rest.class ?? ``} ${pane_props?.class ?? ``}`.trim(),
+  }}
+  {toggle_props}
+>
+  {#each sections as section, sec_idx (section.title ?? sec_idx)}
+    {#if section.title}
+      <h4
+        {@attach section.tooltip
+          ? tooltip({ allow_html: true, content: sanitize_html(section.tooltip) })
+          : () => {}}
+      >{section.title}</h4>
+    {/if}
+    <div class="export-grid">
+      {#each section.items as item, item_idx (item.label)}
+        {@const copy_key = `${sec_idx}-${item_idx}`}
+        <!-- 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>
+          {:else}
+            {item.label}
+          {/if}
+          {#if item.on_download}
+            <button
+              type="button"
+              onclick={item.on_download}
+              disabled={item.disabled ?? false}
+              aria-label={`Download ${item.label}`}
+              title={`Download ${item.label}${item.show_dpi ? ` (${png_dpi} DPI)` : ``}`}
+            >
+              ⬇
+            </button>
+          {/if}
+          {#if item.copy_text}
+            <button
+              type="button"
+              onclick={() => handle_copy(item, copy_key)}
+              disabled={item.disabled ?? false}
+              aria-label="Copy {item.label} to clipboard"
+              title="Copy {item.label} to clipboard"
+            >
+              {copied_key === copy_key ? `✅` : `📋`}
+            </button>
+          {/if}
+          {#if item.show_dpi}
+            <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>
+          {/if}
+        </span>
+      {/each}
+    </div>
+  {/each}
+  {@render children?.()}
+</DraggablePane>
+
+<style>
+  h4 {
+    display: flex;
+    align-items: center;
+    margin: 0;
+  }
+  .export-grid {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 4pt 10pt;
+    font-size: 0.95em;
+  }
+  .export-item {
+    display: flex;
+    align-items: center;
+    gap: 4pt;
+    white-space: nowrap;
+  }
+  .export-grid button {
+    min-width: 1.9em;
+    height: 1.6em;
+    padding: 0 4pt;
+    box-sizing: border-box;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+  }
+  .export-grid input[type='number'] {
+    width: 3.5em;
+  }
+  .dpi-input {
+    display: inline-flex;
+    align-items: center;
+    gap: 2pt;
+    white-space: nowrap;
+  }
+</style>

package/dist/io/ExportPane.svelte.d.ts

@@ -0,0 +1,17 @@
+import type { PaneProps, PaneToggleProps } from '../overlays';
+import type { ExportSection } from './types';
+import { type Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
+    export_pane_open?: boolean;
+    sections?: ExportSection[];
+    png_dpi?: number;
+    dpi_range?: readonly [number, number];
+    icon_style?: string;
+    toggle_props?: PaneToggleProps;
+    pane_props?: PaneProps;
+    children?: Snippet;
+};
+declare const ExportPane: import("svelte").Component<$$ComponentProps, {}, "export_pane_open" | "png_dpi">;
+type ExportPane = ReturnType<typeof ExportPane>;
+export default ExportPane;

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)) {
@@ -15,7 +16,6 @@ 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 {
-        // Handle unsupported formats
         if (format === `zip` || format === `xz` || format === `bz2`) {
             throw new Error(`${format.toUpperCase()} decompression is not supported in the browser. ` +
                 `Please extract the ${format.toUpperCase()} file first.`);
@@ -39,13 +39,14 @@ export async function decompress_data_binary(data, format) {
 }
 export function decompress_file(file) {
     const format = detect_compression_format(file.name);
-    const is_supported = Boolean(format && ![`zip`, `xz`, `bz2`].includes(format));
+    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;
-                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 +63,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

@@ -1,11 +1,15 @@
 import type { AnyStructure } from '../structure';
-import { type Camera, type Scene } from 'three';
+import { type Camera, type Scene, type WebGLRenderer } from 'three';
+export declare const renderer_registry: WeakMap<HTMLCanvasElement, WebGLRenderer>;
+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): 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 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;
 export declare function export_trajectory_video(canvas: HTMLCanvasElement | null, filename: string, options?: {
     fps?: number;