matterviz 0.3.7 → 0.4.0

package/dist/chempot-diagram/async-compute.svelte.js

@@ -1,6 +1,7 @@
 // Async wrapper for compute_chempot_diagram via Web Worker.
 // Falls back to synchronous main-thread computation during SSR.
 import { compute_chempot_diagram, formula_key_from_composition } from './compute';
+import { to_error } from '../utils';
 let worker = null;
 let next_id = 0;
 const pending = new Map();
@@ -28,6 +29,7 @@ function get_worker() {
     if (typeof Worker === `undefined`)
         return null;
     if (!worker) {
+        // oxlint-disable-next-line eslint-plugin-unicorn/relative-url-style -- Vite worker detection requires the `./` prefix
         worker = new Worker(new URL(`./chempot-worker.js`, import.meta.url), { type: `module` });
         worker.addEventListener(`message`, ({ data: { id, result, error } }) => {
             const req = pending.get(id);
@@ -71,7 +73,7 @@ export function compute_chempot_async(entries, config = {}) {
         }
         catch (err) {
             pending.delete(id);
-            reject(err instanceof Error ? err : new Error(String(err)));
+            reject(to_error(err));
         }
     });
     return track_pending(request_key, promise);

package/dist/chempot-diagram/chempot-worker.js

@@ -1,4 +1,5 @@
 import { compute_chempot_diagram } from './compute';
+import { to_error } from '../utils';
 self.addEventListener(`message`, (event) => {
     const { id, entries, config } = event.data;
     try {
@@ -6,6 +7,6 @@ self.addEventListener(`message`, (event) => {
         postMessage({ id, result, error: null });
     }
     catch (err) {
-        postMessage({ id, result: null, error: err instanceof Error ? err.message : String(err) });
+        postMessage({ id, result: null, error: to_error(err).message });
     }
 });

package/dist/chempot-diagram/compute.d.ts

@@ -8,7 +8,7 @@ export declare function get_min_entries_and_el_refs(entries: PhaseData[]): {
 };
 export declare function compute_form_energy_per_atom(entry: PhaseData, el_refs: Record<string, PhaseData>): number;
 export declare function best_form_energy_for_formula(entries: PhaseData[], formula: string, el_refs: Record<string, PhaseData>): number | undefined;
-export declare function renormalize_entries(entries: PhaseData[], el_refs: Record<string, PhaseData>, elements: string[]): PhaseData[];
+export declare const renormalize_entries: (entries: PhaseData[], el_refs: Record<string, PhaseData>, elements: string[]) => PhaseData[];
 export declare function build_hyperplanes(min_entries: PhaseData[], el_refs: Record<string, PhaseData>, elements: string[]): {
     hyperplanes: number[][];
     hyperplane_entries: PhaseData[];

package/dist/chempot-diagram/compute.js

@@ -112,24 +112,22 @@ export function best_form_energy_for_formula(entries, formula, el_refs) {
 }
 // Renormalize entry energies to be relative to elemental references (formal chemical potentials).
 // For each entry, subtracts sum(x_i * E_ref_i) from its energy per atom.
-export function renormalize_entries(entries, el_refs, elements) {
-    return entries.map((entry) => {
-        const atoms = count_atoms_in_composition(entry.composition);
-        let renorm_energy = 0;
-        for (const el of elements) {
-            const frac = atoms > 0 ? (entry.composition[el] ?? 0) / atoms : 0;
-            const ref = el_refs[el];
-            if (ref)
-                renorm_energy += frac * get_energy_per_atom(ref);
-        }
-        const new_energy_per_atom = get_energy_per_atom(entry) - renorm_energy;
-        return {
-            ...entry,
-            energy: new_energy_per_atom * atoms,
-            energy_per_atom: new_energy_per_atom,
-        };
-    });
-}
+export const renormalize_entries = (entries, el_refs, elements) => entries.map((entry) => {
+    const atoms = count_atoms_in_composition(entry.composition);
+    let renorm_energy = 0;
+    for (const el of elements) {
+        const frac = atoms > 0 ? (entry.composition[el] ?? 0) / atoms : 0;
+        const ref = el_refs[el];
+        if (ref)
+            renorm_energy += frac * get_energy_per_atom(ref);
+    }
+    const new_energy_per_atom = get_energy_per_atom(entry) - renorm_energy;
+    return {
+        ...entry,
+        energy: new_energy_per_atom * atoms,
+        energy_per_atom: new_energy_per_atom,
+    };
+});
 // Build hyperplane representation for minimum entries.
 // Each row is [x_1, ..., x_n, -E_per_atom].
 // Filters to entries with negative formation energy plus all elemental refs.
@@ -782,7 +780,7 @@ export function compute_chempot_diagram(entries, config = {}) {
     if (is_projection) {
         const col_indices = display_elements.map((element) => {
             const idx = compute_elements.indexOf(element);
-            if (idx < 0) {
+            if (idx === -1) {
                 throw new Error(`Display element ${element} not present in compute element set`);
             }
             return idx;

package/dist/colors/index.js

@@ -1,4 +1,4 @@
-import { rgb } from 'd3-color';
+import { color as d3_color, rgb } from 'd3-color';
 import * as d3_sc from 'd3-scale-chromatic';
 import alloy_colors from './alloy-colors.json' with { type: 'json' };
 import dark_mode_colors from './dark-mode-colors.json' with { type: 'json' };
@@ -55,13 +55,14 @@ export const ELEMENT_COLOR_SCHEMES = {
     'Dark Mode': dark_mode_hex,
 };
 export const default_element_colors = { ...vesta_hex };
-// Helper function to detect if a value is a color string
+// Detect if a value is a CSS color string. d3-color parses hex, rgb()/rgba(),
+// hsl()/hsla(), and named colors case-insensitively, rejecting arbitrary words like
+// `pending`. It doesn't parse var()/color()/currentcolor, so match those explicitly.
 export const is_color = (val) => {
     if (typeof val !== `string`)
         return false;
-    // Check for hex colors, rgb/rgba, hsl/hsla, color(), var(), and named colors
-    // Exclude incomplete function prefixes like 'rgb', 'hsl', 'var', 'color'
-    return /^(#[0-9a-f]{3,8}|rgba?\([^)]+\)|hsla?\([^)]+\)|color\([^)]+\)|var\([^)]+\)|(?!rgb$|hsl$|var$|color$)[a-z]+)$/i.test(val.trim());
+    const trimmed = val.trim();
+    return /^(?:var|color)\([^)]+\)$|^currentcolor$/i.test(trimmed) || d3_color(trimmed) !== null;
 };
 export const PLOT_COLORS = [
     // Color series for e.g. line plots

package/dist/composition/FormulaFilter.svelte

@@ -338,10 +338,10 @@
       normalized = normalized.replaceAll(superscript, ascii)
     }
     return normalized
-      .replaceAll(`·`, ``)
-      .replaceAll(`⋅`, ``)
+      // keep hydrate dots (deleting would glue digits: CuSO4·5H2O -> CuSO45H2O)
+      .replaceAll(`⋅`, `·`)
       .replaceAll(`−`, `-`)
-      .replace(/\s+/g, ``)
+      .replaceAll(/\s+/g, ``)
   }
 
   function normalize_exact_formula(input: string): string {
@@ -361,7 +361,7 @@
       const wildcard_tokens = tokens.filter((token) => token.element === null)
 
       // Merge explicit element counts before sorting.
-      const merged_explicit: Array<{ element: string; count: number }> = []
+      const merged_explicit: { element: string; count: number }[] = []
       for (const token of explicit) {
         const existing = merged_explicit.find((item) =>
           item.element === token.element
@@ -609,14 +609,20 @@
     const reformatted = format_for_mode(elements, next_mode)
 
     search_mode = next_mode
-    last_synced = value = input_value = reformatted // update last_synced to prevent effect re-inference
+    // set last_synced too to prevent effect re-inference
+    last_synced = reformatted
+    value = reformatted
+    input_value = reformatted
     run_validation(reformatted, next_mode)
     onchange?.(reformatted, next_mode)
   }
 
   function set_value(new_value: string, forced_mode?: FormulaSearchMode): void {
     const mode = forced_mode ?? (mode_locked ? search_mode : infer_mode(new_value))
-    last_synced = value = input_value = new_value // update last_synced to prevent effect re-inference
+    // set last_synced too to prevent effect re-inference
+    last_synced = new_value
+    value = new_value
+    input_value = new_value
     search_mode = mode
     if (new_value.trim()) add_to_history(new_value)
     close_history()

package/dist/composition/PieChart.svelte

@@ -151,11 +151,9 @@
         } else if (is_medium_slice) {
           // Medium slices: place closer to outer edge, proportional to chart size
           label_radius = outer_radius - outer_radius * 0.3
-          is_outside_slice = false
         } else {
           // Large slices: place in middle of ring
           label_radius = (outer_radius + inner_radius_adjusted) / 2
-          is_outside_slice = false
         }
 
         // Calculate font scale based on slice size and smart text fitting
@@ -293,9 +291,15 @@
   .pie-segment.interactive:focus {
     outline: none;
   }
+  svg {
+    /* very thin slices place their labels outside the pie at 1.2x the outer radius,
+    past the square viewBox - the default svg overflow: hidden would clip them */
+    overflow: visible;
+  }
   foreignobject {
     pointer-events: none;
     transition: all 0.2s ease;
+    overflow: visible;
   }
   foreignobject.hovered {
     font-weight: 700;
@@ -310,9 +314,6 @@
     transition: all 0.2s ease;
     white-space: nowrap;
   }
-  foreignobject {
-    overflow: visible;
-  }
   .pie-label.hovered {
     font-weight: 700;
   }

package/dist/composition/chem-sys.d.ts

@@ -0,0 +1,8 @@
+import type { SunburstNode } from '../plot/core/types';
+export interface ChemSysSunburstMetadata {
+    chem_sys: string;
+    arity: number;
+    [key: string]: unknown;
+}
+export declare const arity_name: (arity: number) => string;
+export declare function chem_sys_sunburst_data(entries: readonly string[]): SunburstNode<ChemSysSunburstMetadata>[];

package/dist/composition/chem-sys.js

@@ -0,0 +1,85 @@
+// Build arity -> chemical-system hierarchy data for the Sunburst component
+// (counterpart to pymatviz's chem_sys_sunburst).
+import { is_valid_element, parse_formula } from './parse';
+const ARITY_NAMES = [
+    ``,
+    `unary`,
+    `binary`,
+    `ternary`,
+    `quaternary`,
+    `quinary`,
+    `senary`,
+    `septenary`,
+    `octonary`,
+    `nonary`,
+    `denary`,
+];
+// || (not ??) so the empty index-0 placeholder also falls through to "0-ary"
+export const arity_name = (arity) => ARITY_NAMES[arity] || `${arity}-ary`;
+// Build arity -> chemical-system sunburst data from a list of chemical systems
+// ("Li-Fe-O") and/or formulas ("LiFePO4"), one entry per occurrence (counts become
+// leaf values). Systems are normalized to alphabetical element order, so "O-Li" and
+// "Li2O" both count toward "Li-O". Ids follow the "<arity>/<system>" scheme.
+export function chem_sys_sunburst_data(entries) {
+    // Inputs are one entry per occurrence, so the same formula typically repeats many
+    // times - memoize raw entry -> normalized system (null = invalid) to parse each
+    // distinct string only once
+    const normalized = new Map();
+    const normalize = (entry) => {
+        let elements;
+        if (entry.includes(`-`)) {
+            elements = entry.split(`-`).map((el) => el.trim());
+            if (!elements.every(is_valid_element))
+                return null;
+        }
+        else {
+            try {
+                elements = Object.keys(parse_formula(entry));
+            }
+            catch {
+                return null;
+            }
+        }
+        if (elements.length === 0)
+            return null;
+        return [...new Set(elements)].sort().join(`-`);
+    };
+    const counts = new Map();
+    let n_invalid = 0;
+    for (const entry of entries) {
+        let chem_sys = normalized.get(entry);
+        if (chem_sys === undefined) {
+            chem_sys = normalize(entry);
+            normalized.set(entry, chem_sys);
+        }
+        if (chem_sys === null) {
+            n_invalid += 1;
+            continue;
+        }
+        counts.set(chem_sys, (counts.get(chem_sys) ?? 0) + 1);
+    }
+    if (n_invalid > 0) {
+        console.warn(`chem_sys_sunburst_data: skipped ${n_invalid} invalid entr${n_invalid === 1 ? `y` : `ies`} (expected chemical systems like "Li-Fe-O" or formulas like "LiFePO4")`);
+    }
+    // One composite sort (arity ascending, then count descending) puts systems in
+    // final order; consecutive same-arity runs then collapse into one branch each
+    const sorted = [...counts]
+        .map(([chem_sys, count]) => ({ chem_sys, count, arity: chem_sys.split(`-`).length }))
+        .sort((sys_a, sys_b) => sys_a.arity - sys_b.arity || sys_b.count - sys_a.count);
+    const roots = [];
+    let branch;
+    for (const { chem_sys, count, arity } of sorted) {
+        const name = arity_name(arity);
+        if (branch?.id !== name) {
+            branch = { id: name, label: name, children: [] };
+            roots.push(branch);
+        }
+        branch.children?.push({
+            id: `${name}/${chem_sys}`,
+            label: chem_sys,
+            value: count,
+            metadata: { chem_sys, arity },
+        });
+    }
+    return roots;
+}

package/dist/composition/format.js

@@ -24,10 +24,12 @@ export const format_composition_formula = (composition, sort_fn, plain_text = fa
     return sort_fn(symbols)
         .filter((el) => composition[el] && composition[el] > 0)
         .map((el) => {
-        const amount = composition[el];
+        const amount = Number(composition[el]);
         if (amount === 1)
             return el;
-        const formatted_amount = format_num(Number(amount), amount_format);
+        // avoid d3 SI prefixes for sub-1 amounts (`s` formats render 0.5 as 500m)
+        const fmt = amount_format.endsWith(`s`) && Math.abs(amount) < 1 ? `.3~g` : amount_format;
+        const formatted_amount = format_num(amount, fmt);
         return plain_text ? `${el}${formatted_amount}` : `${el}<sub>${formatted_amount}</sub>`;
     })
         .join(delim);

package/dist/composition/index.d.ts

@@ -1,6 +1,7 @@
 import type { ElementSymbol } from '../element';
 export { default as BarChart } from './BarChart.svelte';
 export { default as BubbleChart } from './BubbleChart.svelte';
+export * from './chem-sys';
 export { default as Composition } from './Composition.svelte';
 export * from './format';
 export { default as Formula } from './Formula.svelte';

package/dist/composition/index.js

@@ -1,5 +1,6 @@
 export { default as BarChart } from './BarChart.svelte';
 export { default as BubbleChart } from './BubbleChart.svelte';
+export * from './chem-sys';
 export { default as Composition } from './Composition.svelte';
 export * from './format';
 export { default as Formula } from './Formula.svelte';

package/dist/composition/parse.js

@@ -65,26 +65,38 @@ export const atomic_symbol_to_num = (symbol_composition) => {
 // Expand parentheses in chemical formulas
 const expand_parentheses = (formula) => {
     while (formula.includes(`(`)) {
-        formula = formula.replace(/\(([^()]+)\)(\d+(?:\.\d+)?|\.\d+)?/g, (_match, group, multiplier) => {
+        const expanded = formula.replaceAll(/\(([^()]+)\)(\d+(?:\.\d+)?|\.\d+)?/g, (_match, group, multiplier) => {
             const mult = parse_count(multiplier);
-            return group.replace(/([A-Z][a-z]?)(\d+(?:\.\d+)?|\.\d+)?/g, (_m, element, count) => {
+            return group.replaceAll(/([A-Z][a-z]?)(\d+(?:\.\d+)?|\.\d+)?/g, (_m, element, count) => {
                 const count_str = format_count(parse_count(count) * mult);
                 return element + (count_str === `1` ? `` : count_str);
             });
         });
+        if (expanded === formula) {
+            // unclosed/empty parens match nothing -> would loop forever
+            throw new Error(`Unbalanced or empty parentheses in formula: ${formula}`);
+        }
+        formula = expanded;
     }
     return formula;
 };
-// Parse chemical formula string into composition object
+// Parse chemical formula string into composition object. Hydrate/adduct segments
+// joined by ·, ⋅, or * are scaled by their leading coefficient (CuSO4·5H2O -> Cu S O9 H10)
 export const parse_formula = (formula) => {
     const composition = {};
-    const cleaned_formula = expand_parentheses(formula.replace(/\s/g, ``));
-    for (const match of cleaned_formula.matchAll(/([A-Z][a-z]?)(\d+(?:\.\d+)?|\.\d+)?/g)) {
-        const element = match[1];
-        const count = parse_count(match[2]);
-        if (!is_valid_element(element))
-            throw new Error(`Invalid element symbol: ${element}`);
-        composition[element] = (composition[element] ?? 0) + count;
+    const cleaned = formula.replaceAll(/\s/g, ``);
+    const segments = cleaned.split(/[·⋅*]/).filter(Boolean);
+    for (const [seg_idx, segment] of segments.entries()) {
+        // only hydrate segments (after a separator) carry a leading multiplier
+        const coeff = seg_idx > 0 ? /^(?:\d+(?:\.\d+)?|\.\d+)/.exec(segment)?.[0] : undefined;
+        const multiplier = coeff ? parseFloat(coeff) : 1;
+        const expanded = expand_parentheses(segment.slice(coeff?.length ?? 0));
+        for (const match of expanded.matchAll(/([A-Z][a-z]?)(\d+(?:\.\d+)?|\.\d+)?/g)) {
+            const [, element, count] = match;
+            if (!is_valid_element(element))
+                throw new Error(`Invalid element symbol: ${element}`);
+            composition[element] = (composition[element] ?? 0) + parse_count(count) * multiplier;
+        }
     }
     return composition;
 };
@@ -210,7 +222,7 @@ const parse_oxidation_state = (oxidation_str) => {
 // When strict=true, throws on conflicting oxidation states for the same element.
 export const parse_formula_with_oxidation = (formula, strict = false) => {
     const elements = [];
-    const cleaned_formula = expand_parentheses(formula.replace(/\s/g, ``));
+    const cleaned_formula = expand_parentheses(formula.replaceAll(/\s/g, ``));
     // Regex to match: Element, optional oxidation state and/or count in either order
     // Pattern: ([A-Z][a-z]?)  - element symbol
     //          Followed by one of:
@@ -332,7 +344,7 @@ export const has_wildcards = (input) => input.includes(`*`);
 // Throws if any non-wildcard token is not a valid element symbol.
 export function parse_chemsys_with_wildcards(input) {
     const tokens = input
-        .replace(/-/g, `,`)
+        .replaceAll('-', `,`)
         .split(`,`)
         .map((tok) => tok.trim())
         .filter(Boolean);
@@ -368,7 +380,7 @@ export const ELEM_WILDCARD = {
 export function parse_formula_with_wildcards(formula) {
     const tokens = [];
     // Expand parentheses, treating * as a pseudo-element (temporarily replace to protect it)
-    let cleaned = formula.replace(/\s/g, ``);
+    let cleaned = formula.replaceAll(/\s/g, ``);
     // Protect wildcards from parentheses expansion by replacing * with placeholder
     cleaned = cleaned.replace(ELEM_WILDCARD.to_placeholder, ELEM_WILDCARD.placeholder);
     cleaned = expand_parentheses(cleaned);

package/dist/convex-hull/ConvexHull2D.svelte

@@ -320,7 +320,7 @@
   let copy_feedback = $state({ visible: false, position: { x: 0, y: 0 } })
 
   // Structure popup state
-  let structure_popup = $state<{
+  let structure_popup = $state.raw<{
     open: boolean
     structure: AnyStructure | null
     entry: ConvexHullEntry | null
@@ -381,17 +381,17 @@
       const hl = is_highlighted(entry) ? merged_highlight_style : null
 
       point_style[idx] = {
-        fill: hl && (hl.effect === `color` || hl.effect === `both`)
-          ? hl.color
+        fill: hl?.effect === `color` || hl?.effect === `both`
+          ? hl?.color
           : is_energy_mode
           ? undefined
           : merged_config.colors?.[is_stable ? `stable` : `unstable`],
         stroke: is_stable ? `#ffffff` : `#000000`,
-        radius: hl && (hl.effect === `size` || hl.effect === `both`)
-          ? base_radius * hl.size_multiplier
+        radius: hl?.effect === `size` || hl?.effect === `both`
+          ? base_radius * (hl?.size_multiplier ?? 1)
           : base_radius,
         symbol_type: marker_to_d3_symbol(entry.marker),
-        is_highlighted: !!hl,
+        is_highlighted: Boolean(hl),
         highlight_effect: hl?.effect,
         highlight_color: hl?.color,
       }
@@ -436,8 +436,10 @@
   const selected_scatter_point = $derived.by(() => {
     const entry = selected_entry
     if (!entry) return null
-    const idx = visible_entries.findIndex((vis_entry) => vis_entry === entry)
-    return idx >= 0 ? { series_idx: 0, point_idx: idx } : null
+    // match by entry_id (same_entry), not reference: selected_entry may be a proxied/
+    // different instance than visible_entries elements when bound to a parent $state
+    const idx = visible_entries.findIndex((vis_entry) => helpers.same_entry(vis_entry, entry))
+    return idx === -1 ? null : { series_idx: 0, point_idx: idx }
   })
 
   // Convex hull statistics - compute internally and expose via bindable prop
@@ -489,11 +491,11 @@
   )
 
   // Custom hover tooltip state used with ScatterPlot events
-  let hover_data = $state<HoverData3D<ConvexHullEntry> | null>(null)
+  let hover_data = $state.raw<HoverData3D<ConvexHullEntry> | null>(null)
   $effect(() => {
     const current_selection = helpers.current_entry(selected_entry, plot_entries)
     if (selected_entry && !current_selection) selected_entry = null
-    else if (current_selection && current_selection !== selected_entry) {
+    else if (current_selection && !helpers.same_entry(current_selection, selected_entry)) {
       selected_entry = current_selection
     }
     const current_hover = helpers.current_entry(hover_data?.entry, plot_entries)

package/dist/convex-hull/ConvexHull3D.svelte

@@ -23,8 +23,8 @@
   } from '../layout'
   import { to_radians, type Point3D, type Vec3 } from '../math'
   import { ColorBar, PlotTooltip } from '../plot'
-  import { centered_rect, pad_rect, rects_overlap, rect_within_rect } from '../plot/layout'
-  import type { Rect } from '../plot/layout'
+  import { centered_rect, pad_rect, rects_overlap, rect_within_rect } from '../plot/core/layout'
+  import type { Rect } from '../plot/core/layout'
   import { create_pulse_animation } from '../effects.svelte'
   import { DEFAULTS } from '../settings'
   import type { AnyStructure } from '../structure'
@@ -422,7 +422,7 @@
   let is_dragging = $state(false)
   let drag_started = $state(false)
   let last_mouse = $state({ x: 0, y: 0 })
-  let hover_data = $state<HoverData3D<ConvexHullEntry> | null>(null)
+  let hover_data = $state.raw<HoverData3D<ConvexHullEntry> | null>(null)
   let copy_feedback = $state({ visible: false, position: { x: 0, y: 0 } })
 
   // Drag and drop state
@@ -436,7 +436,7 @@
     const current_selection = helpers.current_entry(selected_entry, plot_entries)
     const stale_selection = selected_entry && !current_selection
     if (stale_selection) selected_entry = null
-    else if (current_selection && current_selection !== selected_entry) {
+    else if (current_selection && !helpers.same_entry(current_selection, selected_entry)) {
       selected_entry = current_selection
     }
     const current_hover = helpers.current_entry(hover_data?.entry, plot_entries)
@@ -963,7 +963,7 @@
 
   // Formation energy color bar helpers
   const e_form_range = $derived.by((): [number, number] => {
-    const min_fe = plot_entries.length ? energy_range.min : -1
+    const min_fe = plot_entries.length > 0 ? energy_range.min : -1
     return [min_fe, 0]
   })
 

package/dist/convex-hull/ConvexHull4D.svelte

@@ -326,7 +326,7 @@
   let is_dragging = $state(false)
   let drag_started = $state(false)
   let last_mouse = $state({ x: 0, y: 0 })
-  let hover_data = $state<HoverData3D<ConvexHullEntry> | null>(null)
+  let hover_data = $state.raw<HoverData3D<ConvexHullEntry> | null>(null)
   let copy_feedback = $state({ visible: false, position: { x: 0, y: 0 } })
 
   // Drag and drop state
@@ -340,7 +340,7 @@
     const current_selection = helpers.current_entry(selected_entry, plot_entries)
     const stale_selection = selected_entry && !current_selection
     if (stale_selection) selected_entry = null
-    else if (current_selection && current_selection !== selected_entry) {
+    else if (current_selection && !helpers.same_entry(current_selection, selected_entry)) {
       selected_entry = current_selection
     }
     const current_hover = helpers.current_entry(hover_data?.entry, plot_entries)
@@ -394,12 +394,11 @@
     const total_entries = effective_entries.length
     if (total_entries > label_threshold) {
       show_stable_labels = false
-      show_unstable_labels = false
     } else {
       // For smaller datasets, show stable labels by default
       show_stable_labels = true
-      show_unstable_labels = false
     }
+    show_unstable_labels = false
   })
 
   // Function to extract structure data from a convex hull entry
@@ -630,11 +629,8 @@
       for (let idx = 0; idx < 4; idx++) {
         const vx = vertices[idx]
         // Direction from centroid to vertex
-        const dir = {
-          x: vx.x - centroid.x,
-          y: vx.y - centroid.y,
-          z: vx.z - centroid.z,
-        }
+        const { x: cx, y: cy, z: cz } = centroid
+        const dir = { x: vx.x - cx, y: vx.y - cy, z: vx.z - cz }
         const len = Math.hypot(dir.x, dir.y, dir.z) || 1
         const label_pos = {
           x: vx.x + (dir.x / len) * distance,

package/dist/convex-hull/ConvexHullStats.svelte

@@ -7,7 +7,7 @@
   import Icon from '../Icon.svelte'
   import { format_num } from '../labels'
   import { sanitize_html } from '../sanitize'
-  import Histogram from '../plot/Histogram.svelte'
+  import Histogram from '../plot/histogram/Histogram.svelte'
   import type { Label, RowData } from '../table'
   import HeatmapTable from '../table/HeatmapTable.svelte'
   import type { HTMLAttributes } from 'svelte/elements'
@@ -254,20 +254,20 @@
   // Escape HTML special chars to prevent XSS when rendering user-supplied strings via {@html}
   const escape_html = (str: string): string =>
     str
-      .replace(/&/g, `&`)
-      .replace(/</g, `&lt;`)
-      .replace(/>/g, `&gt;`)
-      .replace(/"/g, `&quot;`)
-      .replace(/'/g, `&#39;`)
+      .replaceAll('&', `&amp;`)
+      .replaceAll('<', `&lt;`)
+      .replaceAll('>', `&gt;`)
+      .replaceAll('"', `&quot;`)
+      .replaceAll('\'', `&#39;`)
   const unescape_html = (str: string, max_rounds = 5): string => {
     let decoded = str
     for (let round_idx = 0; round_idx < max_rounds; round_idx++) {
       const next_decoded = decoded
-        .replace(/&amp;/g, `&`)
-        .replace(/&lt;/g, `<`)
-        .replace(/&gt;/g, `>`)
-        .replace(/&quot;/g, `"`)
-        .replace(/&#39;/g, `'`)
+        .replaceAll('&amp;', `&`)
+        .replaceAll('&lt;', `<`)
+        .replaceAll('&gt;', `>`)
+        .replaceAll('&quot;', `"`)
+        .replaceAll('&#39;', `'`)
       if (next_decoded === decoded) break
       decoded = next_decoded
     }
@@ -336,7 +336,7 @@
       // Match by entry_id or common data fields (mat_id, structure_id)
       // since entry_id may be wrapped in HTML (e.g. <a> tags)
       const entry_data = entry.data as Record<string, unknown> | undefined
-      const is_highlighted = !!(highlighted_entry_id && (
+      const is_highlighted = Boolean(highlighted_entry_id && (
         entry.entry_id === highlighted_entry_id ||
         entry_data?.mat_id === highlighted_entry_id ||
         entry_data?.structure_id === highlighted_entry_id

package/dist/convex-hull/GasPressureControls.svelte

@@ -64,7 +64,7 @@
 
   // Convert slider position (0-100) to pressure
   const slider_to_pressure = (value: number): number =>
-    Math.pow(10, LOG_P_MIN + (value / 100) * LOG_P_RANGE)
+    10 ** (LOG_P_MIN + (value / 100) * LOG_P_RANGE)
 
   // Format gas name for display (subscript numbers)
   const format_gas_name = (gas: GasSpecies): string =>
@@ -94,7 +94,7 @@
     gas: GasSpecies,
     event: Event & { currentTarget: HTMLInputElement },
   ): void {
-    const P = slider_to_pressure(+event.currentTarget.value)
+    const P = slider_to_pressure(Number(event.currentTarget.value))
     pressures = { ...pressures, [gas]: P }
     // Clear only this gas's preview (don't reset other sliders being dragged simultaneously)
     const { [gas]: _removed_preview, ...remaining_previews } = preview_pressures
@@ -103,8 +103,8 @@
 
   function set_pressure_direct(gas: GasSpecies, value: number): void {
     const clamped = Math.max(
-      Math.pow(10, LOG_P_MIN),
-      Math.min(Math.pow(10, LOG_P_MAX), value),
+      10 ** LOG_P_MIN,
+      Math.min(10 ** LOG_P_MAX, value),
     )
     pressures = { ...pressures, [gas]: clamped }
   }