matterviz 0.3.4 → 0.3.6

package/dist/composition/parse.js

@@ -1,459 +0,0 @@
-import { element_data } from '../element';
-import { ELEM_SYMBOLS } from '../labels';
-// Create symbol/number/mass/electronegativity lookup maps for O(1) access
-export const ATOMIC_NUMBER_TO_SYMBOL = {};
-export const SYMBOL_TO_ATOMIC_NUMBER = {};
-export const ATOMIC_WEIGHTS = new Map();
-export const ELEMENT_ELECTRONEGATIVITY_MAP = new Map();
-export const ELEM_NAME_TO_SYMBOL = {};
-export const ELEM_SYMBOL_TO_NAME = {};
-// Populate maps at module load time
-for (const element of element_data) {
-    ATOMIC_NUMBER_TO_SYMBOL[element.number] = element.symbol;
-    SYMBOL_TO_ATOMIC_NUMBER[element.symbol] = element.number;
-    ATOMIC_WEIGHTS.set(element.symbol, element.atomic_mass);
-    ELEMENT_ELECTRONEGATIVITY_MAP.set(element.symbol, element.electronegativity ?? 0);
-    ELEM_NAME_TO_SYMBOL[element.name] = element.symbol;
-    ELEM_SYMBOL_TO_NAME[element.symbol] = element.name;
-}
-// Type guard: check if a string is a valid element symbol
-export const is_valid_element = (sym) => ELEM_SYMBOLS.includes(sym);
-// Check if object has atomic numbers as keys (1-118)
-const is_atomic_number_composition = (obj) => {
-    const keys = Object.keys(obj);
-    return (keys.length > 0 &&
-        keys.map(Number).every((num) => Number.isInteger(num) && num >= 1 && num <= 118));
-};
-// Convert atomic numbers to element symbols
-export const atomic_num_to_symbols = (atomic_composition) => {
-    const composition = {};
-    for (const [atomic_num_str, amount] of Object.entries(atomic_composition)) {
-        const symbol = ATOMIC_NUMBER_TO_SYMBOL[Number(atomic_num_str)];
-        if (!symbol)
-            throw new Error(`Invalid atomic number: ${atomic_num_str}`);
-        if (amount > 0)
-            composition[symbol] = (composition[symbol] || 0) + amount;
-    }
-    return composition;
-};
-// Convert element symbols to atomic numbers
-export const atomic_symbol_to_num = (symbol_composition) => {
-    const atomic_composition = {};
-    for (const [symbol, amount] of Object.entries(symbol_composition)) {
-        const atomic_num = SYMBOL_TO_ATOMIC_NUMBER[symbol];
-        if (!atomic_num)
-            throw new Error(`Invalid element symbol: ${symbol}`);
-        if (amount > 0) {
-            atomic_composition[atomic_num] = (atomic_composition[atomic_num] || 0) + amount;
-        }
-    }
-    return atomic_composition;
-};
-// Expand parentheses in chemical formulas
-const expand_parentheses = (formula) => {
-    while (formula.includes(`(`)) {
-        formula = formula.replace(/\(([^()]+)\)(\d*)/g, (_match, group, multiplier) => {
-            const mult = multiplier ? parseInt(multiplier, 10) : 1;
-            return group.replace(/([A-Z][a-z]?)(\d*)/g, (_m, element, count) => {
-                const num = (count ? parseInt(count, 10) : 1) * mult;
-                return element + (num > 1 ? num : ``);
-            });
-        });
-    }
-    return formula;
-};
-// Parse chemical formula string into composition object
-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*)/g)) {
-        const element = match[1];
-        const count = match[2] ? parseInt(match[2], 10) : 1;
-        if (!is_valid_element(element))
-            throw new Error(`Invalid element symbol: ${element}`);
-        composition[element] = (composition[element] || 0) + count;
-    }
-    return composition;
-};
-// Normalize composition to positive numbers only
-export const normalize_composition = (composition) => {
-    if (is_atomic_number_composition(composition)) {
-        return normalize_composition(atomic_num_to_symbols(composition));
-    }
-    const normalized = {};
-    for (const [element, amount] of Object.entries(composition)) {
-        if (typeof amount === `number` && amount > 0) {
-            normalized[element] = amount;
-        }
-    }
-    return normalized;
-};
-// Sanitize composition keys by extracting valid element symbols.
-// Handles malformed keys like "B0.", "Fe2+", "Fe[2+]", "Ca^2+" by extracting
-// the element symbol portion. Merges amounts for keys that map to the same element.
-// Returns null if no valid elements can be extracted.
-// NOTE: Only extracts the FIRST valid element from each key. Keys with multiple
-// elements (e.g. "CO3", "Fe2O3") will lose stoichiometry - use parse_formula for those.
-export const sanitize_composition_keys = (composition) => {
-    const sanitized = {};
-    for (const [key, amount] of Object.entries(composition)) {
-        if (typeof amount !== `number` || amount <= 0)
-            continue;
-        // Extract first valid element symbol from key (e.g. "B0." -> "B", "Fe2+" -> "Fe")
-        const elem = (key.match(/[A-Z][a-z]?/g) || []).find(is_valid_element);
-        if (elem)
-            sanitized[elem] = (sanitized[elem] || 0) + amount;
-    }
-    const result = normalize_composition(sanitized);
-    return Object.keys(result).length > 0 ? result : null;
-};
-// Get total number of atoms
-export const count_atoms_in_composition = (composition) => Object.values(composition).reduce((sum, count) => sum + (count ?? 0), 0);
-export const fractional_composition = (composition, by_weight = false) => {
-    // Filter out zero/negative amounts for both branches
-    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]) => {
-            const atomic_mass = ATOMIC_WEIGHTS.get(element);
-            if (!atomic_mass)
-                throw new Error(`Unknown element: ${element}`);
-            return [element, amount * atomic_mass];
-        }));
-        const total_weight = Object.values(element_weights).reduce((sum, wt) => sum + wt, 0);
-        if (total_weight === 0)
-            return {};
-        return Object.fromEntries(Object.entries(element_weights).map(([element, weight]) => [
-            element,
-            weight / total_weight,
-        ]));
-    }
-    const total = count_atoms_in_composition(filtered);
-    if (total === 0)
-        return {};
-    return Object.fromEntries(Object.entries(filtered).map(([element, amount]) => [element, amount / total]));
-};
-// Parse composition from various input types
-export const parse_composition = (input) => {
-    if (typeof input === `string`) {
-        if (input.trim().startsWith(`{`) && input.trim().endsWith(`}`)) {
-            try {
-                return normalize_composition(JSON.parse(input));
-            }
-            catch {
-                // Fall through to formula parsing
-            }
-        }
-        return normalize_composition(parse_formula(input));
-    }
-    return normalize_composition(input);
-};
-// Calculate GCD of two numbers
-const gcd = (num_a, num_b) => num_b === 0 ? num_a : gcd(num_b, num_a % num_b);
-// Get reduced formula by dividing all amounts by their GCD
-// Example: Fe2O4 -> FeO2, H4O2 -> H2O
-export const get_reduced_formula = (composition) => {
-    const amounts = Object.values(composition).filter((amt) => amt > 0);
-    if (amounts.length === 0)
-        return {};
-    // Find GCD of all amounts (works with integers; for floats, find approximate GCD)
-    const all_integers = amounts.every((amt) => Number.isInteger(amt));
-    if (!all_integers)
-        return composition; // Can't reduce non-integer compositions
-    const divisor = amounts.reduce((acc, amt) => gcd(acc, amt));
-    if (divisor <= 1)
-        return composition;
-    return Object.fromEntries(Object.entries(composition).map(([elem, amt]) => [elem, amt / divisor]));
-};
-// Calculate molecular weight (sum of atomic masses * amounts)
-export const get_molecular_weight = (composition) => Object.entries(composition).reduce((total, [elem, amount]) => {
-    const mass = ATOMIC_WEIGHTS.get(elem) ?? 0;
-    return total + mass * amount;
-}, 0);
-// Parse oxidation state string (e.g. "+2", "2+", "-", "[2-]") to number
-const parse_oxidation_state = (oxidation_str) => {
-    // Handle bare signs: "+", "-" are treated as ±1
-    if (oxidation_str === `+` || oxidation_str === `-`) {
-        return oxidation_str === `+` ? 1 : -1;
-    }
-    // Handle formats like "2+", "+2", "2-", "-2"
-    const ox_match = /([+-]?)(\d+)([+-]?)/.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);
-};
-// Parse chemical formula string with oxidation states into structured data.
-// Supports both ^2+ and [2+] syntax for oxidation states.
-// Examples: "Fe^2+O3", "Fe[2+]O3", "Ca^2+Cl^-2"
-// Tracks original element order from the input string.
-// 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, ``));
-    // 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+[+-]?|[+-])\])(\d*)
-    //          - count then optional oxidation: (\d+)(?:\^([+-]?\d+[+-]?|[+-])|\[([+-]?\d+[+-]?|[+-])\])?
-    //          - just oxidation: (?:\^([+-]?\d+[+-]?|[+-])|\[([+-]?\d+[+-]?|[+-])\])
-    //          - just count: (\d+)
-    //          - neither
-    const regex = /([A-Z][a-z]?)(?:(?:\^([+-]?\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 = count_str ? parseInt(count_str, 10) : 1;
-        if (!is_valid_element(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
-                const format_state = (state) => (state > 0 ? `+` : ``) + state;
-                throw new Error(`Conflicting oxidation states for ${element}: ${format_state(existing.oxidation_state)} and ${format_state(oxidation_state)}`);
-            }
-        }
-        else {
-            elements.push({ element, amount: count, oxidation_state, orig_idx: orig_idx++ });
-        }
-    }
-    return elements;
-};
-// Convert OxiComposition to ElementWithOxidation array
-// Does not preserve original order since objects don't have a defined order
-export const oxi_composition_to_elements = (composition) => Object.entries(composition).map(([element, data], idx) => ({
-    element: element,
-    amount: data.amount,
-    oxidation_state: data.oxidation_state,
-    orig_idx: idx,
-}));
-// Extract element symbols from a chemical formula.
-// Default (unique=true, sorted=true): "NbZr2Nb" -> ["Nb", "Zr"]
-// unique=false: Fast token extraction preserving order without parentheses expansion
-//   "NbZr2Nb" -> ["Nb", "Zr", "Nb"], "Fe2(SO4)3" -> ["Fe", "S", "O"]
-//   Validates tokens against ELEM_SYMBOLS, filtering out invalid ones.
-// sorted=false: Preserves order of first appearance (only applies when unique=true)
-//   "ZrNb" -> ["Zr", "Nb"]
-export function extract_formula_elements(formula, { unique = true, sorted = true } = {}) {
-    if (!unique) {
-        // Fast path: regex token extraction without parentheses expansion
-        const matches = formula.match(/[A-Z][a-z]?/g) || [];
-        return matches.filter(is_valid_element);
-    }
-    const symbols = Object.keys(parse_formula(formula));
-    return sorted ? symbols.sort() : symbols;
-}
-// Generate all non-empty subsets of a chemical system as hyphenated strings.
-// Input: formula string, composition object, or element symbol array
-// Output: All subsets sorted alphabetically: ["B", "Mo", "Sc", "B-Mo", "B-Sc", "Mo-Sc", "B-Mo-Sc"]
-// Complexity: O(2^n) where n = number of unique elements (fine for typical ~1-5 elements)
-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_valid_element(elem))
-                throw new Error(`Invalid element symbol: ${elem}`);
-        }
-        elements = uniq;
-    }
-    else {
-        const keys = Object.keys(input);
-        for (const elem of keys) {
-            if (!is_valid_element(elem))
-                throw new Error(`Invalid element symbol: ${elem}`);
-        }
-        elements = keys;
-    }
-    const sorted = [...elements].sort();
-    const subspaces = [];
-    const subset_count = 2 ** sorted.length;
-    for (let mask = 1; mask < subset_count; mask++) {
-        const subset = [];
-        for (let idx = 0; idx < sorted.length; idx++) {
-            if (mask & (1 << idx))
-                subset.push(sorted[idx]);
-        }
-        subspaces.push(subset.join(`-`));
-    }
-    return subspaces;
-}
-// Normalize CSV of element symbols to valid symbols in periodic order.
-// Filters invalid symbols, removes duplicates, trims whitespace.
-// Example: "Zr, Nb, InvalidElement, H" -> ["H", "Nb", "Zr"]
-// Note: Matching is case-sensitive. Use all_symbols to filter against a subset.
-export const normalize_element_symbols = (csv, all_symbols) => {
-    const input_set = new Set(csv
-        .split(`,`)
-        .map((sym) => sym.trim())
-        .filter(Boolean));
-    // Cast needed: ELEM_SYMBOLS is readonly const tuple, T is generic string subtype
-    return (all_symbols ?? ELEM_SYMBOLS).filter((sym) => input_set.has(sym));
-};
-// Check if input contains wildcard elements (*).
-// Works for both chemsys format (Li-Fe-*-*) and exact formula format (LiFe*2*).
-export const has_wildcards = (input) => input.includes(`*`);
-// Parse chemsys format with wildcards: "Li-Fe-*-*" -> { elements: ["Li", "Fe"], wildcard_count: 2 }
-// Accepts both hyphen and comma separators.
-// Throws if any non-wildcard token is not a valid element symbol.
-export function parse_chemsys_with_wildcards(input) {
-    const tokens = input
-        .replace(/-/g, `,`)
-        .split(`,`)
-        .map((tok) => tok.trim())
-        .filter(Boolean);
-    const elements = [];
-    let wildcard_count = 0;
-    for (const token of tokens) {
-        if (token === `*`) {
-            wildcard_count++;
-        }
-        else if (is_valid_element(token)) {
-            elements.push(token);
-        }
-        else {
-            throw new Error(`Invalid element symbol or wildcard: ${token}`);
-        }
-    }
-    return { elements: elements.sort(), wildcard_count };
-}
-// Placeholder for wildcards during parentheses expansion (Zz is not a real element symbol).
-// Use static regex literals to avoid escaping issues if placeholder ever changes.
-export const ELEM_WILDCARD = {
-    placeholder: `Zz`,
-    to_placeholder: /\*/g,
-    from_placeholder: /Zz/g,
-};
-// Parse exact formula with wildcards: "LiFe*2*" -> [{ element: "Li", count: 1 }, { element: "Fe", count: 1 }, { element: null, count: 2 }, { element: null, count: 1 }]
-// The * character represents any element, optionally followed by a count.
-// Each * in the pattern represents a distinct element position (wildcards cannot share elements).
-// Examples:
-//   "LiFe*2*" -> Li(1), Fe(1), *(2), *(1) - matches formulas with 4 distinct elements
-//   "*2O3" -> *(2), O(3) - matches any binary oxide with 2:3 ratio
-//   "**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)
-    let cleaned = formula.replace(/\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 count: ([A-Z][a-z]?)(\d*)
-    // 2. Wildcard with optional count: \*(\d*)
-    const regex = /([A-Z][a-z]?)(\d*)|(\*)(\d*)/g;
-    let match;
-    while ((match = regex.exec(cleaned)) !== null) {
-        if (match[3] === `*`) {
-            // Wildcard match
-            const count = match[4] ? parseInt(match[4], 10) : 1;
-            tokens.push({ element: null, count });
-        }
-        else if (match[1]) {
-            // Element symbol match
-            const element = match[1];
-            const count = match[2] ? parseInt(match[2], 10) : 1;
-            if (!is_valid_element(element)) {
-                throw new Error(`Invalid element symbol: ${element}`);
-            }
-            tokens.push({ element, count });
-        }
-    }
-    return tokens;
-}
-// Check if a formula matches a chemsys pattern with wildcards.
-// The formula must contain exactly the specified elements plus wildcard_count additional distinct elements.
-// Example: matches_chemsys_wildcard("LiFeCoO", ["Li", "Fe"], 2) -> true (Co and O fill the wildcards)
-export function matches_chemsys_wildcard(formula, explicit_elements, wildcard_count) {
-    try {
-        const formula_elements = extract_formula_elements(formula, { unique: true });
-        const required_count = explicit_elements.length + wildcard_count;
-        // Must have exactly the right number of elements
-        if (formula_elements.length !== required_count)
-            return false;
-        // Must contain all explicit elements
-        const formula_set = new Set(formula_elements);
-        for (const elem of explicit_elements) {
-            if (!formula_set.has(elem))
-                return false;
-        }
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// Check if a formula matches an exact formula pattern with wildcards.
-// Each wildcard (*) must be satisfied by a distinct element not used by explicit elements or other wildcards.
-// Example: matches_formula_wildcard("LiFeCoNiO4", [{element: "Li", count: 1}, {element: null, count: 1}, ...])
-export function matches_formula_wildcard(formula, pattern) {
-    try {
-        const composition = parse_formula(formula);
-        // Separate explicit elements and wildcards from pattern
-        const explicit_requirements = [];
-        const wildcard_counts = [];
-        for (const token of pattern) {
-            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 });
-                }
-            }
-        }
-        // Check explicit element requirements
-        const used_elements = new Set();
-        for (const req of explicit_requirements) {
-            if (composition[req.element] !== req.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)
-            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;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/constants.d.ts

@@ -1,29 +0,0 @@
-export declare const COMPRESSION_FORMATS: {
-    readonly gzip: readonly [".gz", ".gzip"];
-    readonly deflate: readonly [".deflate"];
-    readonly 'deflate-raw': readonly [".z"];
-    readonly zip: readonly [".zip"];
-    readonly xz: readonly [".xz"];
-    readonly bz2: readonly [".bz2"];
-};
-export declare const COMPRESSION_EXTENSIONS: readonly string[];
-export declare const TRAJ_KEYWORDS: readonly string[];
-export declare const STRUCT_KEYWORDS: readonly string[];
-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[];
-export declare const STRUCTURE_EXTENSIONS_REGEX: RegExp;
-export declare const TRAJ_FALLBACK_EXTENSIONS: readonly string[];
-export declare const TRAJ_FALLBACK_EXTENSIONS_REGEX: RegExp;
-export declare const VASP_FILES_REGEX: RegExp;
-export declare const VASP_VOLUMETRIC_REGEX: RegExp;
-export declare const XDATCAR_REGEX: RegExp;
-export declare const CONFIG_DIRS_REGEX: RegExp;
-export declare const MD_SIM_EXCLUDE_REGEX: RegExp;
-export declare const XYZ_EXTXYZ_REGEX: RegExp;
-export declare const COMPRESSION_EXTENSIONS_REGEX: RegExp;

package/dist/constants.js

@@ -1,105 +0,0 @@
-// Shared keyword constants for file type detection across the codebase
-// compression formats and their file extensions
-export const COMPRESSION_FORMATS = {
-    gzip: [`.gz`, `.gzip`],
-    deflate: [`.deflate`],
-    'deflate-raw': [`.z`],
-    zip: [`.zip`], // Browser DecompressionStream doesn't support ZIP
-    xz: [`.xz`], // Browser DecompressionStream doesn't support XZ
-    bz2: [`.bz2`], // Browser DecompressionStream doesn't support BZ2
-};
-// All detectable compression extensions
-export const COMPRESSION_EXTENSIONS = Object.freeze([
-    ...Object.values(COMPRESSION_FORMATS).flat(),
-]);
-// Keywords that indicate a file is likely a trajectory file
-export const TRAJ_KEYWORDS = Object.freeze([
-    `trajectory`,
-    `traj`,
-    `relax`,
-    `npt`,
-    `nvt`,
-    `nve`,
-    `qha`,
-    `md`,
-    `dynamics`,
-    `simulation`,
-]);
-// Keywords that indicate a file is likely a structure file
-export const STRUCT_KEYWORDS = Object.freeze([
-    `structure`,
-    `phono`,
-    `vasp`,
-    `crystal`,
-    `material`,
-    `lattice`,
-    `geometry`,
-    `unit_cell`,
-    `unitcell`,
-    `atoms`,
-    `sites`,
-    `data`,
-    `phono3py`,
-    `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 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`);
-// 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 STRUCTURE_EXTENSIONS = Object.freeze([
-    `.cif`,
-    `.mcif`,
-    `.poscar`,
-    `.vasp`,
-    `.cube`,
-    `.lmp`,
-    `.data`,
-    `.dump`,
-    `.pdb`,
-    `.mol`,
-    `.mol2`,
-    `.sdf`,
-    `.mmcif`,
-]);
-export const STRUCTURE_EXTENSIONS_REGEX = new RegExp(`\\.(${STRUCTURE_EXTENSIONS.map((ext) => ext.slice(1)).join(`|`)})$`, `i`);
-export const TRAJ_FALLBACK_EXTENSIONS = Object.freeze([
-    `.dat`,
-    `.data`,
-    `.log`,
-    `.out`,
-    `.json`,
-]);
-export const TRAJ_FALLBACK_EXTENSIONS_REGEX = new RegExp(`\\.(${TRAJ_FALLBACK_EXTENSIONS.map((ext) => ext.slice(1)).join(`|`)})$`, `i`);
-// 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 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;
-// Compression extensions regex (shared across files)
-export const COMPRESSION_EXTENSIONS_REGEX = new RegExp(`\\.(${COMPRESSION_EXTENSIONS.map((ext) => ext.slice(1)).join(`|`)})$`, `i`);

package/dist/controls.d.ts

@@ -1,14 +0,0 @@
-export type ControlsVisibility = `always` | `hover` | `never`;
-export type ShowControlsConfig = {
-    mode?: ControlsVisibility;
-    hidden?: string[];
-    style?: string;
-};
-export type ShowControlsProp = ControlsVisibility | ShowControlsConfig | boolean;
-export declare function normalize_show_controls(prop: ShowControlsProp | undefined): {
-    mode: ControlsVisibility;
-    hidden: Set<string>;
-    style: string | undefined;
-    visible: (name: string) => boolean;
-    class: string;
-};

package/dist/controls.js

@@ -1,30 +0,0 @@
-// Controls visibility configuration for visualization components
-// Manages visibility of control buttons in Structure, Trajectory, BrillouinZone
-// Normalize show_controls prop into consistent config with helper methods
-export function normalize_show_controls(prop) {
-    // Extract mode, hidden, style from various prop forms
-    let mode = `hover`;
-    let hidden_arr;
-    let style;
-    if (typeof prop === `boolean`) {
-        mode = prop ? `always` : `never`;
-    }
-    else if (typeof prop === `string`) {
-        mode = prop;
-    }
-    else if (prop) {
-        mode = prop.mode ?? `hover`;
-        hidden_arr = prop.hidden;
-        style = prop.style;
-    }
-    const hidden = new Set(hidden_arr);
-    return {
-        mode,
-        hidden,
-        style,
-        // Helper: check if a control should be visible
-        visible: (name) => !hidden.has(name),
-        // CSS class for visibility mode
-        class: mode === `never` ? `` : `${mode}-visible`,
-    };
-}