matterviz 0.4.1 → 0.4.3

package/dist/composition/format.js

@@ -3,17 +3,15 @@ import { is_elem_symbol } from '../element';
 import { ELEMENT_ELECTRONEGATIVITY_MAP, parse_composition } from './parse';
 // Extract composition from structure object
 const structure_to_composition = (structure) => {
-    if (!structure.sites || !Array.isArray(structure.sites)) {
-        throw new Error(`Invalid structure object`);
+    if (!Array.isArray(structure.sites)) {
+        throw new TypeError(`Invalid structure object`);
     }
     const composition = {};
     for (const site of structure.sites) {
-        if (site.species && Array.isArray(site.species)) {
-            for (const species of site.species) {
-                const element = species.element;
-                const occu = species.occu ?? 1;
-                composition[element] = (composition[element] ?? 0) + occu;
-            }
+        if (!Array.isArray(site.species))
+            continue;
+        for (const species of site.species) {
+            composition[species.element] = (composition[species.element] ?? 0) + (species.occu ?? 1);
         }
     }
     return composition;
@@ -86,7 +84,7 @@ export const get_electro_neg_formula = (input, plain_text = false, delim = ` `,
 export function get_formula_label_segments(formula) {
     const segments = [];
     let cursor = 0;
-    for (const match of formula.matchAll(/([A-Za-z])(\d+(?:\.\d+)?)/g)) {
+    for (const match of formula.matchAll(/(?<letter>[A-Za-z])(?<amount>\d+(?:\.\d+)?)/g)) {
         const match_idx = match.index ?? 0;
         const prefix = match[1];
         const amount = match[2];

package/dist/composition/index.d.ts

@@ -18,4 +18,6 @@ export type ChartSegmentData = {
     font_scale: number;
     text_color: string;
 };
+export declare const chart_segment_suffix: (amount: number | undefined, fraction: number, show_amounts: boolean, show_percentages: boolean) => string;
+export declare const chart_segment_label: (element: string, amount: number | undefined, fraction: number, show_amounts: boolean, show_percentages: boolean) => string;
 export declare function get_chart_font_scale(base_scale: number, label_text: string, available_space: number, min_scale_factor?: number, base_font_size?: number): number;

package/dist/composition/index.js

@@ -1,3 +1,4 @@
+import { format_num } from '../labels';
 export { default as BarChart } from './BarChart.svelte';
 export { default as BubbleChart } from './BubbleChart.svelte';
 export * from './chem-sys';
@@ -7,6 +8,19 @@ export { default as Formula } from './Formula.svelte';
 export { default as FormulaFilter } from './FormulaFilter.svelte';
 export * from './parse';
 export { default as PieChart } from './PieChart.svelte';
+// Amount/percentage suffix rendered after the element symbol in bar/pie chart
+// segments; `=` separates amount from percentage when both are shown (Fe2=20%).
+// format_num (not toString) so float noise like 0.30000000000000004 can't leak
+// into labels; same format convention as format_composition_formula subscripts
+// (`.3~s`, avoiding SI prefixes for sub-1 amounts where `s` renders 0.5 as 500m)
+export const chart_segment_suffix = (amount, fraction, show_amounts, show_percentages) => (show_amounts && amount !== undefined
+    ? format_num(amount, Math.abs(amount) < 1 ? `.3~g` : `.3~s`)
+    : ``) +
+    (show_amounts && show_percentages ? `=` : ``) +
+    (show_percentages ? format_num(fraction, `.1~%`) : ``);
+// Full segment label used to estimate label width for font scaling; must match
+// the text the charts actually render (element symbol + chart_segment_suffix)
+export const chart_segment_label = (element, amount, fraction, show_amounts, show_percentages) => element + chart_segment_suffix(amount, fraction, show_amounts, show_percentages);
 export function get_chart_font_scale(base_scale, label_text, available_space, min_scale_factor = 0.7, base_font_size = 16) {
     const text_width = label_text.length * 0.6 * base_font_size * base_scale;
     return available_space > 0 && text_width > available_space

package/dist/composition/parse.d.ts

@@ -2,8 +2,8 @@ import type { ElementSymbol } from '../element';
 import type { CompositionType } from './';
 export declare const ATOMIC_NUMBER_TO_SYMBOL: Record<number, ElementSymbol>;
 export declare const SYMBOL_TO_ATOMIC_NUMBER: Partial<CompositionType>;
-export declare const ATOMIC_WEIGHTS: Map<"S" | "K" | "B" | "H" | "He" | "Li" | "Be" | "C" | "N" | "O" | "F" | "Ne" | "Na" | "Mg" | "Al" | "Si" | "P" | "Cl" | "Ar" | "Ca" | "Sc" | "Ti" | "V" | "Cr" | "Mn" | "Fe" | "Co" | "Ni" | "Cu" | "Zn" | "Ga" | "Ge" | "As" | "Se" | "Br" | "Kr" | "Rb" | "Sr" | "Y" | "Zr" | "Nb" | "Mo" | "Tc" | "Ru" | "Rh" | "Pd" | "Ag" | "Cd" | "In" | "Sn" | "Sb" | "Te" | "I" | "Xe" | "Cs" | "Ba" | "La" | "Ce" | "Pr" | "Nd" | "Pm" | "Sm" | "Eu" | "Gd" | "Tb" | "Dy" | "Ho" | "Er" | "Tm" | "Yb" | "Lu" | "Hf" | "Ta" | "W" | "Re" | "Os" | "Ir" | "Pt" | "Au" | "Hg" | "Tl" | "Pb" | "Bi" | "Po" | "At" | "Rn" | "Fr" | "Ra" | "Ac" | "Th" | "Pa" | "U" | "Np" | "Pu" | "Am" | "Cm" | "Bk" | "Cf" | "Es" | "Fm" | "Md" | "No" | "Lr" | "Rf" | "Db" | "Sg" | "Bh" | "Hs" | "Mt" | "Ds" | "Rg" | "Cn" | "Nh" | "Fl" | "Mc" | "Lv" | "Ts" | "Og", number>;
-export declare const ELEMENT_ELECTRONEGATIVITY_MAP: Map<"S" | "K" | "B" | "H" | "He" | "Li" | "Be" | "C" | "N" | "O" | "F" | "Ne" | "Na" | "Mg" | "Al" | "Si" | "P" | "Cl" | "Ar" | "Ca" | "Sc" | "Ti" | "V" | "Cr" | "Mn" | "Fe" | "Co" | "Ni" | "Cu" | "Zn" | "Ga" | "Ge" | "As" | "Se" | "Br" | "Kr" | "Rb" | "Sr" | "Y" | "Zr" | "Nb" | "Mo" | "Tc" | "Ru" | "Rh" | "Pd" | "Ag" | "Cd" | "In" | "Sn" | "Sb" | "Te" | "I" | "Xe" | "Cs" | "Ba" | "La" | "Ce" | "Pr" | "Nd" | "Pm" | "Sm" | "Eu" | "Gd" | "Tb" | "Dy" | "Ho" | "Er" | "Tm" | "Yb" | "Lu" | "Hf" | "Ta" | "W" | "Re" | "Os" | "Ir" | "Pt" | "Au" | "Hg" | "Tl" | "Pb" | "Bi" | "Po" | "At" | "Rn" | "Fr" | "Ra" | "Ac" | "Th" | "Pa" | "U" | "Np" | "Pu" | "Am" | "Cm" | "Bk" | "Cf" | "Es" | "Fm" | "Md" | "No" | "Lr" | "Rf" | "Db" | "Sg" | "Bh" | "Hs" | "Mt" | "Ds" | "Rg" | "Cn" | "Nh" | "Fl" | "Mc" | "Lv" | "Ts" | "Og", number>;
+export declare const ATOMIC_WEIGHTS: Map<"Ac" | "Ag" | "Al" | "Am" | "Ar" | "As" | "At" | "Au" | "B" | "Ba" | "Be" | "Bh" | "Bi" | "Bk" | "Br" | "C" | "Ca" | "Cd" | "Ce" | "Cf" | "Cl" | "Cm" | "Co" | "Cr" | "Cs" | "Cu" | "Db" | "Dy" | "Er" | "Es" | "Eu" | "F" | "Fe" | "Fm" | "Fr" | "Ga" | "Gd" | "Ge" | "H" | "He" | "Hf" | "Hg" | "Ho" | "Hs" | "I" | "In" | "Ir" | "K" | "Kr" | "La" | "Li" | "Lr" | "Lu" | "Md" | "Mg" | "Mn" | "Mo" | "Mt" | "N" | "Na" | "Nb" | "Nd" | "Ne" | "Ni" | "No" | "Np" | "O" | "Os" | "P" | "Pa" | "Pb" | "Pd" | "Pm" | "Po" | "Pr" | "Pt" | "Pu" | "Ra" | "Rb" | "Re" | "Rf" | "Rh" | "Rn" | "Ru" | "S" | "Sb" | "Sc" | "Se" | "Sg" | "Si" | "Sm" | "Sn" | "Sr" | "Ta" | "Tb" | "Tc" | "Te" | "Th" | "Ti" | "Tl" | "Tm" | "U" | "V" | "W" | "Xe" | "Y" | "Yb" | "Zn" | "Zr" | "Ds" | "Rg" | "Cn" | "Nh" | "Fl" | "Mc" | "Lv" | "Ts" | "Og", number>;
+export declare const ELEMENT_ELECTRONEGATIVITY_MAP: Map<"Ac" | "Ag" | "Al" | "Am" | "Ar" | "As" | "At" | "Au" | "B" | "Ba" | "Be" | "Bh" | "Bi" | "Bk" | "Br" | "C" | "Ca" | "Cd" | "Ce" | "Cf" | "Cl" | "Cm" | "Co" | "Cr" | "Cs" | "Cu" | "Db" | "Dy" | "Er" | "Es" | "Eu" | "F" | "Fe" | "Fm" | "Fr" | "Ga" | "Gd" | "Ge" | "H" | "He" | "Hf" | "Hg" | "Ho" | "Hs" | "I" | "In" | "Ir" | "K" | "Kr" | "La" | "Li" | "Lr" | "Lu" | "Md" | "Mg" | "Mn" | "Mo" | "Mt" | "N" | "Na" | "Nb" | "Nd" | "Ne" | "Ni" | "No" | "Np" | "O" | "Os" | "P" | "Pa" | "Pb" | "Pd" | "Pm" | "Po" | "Pr" | "Pt" | "Pu" | "Ra" | "Rb" | "Re" | "Rf" | "Rh" | "Rn" | "Ru" | "S" | "Sb" | "Sc" | "Se" | "Sg" | "Si" | "Sm" | "Sn" | "Sr" | "Ta" | "Tb" | "Tc" | "Te" | "Th" | "Ti" | "Tl" | "Tm" | "U" | "V" | "W" | "Xe" | "Y" | "Yb" | "Zn" | "Zr" | "Ds" | "Rg" | "Cn" | "Nh" | "Fl" | "Mc" | "Lv" | "Ts" | "Og", number>;
 export declare const ELEM_NAME_TO_SYMBOL: Record<string, ElementSymbol>;
 export declare const ELEM_SYMBOL_TO_NAME: Partial<Record<ElementSymbol, string>>;
 export declare const atomic_num_to_symbols: (atomic_composition: Record<number, number>) => CompositionType;

package/dist/composition/parse.js

@@ -1,4 +1,5 @@
-import { element_data, is_elem_symbol } from '../element';
+import { default as element_data } from '../element/data';
+import { is_elem_symbol } from '../element/helpers';
 import { ELEM_SYMBOLS } from '../labels';
 // Create symbol/number/mass/electronegativity lookup maps for O(1) access
 export const ATOMIC_NUMBER_TO_SYMBOL = {};
@@ -24,7 +25,7 @@ const is_atomic_number_composition = (obj) => {
         atomic_nums.every((atomic_num) => Number.isInteger(atomic_num) && Object.hasOwn(ATOMIC_NUMBER_TO_SYMBOL, atomic_num)));
 };
 const format_state = (state) => (state > 0 ? `+` : ``) + state;
-const parse_count = (count) => (count ? parseFloat(count) : 1);
+const parse_count = (count) => (count ? Number(count) : 1);
 const format_count = (count) => {
     if (!Number.isFinite(count))
         return `${count}`;
@@ -49,9 +50,7 @@ export const atomic_num_to_symbols = (atomic_composition) => {
 export const atomic_symbol_to_num = (symbol_composition) => {
     const atomic_composition = {};
     for (const [symbol, amount] of Object.entries(symbol_composition)) {
-        if (!is_elem_symbol(symbol))
-            throw new Error(`Invalid element symbol: ${symbol}`);
-        const atomic_num = SYMBOL_TO_ATOMIC_NUMBER[symbol];
+        const atomic_num = is_elem_symbol(symbol) ? SYMBOL_TO_ATOMIC_NUMBER[symbol] : undefined;
         if (!atomic_num)
             throw new Error(`Invalid element symbol: ${symbol}`);
         if (amount > 0) {
@@ -63,9 +62,9 @@ export const atomic_symbol_to_num = (symbol_composition) => {
 // Expand parentheses in chemical formulas
 const expand_parentheses = (formula) => {
     while (formula.includes(`(`)) {
-        const expanded = formula.replaceAll(/\(([^()]+)\)(\d+(?:\.\d+)?|\.\d+)?/g, (_match, group, multiplier) => {
+        const expanded = formula.replaceAll(/\((?<group>[^()]+)\)(?<multiplier>\d+(?:\.\d+)?|\.\d+)?/g, (_match, group, multiplier) => {
             const mult = parse_count(multiplier);
-            return group.replaceAll(/([A-Z][a-z]?)(\d+(?:\.\d+)?|\.\d+)?/g, (_m, element, count) => {
+            return group.replaceAll(/(?<element>[A-Z][a-z]?)(?<count>\d+(?:\.\d+)?|\.\d+)?/g, (_m, element, count) => {
                 const count_str = format_count(parse_count(count) * mult);
                 return element + (count_str === `1` ? `` : count_str);
             });
@@ -87,9 +86,9 @@ export const parse_formula = (formula) => {
     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 multiplier = coeff ? Number(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)) {
+        for (const match of expanded.matchAll(/(?<element>[A-Z][a-z]?)(?<count>\d+(?:\.\d+)?|\.\d+)?/g)) {
             const [, element, count] = match;
             if (!is_elem_symbol(element))
                 throw new Error(`Invalid element symbol: ${element}`);
@@ -137,9 +136,7 @@ export const fractional_composition = (composition, by_weight = false) => {
     const filtered = Object.fromEntries(Object.entries(composition).filter(([, amount]) => amount > 0));
     if (by_weight) {
         const element_weights = Object.fromEntries(Object.entries(filtered).map(([element, amount]) => {
-            if (!is_elem_symbol(element))
-                throw new Error(`Unknown element: ${element}`);
-            const atomic_mass = ATOMIC_WEIGHTS.get(element);
+            const atomic_mass = is_elem_symbol(element) ? ATOMIC_WEIGHTS.get(element) : undefined;
             if (!atomic_mass)
                 throw new Error(`Unknown element: ${element}`);
             return [element, amount * atomic_mass];
@@ -206,12 +203,12 @@ const parse_oxidation_state = (oxidation_str) => {
         return oxidation_str === `+` ? 1 : -1;
     }
     // Handle formats like "2+", "+2", "2-", "-2"
-    const ox_match = /([+-]?)(\d+)([+-]?)/.exec(oxidation_str);
+    const ox_match = /(?<sign_before>[+-]?)(?<number>\d+)(?<sign_after>[+-]?)/.exec(oxidation_str);
     if (!ox_match)
         return 0;
     const [, sign_before, number, sign_after] = ox_match;
     const sign = sign_before || sign_after || `+`;
-    return sign === `-` ? -parseInt(number, 10) : parseInt(number, 10);
+    return sign === `-` ? -Number(number) : Number(number);
 };
 // Parse chemical formula string with oxidation states into structured data.
 // Supports both ^2+ and [2+] syntax for oxidation states.
@@ -221,46 +218,30 @@ const parse_oxidation_state = (oxidation_str) => {
 export const parse_formula_with_oxidation = (formula, strict = false) => {
     const elements = [];
     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:
-    //          - oxidation then optional count: (?:\^([+-]?\d+[+-]?|[+-])|\[([+-]?\d+[+-]?|[+-])\])(count?)
-    //          - count then optional oxidation: count(?:\^([+-]?\d+[+-]?|[+-])|\[([+-]?\d+[+-]?|[+-])\])?
-    //          - just oxidation: (?:\^([+-]?\d+[+-]?|[+-])|\[([+-]?\d+[+-]?|[+-])\])
-    //          - just count: count
-    //          - neither
-    const regex = /([A-Z][a-z]?)(?:(?:\^([+-]?\d+[+-]?|[+-])|\[([+-]?\d+[+-]?|[+-])\])((?:\d+(?:\.\d+)?|\.\d+)?)|((?:\d+(?:\.\d+)?|\.\d+))(?:\^([+-]?\d+[+-]?|[+-])|\[([+-]?\d+[+-]?|[+-])\])?)?/g;
-    let match;
-    let orig_idx = 0;
-    while ((match = regex.exec(cleaned_formula)) !== null) {
-        const element = match[1];
-        // Oxidation can be in groups 2/3 (oxidation first) or 6/7 (count first)
-        // Count can be in group 4 (after oxidation) or 5 (before oxidation)
-        const oxidation_str = match[2] || match[3] || match[6] || match[7];
-        const count_str = match[4] || match[5];
-        const count = parse_count(count_str);
+    // Element symbol followed by optional oxidation state (^2+ or [2+] syntax) and
+    // optional count, in either order: Fe^2+O3, Fe[2+]O3, Fe3^2+, Fe2
+    const regex = /(?<element>[A-Z][a-z]?)(?:(?:\^(?<oxi_caret>[+-]?\d+[+-]?|[+-])|\[(?<oxi_bracket>[+-]?\d+[+-]?|[+-])\])(?<count_after>(?:\d+(?:\.\d+)?|\.\d+)?)|(?<count_before>(?:\d+(?:\.\d+)?|\.\d+))(?:\^(?<oxi_caret_2>[+-]?\d+[+-]?|[+-])|\[(?<oxi_bracket_2>[+-]?\d+[+-]?|[+-])\])?)?/g;
+    for (const match of cleaned_formula.matchAll(regex)) {
+        const groups = match.groups ?? {};
+        const element = groups.element;
+        const oxidation_str = groups.oxi_caret || groups.oxi_bracket || groups.oxi_caret_2 || groups.oxi_bracket_2;
+        const count = parse_count(groups.count_after || groups.count_before);
         if (!is_elem_symbol(element))
             throw new Error(`Invalid element symbol: ${element}`);
         const oxidation_state = oxidation_str ? parse_oxidation_state(oxidation_str) : undefined;
-        // Find or add element entry
         const existing = elements.find((el) => el.element === element);
-        if (existing) {
-            existing.amount += count;
-            // Handle oxidation state conflicts
-            if (oxidation_state === undefined) {
-                // No oxidation state in current match, nothing to do
-            }
-            else if (existing.oxidation_state === undefined) {
-                // Set oxidation state on first occurrence
-                existing.oxidation_state = oxidation_state;
-            }
-            else if (strict && existing.oxidation_state !== oxidation_state) {
-                // In strict mode, throw on conflicting oxidation states
-                throw new Error(`Conflicting oxidation states for ${element}: ${format_state(existing.oxidation_state)} and ${format_state(oxidation_state)}`);
-            }
+        if (!existing) {
+            elements.push({ element, amount: count, oxidation_state, orig_idx: elements.length });
+            continue;
         }
-        else {
-            elements.push({ element, amount: count, oxidation_state, orig_idx: orig_idx++ });
+        existing.amount += count;
+        if (oxidation_state === undefined)
+            continue;
+        if (existing.oxidation_state === undefined) {
+            existing.oxidation_state = oxidation_state; // Set on first occurrence
+        }
+        else if (strict && existing.oxidation_state !== oxidation_state) {
+            throw new Error(`Conflicting oxidation states for ${element}: ${format_state(existing.oxidation_state)} and ${format_state(oxidation_state)}`);
         }
     }
     return elements;
@@ -297,20 +278,12 @@ export function generate_chem_sys_subspaces(input) {
     let elements;
     if (typeof input === `string`)
         elements = extract_formula_elements(input);
-    else if (Array.isArray(input)) {
-        const uniq = [...new Set(input)];
-        for (const elem of uniq) {
-            if (!is_elem_symbol(elem))
-                throw new Error(`Invalid element symbol: ${elem}`);
-        }
-        elements = uniq;
-    }
     else {
-        elements = [];
-        for (const elem of Object.keys(input)) {
+        const symbols = Array.isArray(input) ? input : Object.keys(input);
+        elements = [...new Set(symbols)];
+        for (const elem of elements) {
             if (!is_elem_symbol(elem))
                 throw new Error(`Invalid element symbol: ${elem}`);
-            elements.push(elem);
         }
     }
     const sorted = [...elements].sort();
@@ -342,7 +315,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
-        .replaceAll('-', `,`)
+        .replaceAll(`-`, `,`)
         .split(`,`)
         .map((tok) => tok.trim())
         .filter(Boolean);
@@ -377,32 +350,21 @@ export const ELEM_WILDCARD = {
 //   "**O4" -> *(1), *(1), O(4) - matches ternary oxides with 1:1:4 ratio
 export function parse_formula_with_wildcards(formula) {
     const tokens = [];
-    // Expand parentheses, treating * as a pseudo-element (temporarily replace to protect it)
+    // Swap * for a placeholder so parentheses expansion treats it as a pseudo-element
     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);
-    // Restore wildcards
     cleaned = cleaned.replace(ELEM_WILDCARD.from_placeholder, `*`);
-    // Regex to match either:
-    // 1. Standard element symbol with optional decimal count
-    // 2. Wildcard with optional decimal count
-    const regex = /([A-Z][a-z]?)((?:\d+(?:\.\d+)?|\.\d+)?)|(\*)((?:\d+(?:\.\d+)?|\.\d+)?)/g;
-    let match;
-    while ((match = regex.exec(cleaned)) !== null) {
-        if (match[3] === `*`) {
-            // Wildcard match
-            const count = parse_count(match[4]);
-            tokens.push({ element: null, count });
-        }
-        else if (match[1]) {
-            // Element symbol match
-            const element = match[1];
-            const count = parse_count(match[2]);
-            if (!is_elem_symbol(element)) {
+    // Match element symbol or wildcard, each with optional decimal count
+    const regex = /(?<element>[A-Z][a-z]?)(?<count>(?:\d+(?:\.\d+)?|\.\d+)?)|(?<wildcard>\*)(?<wildcard_count>(?:\d+(?:\.\d+)?|\.\d+)?)/g;
+    for (const match of cleaned.matchAll(regex)) {
+        const { element, count, wildcard, wildcard_count } = match.groups ?? {};
+        if (wildcard)
+            tokens.push({ element: null, count: parse_count(wildcard_count) });
+        else if (element) {
+            if (!is_elem_symbol(element))
                 throw new Error(`Invalid element symbol: ${element}`);
-            }
-            tokens.push({ element, count });
+            tokens.push({ element, count: parse_count(count) });
         }
     }
     return tokens;
@@ -435,48 +397,32 @@ export function matches_chemsys_wildcard(formula, explicit_elements, wildcard_co
 export function matches_formula_wildcard(formula, pattern) {
     try {
         const composition = parse_formula(formula);
-        // Separate explicit elements and wildcards from pattern
-        const explicit_requirements = [];
+        // Split pattern into merged explicit element counts (e.g. "LiLi" -> Li: 2)
+        // and wildcard counts
+        const explicit_counts = new Map();
         const wildcard_counts = [];
         for (const token of pattern) {
-            if (token.element === null) {
+            if (token.element === null)
                 wildcard_counts.push(token.count);
-            }
             else {
-                // Merge counts for same element (e.g. "LiLi" -> Li with count 2)
-                const existing = explicit_requirements.find((req) => req.element === token.element);
-                if (existing) {
-                    existing.count += token.count;
-                }
-                else {
-                    explicit_requirements.push({ element: token.element, count: token.count });
-                }
+                explicit_counts.set(token.element, (explicit_counts.get(token.element) ?? 0) + token.count);
             }
         }
-        // Check explicit element requirements
-        const used_elements = new Set();
-        for (const req of explicit_requirements) {
-            if (composition[req.element] !== req.count)
+        for (const [element, count] of explicit_counts) {
+            if (composition[element] !== count)
                 return false;
-            used_elements.add(req.element);
         }
-        // Get remaining elements (candidates for wildcards)
-        const remaining_elements = Object.entries(composition)
-            .filter(([elem]) => !used_elements.has(elem))
-            .map(([elem, count]) => ({ elem, count }));
-        // Must have exactly as many remaining elements as wildcards
-        if (remaining_elements.length !== wildcard_counts.length)
+        // Remaining elements are wildcard candidates. Each wildcard needs a distinct
+        // element with exactly its count, so sorting both count lists reduces the
+        // matching to a positional comparison
+        const remaining_counts = Object.entries(composition)
+            .filter(([elem]) => !explicit_counts.has(elem))
+            .map(([, count]) => count)
+            .sort((cnt_a, cnt_b) => cnt_a - cnt_b);
+        if (remaining_counts.length !== wildcard_counts.length)
             return false;
-        // Try to match remaining elements to wildcards (each wildcard needs a distinct element)
-        // Sort both by count to enable greedy matching
-        const sorted_remaining = [...remaining_elements].sort((a, b) => a.count - b.count);
-        const sorted_wildcards = [...wildcard_counts].sort((a, b) => a - b);
-        // Check if counts match (simple comparison works because we need exact matches)
-        for (let idx = 0; idx < sorted_wildcards.length; idx++) {
-            if (sorted_remaining[idx].count !== sorted_wildcards[idx])
-                return false;
-        }
-        return true;
+        wildcard_counts.sort((cnt_a, cnt_b) => cnt_a - cnt_b);
+        return wildcard_counts.every((count, idx) => remaining_counts[idx] === count);
     }
     catch {
         return false;

package/dist/constants.d.ts

@@ -13,7 +13,6 @@ export declare const STRUCT_KEYWORDS_STRICT: readonly string[];
 export declare const TRAJ_KEYWORDS_REGEX: RegExp;
 export declare const STRUCT_KEYWORDS_REGEX: RegExp;
 export declare const STRUCT_KEYWORDS_STRICT_REGEX: RegExp;
-export declare const TRAJ_KEYWORDS_SIMPLE_REGEX: RegExp;
 export declare const TRAJ_EXTENSIONS: readonly string[];
 export declare const TRAJ_EXTENSIONS_REGEX: RegExp;
 export declare const STRUCTURE_EXTENSIONS: readonly string[];

package/dist/constants.js

@@ -14,11 +14,13 @@ export const COMPRESSION_EXTENSIONS = Object.freeze(Object.values(COMPRESSION_FO
 export const TRAJ_KEYWORDS = Object.freeze([
     `trajectory`,
     `traj`,
+    `relaxation`,
     `relax`,
     `npt`,
     `nvt`,
     `nve`,
     `qha`,
+    `dpmd`, // DeePMD trajectory outputs (before `md` so the longer token wins)
     `md`,
     `dynamics`,
     `simulation`,
@@ -41,29 +43,18 @@ export const STRUCT_KEYWORDS = Object.freeze([
     `phonopy`,
 ]);
 // More restrictive keywords for JSON/YAML files (excludes generic terms like "data")
-export const STRUCT_KEYWORDS_STRICT = Object.freeze([
-    `structure`,
-    `phono`,
-    `vasp`,
-    `crystal`,
-    `material`,
-    `lattice`,
-    `geometry`,
-    `unit_cell`,
-    `unitcell`,
-    `atoms`,
-    `sites`,
-    `phono3py`,
-    `phonopy`,
-]);
-// Regex patterns for keyword matching
+export const STRUCT_KEYWORDS_STRICT = Object.freeze(STRUCT_KEYWORDS.filter((keyword) => keyword !== `data`));
+// Regex patterns for keyword matching. Keywords must be delimited on both sides
+// (`md_300K`, `si_md.log`) so bare prefixes like `md/notes.log` or `mdp_run` do not
+// match. `relaxation` is listed explicitly (not only via the `relax` prefix).
 export const TRAJ_KEYWORDS_REGEX = new RegExp(`(^|[-_.])(${TRAJ_KEYWORDS.join(`|`)})([-_.]|$)`, `i`);
 export const STRUCT_KEYWORDS_REGEX = new RegExp(`(${STRUCT_KEYWORDS.join(`|`)})`, `i`);
 export const STRUCT_KEYWORDS_STRICT_REGEX = new RegExp(`(${STRUCT_KEYWORDS_STRICT.join(`|`)})`, `i`);
-export const TRAJ_KEYWORDS_SIMPLE_REGEX = new RegExp(`(${TRAJ_KEYWORDS.join(`|`)})`, `i`);
+// Build a case-insensitive `\.(ext1|ext2|...)$` regex from extensions (leading dots stripped)
+const ext_regex = (exts) => new RegExp(`\\.(${exts.map((ext) => ext.slice(1)).join(`|`)})$`, `i`);
 // File extensions for different file types
 export const TRAJ_EXTENSIONS = Object.freeze([`.traj`, `.xtc`, `.lammpstrj`]);
-export const TRAJ_EXTENSIONS_REGEX = new RegExp(`\\.(${TRAJ_EXTENSIONS.map((ext) => ext.slice(1)).join(`|`)})$`, `i`);
+export const TRAJ_EXTENSIONS_REGEX = ext_regex(TRAJ_EXTENSIONS);
 export const STRUCTURE_EXTENSIONS = Object.freeze([
     `.cif`,
     `.mcif`,
@@ -79,7 +70,7 @@ export const STRUCTURE_EXTENSIONS = Object.freeze([
     `.sdf`,
     `.mmcif`,
 ]);
-export const STRUCTURE_EXTENSIONS_REGEX = new RegExp(`\\.(${STRUCTURE_EXTENSIONS.map((ext) => ext.slice(1)).join(`|`)})$`, `i`);
+export const STRUCTURE_EXTENSIONS_REGEX = ext_regex(STRUCTURE_EXTENSIONS);
 export const TRAJ_FALLBACK_EXTENSIONS = Object.freeze([
     `.dat`,
     `.data`,
@@ -87,13 +78,13 @@ export const TRAJ_FALLBACK_EXTENSIONS = Object.freeze([
     `.out`,
     `.json`,
 ]);
-export const TRAJ_FALLBACK_EXTENSIONS_REGEX = new RegExp(`\\.(${TRAJ_FALLBACK_EXTENSIONS.map((ext) => ext.slice(1)).join(`|`)})$`, `i`);
+export const TRAJ_FALLBACK_EXTENSIONS_REGEX = ext_regex(TRAJ_FALLBACK_EXTENSIONS);
 // Special regex patterns
-export const VASP_FILES_REGEX = /(?:^|[\\/_.-])(poscar|contcar|potcar|incar|kpoints|outcar)(?:[\\/_.-]|$)/i;
-export const VASP_VOLUMETRIC_REGEX = /(?:^|[\\/_.-])(chgcar|aeccar[012]?|elfcar|locpot|parchg)(?:[\\/_.-]|$)/i;
+export const VASP_FILES_REGEX = /(?:^|[\\/_.-])(?:poscar|contcar|potcar|incar|kpoints|outcar)(?:[\\/_.-]|$)/i;
+export const VASP_VOLUMETRIC_REGEX = /(?:^|[\\/_.-])(?:chgcar|aeccar[012]?|elfcar|locpot|parchg)(?:[\\/_.-]|$)/i;
 export const XDATCAR_REGEX = /xdatcar/i;
-export const CONFIG_DIRS_REGEX = /(?:^|[\\/])(\.vscode|\.idea|\.nyc_output|\.cache|\.tmp|\.temp|node_modules|dist|build|coverage)(?:[\\/]|$)/i;
-export const MD_SIM_EXCLUDE_REGEX = /md_simulation\.(out|txt|yml|py|csv|html|css|md|js|ts)$/i;
-export const XYZ_EXTXYZ_REGEX = /\.(xyz|extxyz)$/i;
+export const CONFIG_DIRS_REGEX = /(?:^|[\\/])(?:\.vscode|\.idea|\.nyc_output|\.cache|\.tmp|\.temp|node_modules|dist|build|coverage)(?:[\\/]|$)/i;
+export const MD_SIM_EXCLUDE_REGEX = /md_simulation\.(?:out|txt|yml|py|csv|html|css|md|js|ts)$/i;
+export const XYZ_EXTXYZ_REGEX = /\.(?:xyz|extxyz)$/i;
 // Compression extensions regex (shared across files)
-export const COMPRESSION_EXTENSIONS_REGEX = new RegExp(`\\.(${COMPRESSION_EXTENSIONS.map((ext) => ext.slice(1)).join(`|`)})$`, `i`);
+export const COMPRESSION_EXTENSIONS_REGEX = ext_regex(COMPRESSION_EXTENSIONS);

package/dist/convex-hull/ConvexHull.svelte

@@ -12,10 +12,11 @@
   // Union type combining all possible props from 2D, 3D, and 4D components
   // each specific component will only use its relevant props from this super set
   // (gas_config/gas_pressures already come from BaseConvexHullProps)
-  type ConvexHullProps = BaseConvexHullProps & Hull3DProps & {
-    x_axis?: AxisConfig
-    y_axis?: AxisConfig
-  }
+  type ConvexHullProps = BaseConvexHullProps &
+    Hull3DProps & {
+      x_axis?: AxisConfig
+      y_axis?: AxisConfig
+    }
 
   let {
     entries = [],
@@ -26,9 +27,7 @@
     show_unstable = $bindable(true),
     hidden_categories = $bindable([]),
     show_hull_faces = $bindable(true),
-    hull_face_opacity: hull_face_opacity_prop = $bindable(
-      undefined as number | undefined,
-    ),
+    hull_face_opacity: hull_face_opacity_prop = $bindable(undefined as number | undefined),
     color_mode = $bindable(`energy`),
     color_scale = $bindable(`interpolateViridis`),
     info_pane_open = $bindable(false),
@@ -88,8 +87,7 @@
   // while each component declares only its dimension's props (2D lacks Hull3DProps, 3D/4D
   // lack x/y_axis), so a constructor union wouldn't compile. Svelte ignores extra props.
   const ConvexHullComponent = $derived(
-    { 2: ConvexHull2D, 3: ConvexHull3D, 4: ConvexHull4D }[element_count] ??
-      null,
+    { 2: ConvexHull2D, 3: ConvexHull3D, 4: ConvexHull4D }[element_count] ?? null,
   ) as Component<ConvexHullProps> | null
 </script>
 
@@ -125,14 +123,13 @@
 {:else}
   <!-- Error state for unsupported dimensionalities -->
   <div class="convex-hull-error">
-    <div
-      style="text-align: center; padding: 2em; color: var(--convex-hull-text-color, #666)"
-    >
+    <div style="text-align: center; padding: 2em; color: var(--convex-hull-text-color, #666)">
       <h3 id="unsupported-chemical-system" style="margin: 0 0 1em 0">Unsupported Chemical System</h3>
       <p style="margin: 0">
-        Convex hulls require 2, 3, or 4 elements. Found {element_count} element{
-          element_count === 1 ? `` : `s`
-        }:
+        Convex hulls require 2, 3, or 4 elements. Found {element_count} element{element_count ===
+        1
+          ? ``
+          : `s`}:
       </p>
       <p style="margin: 0.5em 0 0 0; font-weight: bold">
         {elements.join(`, `)}

package/dist/convex-hull/ConvexHull.svelte.d.ts

@@ -5,6 +5,6 @@ type ConvexHullProps = BaseConvexHullProps & Hull3DProps & {
     x_axis?: AxisConfig;
     y_axis?: AxisConfig;
 };
-declare const ConvexHull: Component<ConvexHullProps, {}, "display" | "temperature" | "fullscreen" | "wrapper" | "controls_open" | "color_scale" | "info_pane_open" | "show_hull_faces" | "hull_face_opacity" | "color_mode" | "show_stable" | "show_unstable" | "show_stable_labels" | "show_unstable_labels" | "max_hull_dist_show_phases" | "max_hull_dist_show_labels" | "hidden_categories" | "energy_source_mode" | "stable_entries" | "unstable_entries" | "phase_stats" | "highlighted_entries" | "selected_entry" | "gas_pressures">;
+declare const ConvexHull: Component<ConvexHullProps, {}, "display" | "fullscreen" | "wrapper" | "controls_open" | "color_scale" | "info_pane_open" | "temperature" | "show_hull_faces" | "hull_face_opacity" | "color_mode" | "show_stable" | "show_unstable" | "show_stable_labels" | "show_unstable_labels" | "max_hull_dist_show_phases" | "max_hull_dist_show_labels" | "hidden_categories" | "energy_source_mode" | "stable_entries" | "unstable_entries" | "phase_stats" | "highlighted_entries" | "selected_entry" | "gas_pressures">;
 type ConvexHull = ReturnType<typeof ConvexHull>;
 export default ConvexHull;