matterviz 0.4.2 → 0.4.3

package/dist/trajectory/parse/xyz.js

@@ -1,7 +1,7 @@
 import * as math from '../../math';
 import { coerce_elem_symbol } from '../../element/helpers';
 import { calc_force_stats, create_trajectory_frame, iter_xyz_frames, } from '../helpers';
-import { traj_warn } from './diagnostics';
+import { get_traj_parse_warnings, traj_warn } from './diagnostics';
 // Resolve species/pos/forces column offsets from an extxyz Properties string of
 // name:type:ncols triples (e.g. "species:S:1:pos:R:3:forces:R:3"), falling back
 // to the conventional "symbol x y z" layout when absent or malformed
@@ -35,6 +35,45 @@ function parse_extxyz_lattice(comment) {
         return undefined;
     return [vals.slice(0, 3), vals.slice(3, 6), vals.slice(6, 9)];
 }
+const EXTXYZ_BOOL = new Map([
+    [`t`, true],
+    [`true`, true],
+    [`1`, true],
+    [`f`, false],
+    [`false`, false],
+    [`0`, false],
+]); // Map avoids Object.prototype hits (e.g. `constructor`)
+function lookup_extxyz_bools(tokens) {
+    if (tokens.length !== 3)
+        return undefined;
+    const [first, second, third] = tokens.map((token) => EXTXYZ_BOOL.get(token.toLowerCase()));
+    if (first === undefined || second === undefined || third === undefined)
+        return undefined;
+    return [first, second, third];
+}
+function parse_extxyz_pbc(comment) {
+    const match = /\bpbc\s*=\s*(?:"(?<double>[^"]*)"|'(?<single>[^']*)'|(?<bare>\S+(?:\s+\S+){0,2}))/iu.exec(comment);
+    const raw = (match?.groups?.double ?? match?.groups?.single ?? match?.groups?.bare)?.trim();
+    if (!raw)
+        return undefined;
+    // Stop before a following `Key=` token that bare matching may have swallowed
+    const split = raw.split(/\s+/u);
+    const cut = split.findIndex((word) => word.includes(`=`));
+    const words = cut === -1 ? split : split.slice(0, cut);
+    if (words.length === 0)
+        return undefined;
+    const [first] = words;
+    if (first.length === 3) {
+        const compact = lookup_extxyz_bools(first.split(``));
+        if (compact)
+            return compact;
+    }
+    if (words.length === 1) {
+        const only = EXTXYZ_BOOL.get(first.toLowerCase());
+        return only === undefined ? undefined : [only, only, only];
+    }
+    return lookup_extxyz_bools(words.slice(0, 3));
+}
 // Keys anchored at ^|\s and followed by [=:] so single-letter keys (E/V/P/T) don't match mid-word
 const make_pattern = (keys) => new RegExp(`(?:^|\\s)(?:${keys})\\s*[=:]\\s*([-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?)`, `i`);
 const METADATA_PATTERNS = {
@@ -96,11 +135,18 @@ export function build_xyz_frame(lines, frame, opts) {
     const { start, num_atoms, comment } = frame;
     const { step, properties } = parse_xyz_comment_metadata(comment);
     const lattice_matrix = parse_extxyz_lattice(comment);
+    const parsed_pbc = parse_extxyz_pbc(comment);
+    if (parsed_pbc === undefined &&
+        /\bpbc\s*=/iu.test(comment) &&
+        !get_traj_parse_warnings().some((msg) => msg.includes(`Invalid EXTXYZ pbc`))) {
+        traj_warn(`Invalid EXTXYZ pbc (first seen in ${opts.frame_label}); defaulting to fully periodic [T, T, T]`);
+    }
+    const pbc = parsed_pbc ?? [true, true, true];
     const { elements, positions, force_stats } = parse_xyz_atom_lines(lines, start + 2, num_atoms, comment, opts.frame_label);
     const metadata = { ...properties, ...force_stats };
     if (lattice_matrix)
         metadata.volume = math.calc_lattice_params(lattice_matrix).volume;
-    return create_trajectory_frame(positions, elements, lattice_matrix, lattice_matrix ? [true, true, true] : undefined, step ?? opts.default_step, metadata);
+    return create_trajectory_frame(positions, elements, lattice_matrix, lattice_matrix ? pbc : undefined, step ?? opts.default_step, metadata);
 }
 export function parse_xyz_trajectory(content) {
     const lines = content.trim().split(/\r?\n/);

package/dist/trajectory/plotting.js

@@ -72,21 +72,14 @@ function extract_property_statistics(trajectory, data_extractor) {
     // Convert to final format with variation detection
     const result = new Map();
     for (const [key, stat] of property_stats) {
-        const n_values = stat.values.length;
-        if (n_values <= 1)
+        if (stat.values.length <= 1)
             continue;
-        const coefficient_of_variation = get_coefficient_of_variation(stat.values);
-        const lower_key = key.toLowerCase();
-        const is_energy = lower_key === `energy`;
-        const has_variation = coefficient_of_variation >= 1e-6;
+        const is_energy = key.toLowerCase() === `energy`;
+        const has_variation = get_coefficient_of_variation(stat.values) >= 1e-6;
         // Skip constant properties except energy
         if (!has_variation && !is_energy)
             continue;
-        result.set(key, {
-            values: stat.values,
-            has_variation,
-            is_energy,
-        });
+        result.set(key, { values: stat.values, has_variation, is_energy });
     }
     return result;
 }
@@ -95,8 +88,6 @@ function create_series_from_stats(property_stats, property_config, colors) {
     const all_series = [];
     let color_idx = 0;
     for (const [key, stat] of property_stats) {
-        if (!stat)
-            continue;
         const n_values = stat.values.length;
         const { clean_label, unit, axis_group } = extract_label_and_unit(key, property_config);
         const color = colors[color_idx % colors.length];
@@ -254,19 +245,12 @@ function get_axis_label(axis_series) {
     if (visible_series.length === 0)
         return `Value`;
     const unit_groups = new Map();
-    visible_series.forEach((srs) => {
-        const unit = srs.unit ?? ``;
-        const label = srs.label ?? `Value`;
-        if (!unit_groups.has(unit))
-            unit_groups.set(unit, []);
-        const group = unit_groups.get(unit);
-        if (group)
-            group.push(label);
-    });
-    const unit_entries = Array.from(unit_groups.entries());
-    if (unit_entries.length === 0)
-        return `Value`;
-    const [unit, labels] = unit_entries[0];
+    for (const srs of visible_series) {
+        const labels = unit_groups.get(srs.unit ?? ``) ?? [];
+        labels.push(srs.label ?? `Value`);
+        unit_groups.set(srs.unit ?? ``, labels);
+    }
+    const [unit, labels] = [...unit_groups.entries()][0];
     const unique_labels = [...new Set(labels)].sort().join(` / `);
     return unit ? `${unique_labels} (${unit})` : unique_labels;
 }
@@ -336,7 +320,8 @@ export function generate_streaming_plot_series(metadata_list, options = {}) {
         if (data_points.length < 2)
             continue;
         const is_energy = property_key.toLowerCase() === `energy`;
-        if (!is_energy && !has_significant_variation(data_points.map((point) => point.y)))
+        const values = data_points.map((point) => point.y);
+        if (!is_energy && get_coefficient_of_variation(values) < 1e-6)
             continue;
         const { clean_label, unit, axis_group } = extract_label_and_unit(property_key, property_config);
         const is_visible = is_default_visible(property_key, default_visible_properties) || color_idx < 2;
@@ -362,12 +347,10 @@ export function generate_streaming_plot_series(metadata_list, options = {}) {
     }
     return all_series;
 }
-// Helper functions for streaming
+// Down-sample to at most target_points entries (callers guarantee the list is longer)
 function downsample_metadata(metadata_list, target_points) {
     const total_count = metadata_list.length;
-    if (total_count <= target_points)
-        return metadata_list;
-    const points = Math.max(2, Math.min(target_points, total_count));
+    const points = Math.max(2, target_points);
     // Evenly spaced indices in [0, total_count-1], guaranteed to include first and last.
     const sampled = [];
     for (let idx = 0; idx < points; idx++) {
@@ -378,12 +361,6 @@ function downsample_metadata(metadata_list, target_points) {
     }
     return sampled;
 }
-function has_significant_variation(values, tolerance = 1e-6) {
-    if (values.length <= 1)
-        return false;
-    const coefficient_of_variation = get_coefficient_of_variation(values);
-    return coefficient_of_variation >= tolerance;
-}
 function determine_axis_from_groups(property, unit, visible_properties) {
     const mock_series = visible_properties.map(({ property: prop, unit: prop_unit, axis_group }) => ({
         label: prop,

package/dist/xrd/XrdPlot.svelte

@@ -2,13 +2,7 @@
   import { add_alpha, PLOT_COLORS } from '../colors'
   import EmptyState from '../EmptyState.svelte'
   import StatusMessage from '../feedback/StatusMessage.svelte'
-  import {
-    decompress_data_binary,
-    decompress_file,
-    detect_compression_format,
-    drag_over_handlers,
-    handle_url_drop,
-  } from '../io'
+  import * as io from '../io'
   import { format_value } from '../labels'
   import { sanitize_html } from '../sanitize'
   import SettingsSection from '../layout/SettingsSection.svelte'
@@ -164,18 +158,17 @@
       const labels: (string | null)[] = []
 
       // Determine which peaks to annotate
-      const intens = ys
       let selected_indices: number[] = []
-      if (annotate_peaks && annotate_peaks > 0) {
+      if (annotate_peaks > 0) {
         let candidates: { idx: number; y_val: number }[] = []
-        if (annotate_peaks > 0 && annotate_peaks < 1) {
+        if (annotate_peaks < 1) {
           const thresh = annotate_peaks * 100
-          candidates = intens
+          candidates = ys
             .map((y_val, idx) => ({ y_val, idx }))
             .filter(({ y_val }) => y_val > thresh)
         } else {
-          const max_peaks = Math.min(intens.length, Math.floor(annotate_peaks))
-          candidates = intens
+          const max_peaks = Math.min(ys.length, Math.floor(annotate_peaks))
+          candidates = ys
             .map((y_val, idx) => ({ y_val, idx }))
             .sort((a, b) => b.y_val - a.y_val)
             .slice(0, max_peaks)
@@ -209,10 +202,9 @@
 
         if (selected_indices.includes(idx)) {
           const angle_text = actual_show_angles ? `${format_value(xs[idx], `.2f`)}°` : ``
-          const hkl_text =
-            hkls && hkl_format
-              ? hkls.map((hkl_val) => format_hkl(hkl_val, hkl_format)).join(`, `)
-              : ``
+          const hkl_text = hkl_format
+            ? hkls.map((hkl_val) => format_hkl(hkl_val, hkl_format)).join(`, `)
+            : ``
           // Use @ separator between hkl and angle for better clarity
           const separator = hkl_text && angle_text ? ` @ ` : ``
           const text = [hkl_text, angle_text].filter(Boolean).join(separator)
@@ -239,49 +231,32 @@
     if (!broadening_enabled) return []
 
     const include_name = pattern_entries.length > 1
-    // We rescale after broadening so that max peak is 100, matching stick view scale
-    return pattern_entries
-      .map((entry, entry_idx) => {
-        const broadened = compute_broadened_pattern(
-          entry.pattern,
-          broadening_params,
-          angle_range,
-        )
-
-        // Normalize broadened profile relative to GLOBAL max intensity of stick patterns?
-        // Or normalize to 100 for *this* profile?
-        // Usually we want relative intensities between patterns to be preserved if possible.
-        // But broadening spreads intensity, so peak heights drop.
-        // If we normalize each profile to 100 independently, we lose relative scaling between patterns.
-        // If we normalize by global_max_intensity (from sticks), broadened peaks will be tiny.
-        // Let's normalize such that the highest peak across ALL broadened patterns is 100.
-
-        return {
-          broadened,
-          entry,
-          entry_idx,
-        }
-      })
-      .map(({ broadened, entry, entry_idx }, _, all_processed) => {
-        // Find global max of all broadened patterns to normalize
-        const all_ys = all_processed.flatMap((processed) => processed.broadened.y)
-        const max_y = Math.max(...all_ys, 1) // Avoid div by zero
-
-        const scale = (y_val: number) => (y_val / max_y) * 100
-        const base_color = entry.color ?? PLOT_COLORS[entry_idx % PLOT_COLORS.length]
-        // Add transparency when multiple series overlap
-        const alpha = all_processed.length > 1 ? 0.6 : 1
-
-        return {
-          x: broadened.x,
-          y: broadened.y.map(scale),
-          label: include_name ? entry.label : ``,
-          color: add_alpha(base_color, alpha),
-          markers: `line`, // Only line for profile
-          line_style: { stroke_width: 2 },
-          visible: true,
-        } as DataSeries
-      })
+    // Normalize so the highest peak across ALL broadened profiles is 100: per-profile
+    // normalization would lose relative scaling between patterns, while the stick-view
+    // global max would make broadened peaks tiny (broadening spreads intensity)
+    const broadened = pattern_entries.map((entry) =>
+      compute_broadened_pattern(entry.pattern, broadening_params, angle_range),
+    )
+    let max_y = 1 // avoid div by zero
+    for (const profile of broadened) {
+      for (const y_val of profile.y) max_y = Math.max(max_y, y_val)
+    }
+    // Add transparency when multiple series overlap
+    const alpha = pattern_entries.length > 1 ? 0.6 : 1
+
+    return broadened.map((profile, entry_idx) => {
+      const entry = pattern_entries[entry_idx]
+      const base_color = entry.color ?? PLOT_COLORS[entry_idx % PLOT_COLORS.length]
+      return {
+        x: profile.x,
+        y: profile.y.map((y_val) => (y_val / max_y) * 100),
+        label: include_name ? entry.label : ``,
+        color: add_alpha(base_color, alpha),
+        markers: `line`, // Only line for profile
+        line_style: { stroke_width: 2 },
+        visible: true,
+      } as DataSeries
+    })
   })
 
   async function handle_file_drop(event: DragEvent) {
@@ -302,16 +277,16 @@
 
     try {
       // Handle URL-based drops
-      const handled = await handle_url_drop(event, on_file_drop || compute_and_add).catch(
-        () => false,
-      )
+      const handled = await io
+        .handle_url_drop(event, on_file_drop || compute_and_add)
+        .catch(() => false)
       if (handled) return
 
       const file = event.dataTransfer?.files?.[0]
       if (file) {
         try {
           const lower_name = file.name.toLowerCase()
-          const compression_format = detect_compression_format(lower_name)
+          const compression_format = io.detect_compression_format(lower_name)
           // Get base filename without compression extension
           const base_name = compression_format
             ? lower_name.replace(/\.(?:gz|gzip)$/i, ``)
@@ -323,7 +298,7 @@
             let buffer = await file.arrayBuffer()
             // Decompress if gzipped
             if (compression_format === `gzip`) {
-              buffer = await decompress_data_binary(buffer, `gzip`)
+              buffer = await io.decompress_data_binary(buffer, `gzip`)
             }
             const output_name = base_name.endsWith(`.brml`)
               ? base_name
@@ -331,7 +306,7 @@
             await (on_file_drop || compute_and_add)(buffer, output_name)
           } else {
             // Text-based formats (.xy, .xye, .xrdml) - decompress_file handles .gz
-            const { content, filename } = await decompress_file(file)
+            const { content, filename } = await io.decompress_file(file)
             if (content) await (on_file_drop || compute_and_add)(content, filename)
           }
         } catch (exc) {
@@ -456,7 +431,7 @@
         }}
         {tooltip}
         ondrop={handle_file_drop}
-        {...drag_over_handlers({
+        {...io.drag_over_handlers({
           allow: () => allow_file_drop,
           set_dragover: (over) => (dragover = over),
         })}
@@ -509,7 +484,7 @@
         }}
         {tooltip}
         ondrop={handle_file_drop}
-        {...drag_over_handlers({
+        {...io.drag_over_handlers({
           allow: () => allow_file_drop,
           set_dragover: (over) => (dragover = over),
         })}

package/dist/xrd/calc-xrd.js

@@ -128,11 +128,7 @@ export function compute_xrd_pattern(structure, options = {}) {
     const two_theta_range = options.two_theta_range === null ? null : (options.two_theta_range ?? [0, 180]);
     const [min_radius, max_radius] = two_theta_range === null
         ? [0, 2 / wavelength]
-        : (([t_min, t_max]) => {
-            const r_min = (2 * Math.sin((t_min / 2) * (Math.PI / 180))) / wavelength;
-            const r_max = (2 * Math.sin((t_max / 2) * (Math.PI / 180))) / wavelength;
-            return [r_min, r_max];
-        })(two_theta_range);
+        : two_theta_range.map((angle) => (2 * Math.sin((angle / 2) * (Math.PI / 180))) / wavelength);
     const recip_points = enumerate_reciprocal_points(recip_rows, structure.lattice.matrix, max_radius, min_radius);
     const coeffs = [];
     const frac_coords = [];
@@ -149,16 +145,11 @@ export function compute_xrd_pattern(structure, options = {}) {
             if (!raw_coeff) {
                 throw new Error(`No atomic scattering coefficients for ${element_symbol}. Extend ATOMIC_SCATTERING_PARAMS.`);
             }
-            let coeff_entry;
-            if (Array.isArray(raw_coeff)) {
-                const a_arr = raw_coeff.map(([a]) => a);
-                const b_arr = raw_coeff.map(([_, b]) => b);
-                coeff_entry = { a: a_arr, b: b_arr, z: ELEMENT_Z[element_symbol] };
-            }
-            else {
-                coeff_entry = { a: raw_coeff.a.slice(), b: raw_coeff.b.slice(), c: raw_coeff.c };
-            }
-            coeffs.push(coeff_entry);
+            coeffs.push({
+                a: raw_coeff.map((row) => row[0]),
+                b: raw_coeff.map((row) => row[1]),
+                z: ELEMENT_Z[element_symbol],
+            });
             frac_coords.push(site.abc);
             occus.push(species.occu);
             dw_factors.push(debye_waller_factors[element_symbol] ?? 0);
@@ -169,9 +160,7 @@ export function compute_xrd_pattern(structure, options = {}) {
     const two_thetas = [];
     const merge_tol = options.peak_merge_tol ?? TWO_THETA_TOL;
     const scaled_tol = options.scaled_intensity_tol ?? SCALED_INTENSITY_TOL;
-    for (const entry of recip_points) {
-        const hkl = entry.hkl;
-        const g_norm = entry.g_norm;
+    for (const { hkl, g_norm } of recip_points) {
         if (g_norm === 0)
             continue;
         const asin_arg = (wavelength * g_norm) / 2;
@@ -182,18 +171,10 @@ export function compute_xrd_pattern(structure, options = {}) {
         const sin_theta_over_lambda_sq = sin_theta_over_lambda * sin_theta_over_lambda;
         // g.r for all fractional coords
         const g_dot_r_all = frac_coords.map((frac_coord) => math.dot(frac_coord, hkl));
-        // Atomic scattering factors (vectorized style)
-        const f_scattering = coeffs.map((coeff_entry) => {
-            const { a: a_arr, b: b_arr, z: atomic_number } = coeff_entry;
-            const num_terms = Math.min(a_arr.length, b_arr.length);
-            const sum_terms = a_arr
-                .slice(0, num_terms)
-                .reduce((sum, a_i, term_idx) => sum + a_i * Math.exp(-b_arr[term_idx] * sin_theta_over_lambda_sq), 0);
-            // pymatgen-style fitted params: f = Z − 41.78214·s²·Σ aᵢ·exp(−bᵢ·s²)
-            if (atomic_number !== undefined) {
-                return atomic_number - 41.78214 * sin_theta_over_lambda_sq * sum_terms;
-            }
-            return sum_terms + (coeff_entry.c ?? 0);
+        // Atomic scattering factors: f = Z − 41.78214·s²·Σ aᵢ·exp(−bᵢ·s²) (pymatgen fitted params)
+        const f_scattering = coeffs.map(({ a: a_arr, b: b_arr, z: atomic_number }) => {
+            const sum_terms = a_arr.reduce((sum, a_i, term_idx) => sum + a_i * Math.exp(-b_arr[term_idx] * sin_theta_over_lambda_sq), 0);
+            return atomic_number - 41.78214 * sin_theta_over_lambda_sq * sum_terms;
         });
         const dw_corr = dw_factors.map((dw_b) => Math.exp(-dw_b * sin_theta_over_lambda_sq));
         // Structure factor sum: sum(fs * occu * exp(2πi g·r) * DW)
@@ -212,28 +193,16 @@ export function compute_xrd_pattern(structure, options = {}) {
         const lorentz = (1 + Math.cos(2 * theta) ** 2) / denom;
         const intensity_hkl = (f_real * f_real + f_imag * f_imag) * lorentz;
         const two_theta = math.to_degrees(2 * theta);
-        // Use (h, k, l) always. For hexagonal systems, pymatgen presents Miller–Bravais (h, k, i, l),
-        // but downstream components expect 3-index HKL. Keep 3-index form to match types/consumers.
-        const hkl_to_store = [hkl[0], hkl[1], hkl[2]];
-        // Merge peaks within tolerance
-        let found_index = null;
-        for (let idx = 0; idx < two_thetas.length; idx++) {
-            if (Math.abs(two_thetas[idx] - two_theta) < merge_tol) {
-                found_index = idx;
-                break;
-            }
-        }
-        if (found_index !== null) {
-            const key = two_thetas[found_index];
-            const item = peaks.get(key);
-            if (item) {
-                item.intensity += intensity_hkl;
-                item.hkls.push(hkl_to_store);
-            }
+        // Merge peaks within tolerance. hkls stay 3-index (h, k, l) even for hexagonal
+        // systems where pymatgen presents Miller–Bravais (h, k, i, l), matching consumers.
+        const merge_key = two_thetas.find((angle) => Math.abs(angle - two_theta) < merge_tol);
+        const existing = merge_key === undefined ? undefined : peaks.get(merge_key);
+        if (existing) {
+            existing.intensity += intensity_hkl;
+            existing.hkls.push(hkl);
         }
         else {
-            const d_hkl = 1 / g_norm;
-            peaks.set(two_theta, { intensity: intensity_hkl, hkls: [hkl_to_store], d_hkl });
+            peaks.set(two_theta, { intensity: intensity_hkl, hkls: [hkl], d_hkl: 1 / g_norm });
             two_thetas.push(two_theta);
         }
     }
@@ -283,14 +252,9 @@ wavelength) {
         // Check if file is a direct XRD data file (.xy, .brml)
         if (is_xrd_data_file(filename)) {
             // Convert ArrayBufferLike to ArrayBuffer if needed (handles SharedArrayBuffer)
-            let buffer_content;
-            if (typeof content === `string`) {
-                buffer_content = content;
-            }
-            else {
-                buffer_content =
-                    content instanceof ArrayBuffer ? content : new Uint8Array(content).slice().buffer;
-            }
+            const buffer_content = typeof content === `string` || content instanceof ArrayBuffer
+                ? content
+                : new Uint8Array(content).slice().buffer;
             const pattern = await parse_xrd_file(buffer_content, filename);
             if (pattern && pattern.x.length > 0) {
                 return { pattern: { label: filename || `XRD data`, pattern } };

package/dist/xrd/parse.js

@@ -2,17 +2,13 @@
 const MAX_POINTS = 1000;
 // Default step size in degrees for XRD scans when not specified in file
 const DEFAULT_STEP_SIZE = 0.02;
-// Generate x values from scan parameters (start angle, step size, point count).
-// Used by formats that store metadata + intensity-only data.
-const generate_x_from_scan = (start, step, count) => Array.from({ length: count }, (_, idx) => start + idx * step);
-// Create normalized XrdPattern from scan metadata and intensities.
+// Create normalized XrdPattern from scan metadata (start angle, step size) and intensities.
 // Returns null if no intensity data. Used by all parsers as final step.
 function create_pattern(start, step, intensities) {
     if (intensities.length === 0)
         return null;
-    const x_values = generate_x_from_scan(start, step, intensities.length);
-    const normalized = normalize_and_subsample(x_values, intensities);
-    return { x: normalized.x, y: normalized.y };
+    const x_values = intensities.map((_, idx) => start + idx * step);
+    return normalize_and_subsample(x_values, intensities);
 }
 // Parse whitespace-separated numbers from text. Used by multiple formats.
 const parse_number_list = (text) => text
@@ -130,8 +126,7 @@ export function parse_xy_file(content) {
     }
     if (x_values.length === 0)
         return null;
-    const normalized = normalize_and_subsample(x_values, y_values);
-    return { x: normalized.x, y: normalized.y };
+    return normalize_and_subsample(x_values, y_values);
 }
 // Parse a Rigaku .ras file (ASCII format with structured header).
 // Format: *RAS_HEADER_START ... *RAS_HEADER_END followed by *RAS_INT_START ... *RAS_INT_END
@@ -525,19 +520,15 @@ function extract_scan_parameters_xml(doc) {
     // Try to find intensity data - multiple possible tag names
     let intensities = null;
     let two_theta_values = null;
-    // Method 1: <Intensities> tag with space-separated values
-    const intensities_el = doc.querySelector(`Intensities`);
-    if (intensities_el?.textContent) {
-        intensities = parse_number_list(intensities_el.textContent);
-    }
-    // Method 2: <Counts> tag
-    if (!intensities?.length) {
-        const counts_el = doc.querySelector(`Counts`);
-        if (counts_el?.textContent) {
-            intensities = parse_number_list(counts_el.textContent);
-        }
+    // Method 1: <Intensities> or <Counts> tag with space-separated values
+    for (const tag of [`Intensities`, `Counts`]) {
+        const text = doc.querySelector(tag)?.textContent;
+        if (text)
+            intensities = parse_number_list(text);
+        if (intensities?.length)
+            break;
     }
-    // Method 3: Individual <I> or <Count> elements
+    // Method 2: Individual <I> or <Count> elements
     if (!intensities?.length) {
         const intensity_elements = doc.querySelectorAll(`I, Count`);
         if (intensity_elements.length > 0) {
@@ -546,7 +537,7 @@ function extract_scan_parameters_xml(doc) {
                 .filter((val) => !isNaN(val));
         }
     }
-    // Method 4: <Datum> elements with comma-separated values
+    // Method 3: <Datum> elements with comma-separated values
     // Bruker uses different formats depending on instrument/software version:
     // - 8-column HRXRD: "1,1,TwoTheta,Omega,...,Intensity" (indices 2 and 7)
     // - 5-column powder: "time,1,TwoTheta,Theta,Intensity" (indices 2 and 4)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterviz",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Interactive visualizations for materials science: periodic tables, 3D structures, MD trajectories, heatmaps, scatter plots.",
   "keywords": [
     "chemistry",
@@ -20,7 +20,10 @@
   ],
   "type": "module",
   "sideEffects": [
-    "**/*.css"
+    "**/*.css",
+    "**/file-viewer/main.*",
+    "**/theme/embedded.*",
+    "**/theme/themes.*"
   ],
   "exports": {
     ".": {
@@ -63,6 +66,30 @@
       "types": "./dist/feedback/index.d.ts",
       "default": "./dist/feedback/index.js"
     },
+    "./file-viewer": {
+      "types": "./dist/file-viewer/index.d.ts",
+      "default": "./dist/file-viewer/index.js"
+    },
+    "./file-viewer/parse": {
+      "types": "./dist/file-viewer/parse.d.ts",
+      "default": "./dist/file-viewer/parse.js"
+    },
+    "./file-viewer/eligibility": {
+      "types": "./dist/file-viewer/eligibility.d.ts",
+      "default": "./dist/file-viewer/eligibility.js"
+    },
+    "./file-viewer/host-protocol": {
+      "types": "./dist/file-viewer/host-protocol.d.ts",
+      "default": "./dist/file-viewer/host-protocol.js"
+    },
+    "./file-viewer/host-transfer": {
+      "types": "./dist/file-viewer/host-transfer.d.ts",
+      "default": "./dist/file-viewer/host-transfer.js"
+    },
+    "./file-viewer/webview": {
+      "types": "./dist/file-viewer/main.d.ts",
+      "default": "./dist/file-viewer/main.js"
+    },
     "./fermi-surface": {
       "types": "./dist/fermi-surface/index.d.ts",
       "default": "./dist/fermi-surface/index.js"
@@ -147,6 +174,10 @@
       "types": "./dist/theme/index.d.ts",
       "default": "./dist/theme/index.js"
     },
+    "./theme/embedded": {
+      "types": "./dist/theme/embedded.d.ts",
+      "default": "./dist/theme/embedded.js"
+    },
     "./theme/themes": {
       "default": "./dist/theme/themes.mjs"
     },
@@ -185,12 +216,13 @@
     "prepublishOnly": "pnpm run package:dist"
   },
   "dependencies": {
-    "@spglib/moyo-wasm": "^0.14.0",
-    "@sveltejs/kit": "2.69.2",
+    "@spglib/moyo-wasm": "^0.15.0",
+    "@sveltejs/kit": "2.69.3",
     "@threlte/core": "^8.5.16",
     "@threlte/extras": "^9.21.0",
     "d3-array": "^3.2.4",
     "d3-color": "^3.1.0",
+    "d3-contour": "^4.0.2",
     "d3-format": "^3.1.2",
     "d3-hierarchy": "^3.1.2",
     "d3-interpolate-path": "^2.3.0",
@@ -214,6 +246,7 @@
     "@sveltejs/vite-plugin-svelte": "^7.2.0",
     "@types/d3-array": "^3.2.2",
     "@types/d3-color": "^3.1.3",
+    "@types/d3-contour": "^3.0.6",
     "@types/d3-format": "^3.0.4",
     "@types/d3-hierarchy": "^3.1.7",
     "@types/d3-interpolate-path": "^2.0.3",
@@ -226,12 +259,12 @@
     "@vitest/coverage-v8": "4.1.10",
     "@wooorm/starry-night": "^3.10.0",
     "happy-dom": "^20.10.6",
-    "knip": "^6.25.0",
+    "knip": "^6.26.0",
     "mdsvex": "^0.12.7",
     "publint": "^0.3.21",
     "rehype-katex": "^7.0.1",
     "remark-math": "3.0.1",
-    "svelte": "^5.56.4",
+    "svelte": "^5.56.5",
     "svelte-check": "^4.7.2",
     "typescript": "^6.0.3",
     "vite": "^8.1.4",
@@ -276,8 +309,7 @@
       },
       "extensions/vscode": {
         "entry": [
-          "src/extension.ts",
-          "src/webview/main.ts"
+          "src/extension.ts"
         ],
         "paths": {
           "$lib": [