matterviz 0.3.7 → 0.4.0

package/dist/structure/parse.js

@@ -41,9 +41,9 @@ function parse_coordinate_line(line) {
         const sanitized = line
             .trim()
             // Add space when '-' follows a digit and precedes a digit or dot
-            .replace(/(\d)-(?=[\d.])/g, `$1 -`)
+            .replaceAll(/(\d)-(?=[\d.])/g, `$1 -`)
             // Revert accidental spaces after exponent markers
-            .replace(/([eE])\s-\s/g, `$1-`);
+            .replaceAll(/([eE])\s-\s/g, `$1-`);
         tokens = sanitized.split(/\s+/);
     }
     if (tokens.length < 3)
@@ -61,6 +61,30 @@ function validate_element_symbol(symbol, index) {
     console.warn(`Invalid element symbol '${symbol}', using fallback '${fallback}'`);
     return fallback;
 }
+// Per OPTIMADE spec, species_at_sites holds species NAMES (e.g. 'Si1') resolved via the
+// species list: highest-concentration entry in chemical_symbols wins, non-element entries
+// like 'vacancy' are skipped, and unresolved names are treated as element symbols.
+// Returns the chosen element plus its index into the species' chemical_symbols
+// (sym_idx = -1 on fallback), so callers can read the matching mass/concentration entry.
+function resolve_optimade_element(species_name, species_list, index) {
+    const spec = species_list?.find((entry) => entry.name === species_name);
+    let best;
+    for (const [sym_idx, symbol] of (spec?.chemical_symbols ?? []).entries()) {
+        if (!is_known_element_symbol(symbol))
+            continue;
+        const conc = spec?.concentration?.[sym_idx] ?? 0;
+        if (!best || conc > best.conc)
+            best = { symbol, conc, sym_idx };
+    }
+    if (best)
+        return { symbol: best.symbol, sym_idx: best.sym_idx };
+    // Fallback: the name may be an element with a trailing atom index (e.g. 'O1');
+    // element symbols never contain digits, so stripping them is safe
+    const stripped = species_name.replace(/\d+$/, ``);
+    if (is_known_element_symbol(stripped))
+        return { symbol: stripped, sym_idx: -1 };
+    return { symbol: validate_element_symbol(species_name, index), sym_idx: -1 };
+}
 const try_create_cart_to_frac = (lattice_matrix) => {
     try {
         return math.create_cart_to_frac(lattice_matrix);
@@ -77,17 +101,21 @@ const approximate_cart_to_frac = (xyz, axis_lengths) => [
 // Parse VASP POSCAR file format
 export function parse_poscar(content) {
     try {
-        const lines = content.replace(/^\s+/, ``).split(/\r?\n/);
+        // Strip only horizontal whitespace: a blank first (comment) line is valid POSCAR
+        const lines = content.replace(/^[ \t]+/, ``).split(/\r?\n/);
         if (lines.length < 8) {
             console.error(`POSCAR file too short`);
             return null;
         }
-        // Parse scaling factor (line 2)
-        let scale_factor = parseFloat(lines[1]);
+        // Scale line: one value (negative = target volume) or three per-axis Cartesian factors
+        const scale_tokens = lines[1].trim().split(/\s+/).map(parseFloat);
+        let scale_factor = scale_tokens[0];
         if (isNaN(scale_factor)) {
             console.error(`Invalid scaling factor in POSCAR`);
             return null;
         }
+        const scale_vec = scale_tokens.slice(0, 3);
+        const per_axis_scale = scale_vec.length === 3 && !scale_vec.some(isNaN) ? scale_vec : null;
         // Parse lattice vectors (lines 3-5)
         const parse_vector = (line, line_num) => {
             const coords = line.trim().split(/\s+/).map(parse_coordinate);
@@ -98,17 +126,15 @@ export function parse_poscar(content) {
             parse_vector(lines[3], 4),
             parse_vector(lines[4], 5),
         ];
-        // Handle negative scale factor (volume-based scaling)
-        if (scale_factor < 0) {
+        // Handle negative scale factor (volume-based scaling, single-factor form only)
+        if (!per_axis_scale && scale_factor < 0) {
             const volume = Math.abs(math.det_3x3(lattice_vecs));
-            scale_factor = Math.pow(-scale_factor / volume, 1 / 3);
+            scale_factor = (-scale_factor / volume) ** (1 / 3);
         }
-        // Scale lattice vectors
-        const scaled_lattice = [
-            math.scale(lattice_vecs[0], scale_factor),
-            math.scale(lattice_vecs[1], scale_factor),
-            math.scale(lattice_vecs[2], scale_factor),
-        ];
+        // Scale lattice vectors (per-axis factors multiply Cartesian components)
+        const axis_scale = per_axis_scale ?? [scale_factor, scale_factor, scale_factor];
+        const apply_axis_scale = (vec) => vec.map((val, axis) => val * axis_scale[axis]);
+        const scaled_lattice = lattice_vecs.map(apply_axis_scale);
         // Parse element symbols and atom counts (may span multiple lines)
         let line_index = 5;
         let element_symbols = [];
@@ -116,7 +142,7 @@ export function parse_poscar(content) {
         // Detect if this is VASP 5+ format (has element symbols)
         // Try to parse the first token as a number - if it succeeds, it's VASP 4 format
         const first_token = lines[line_index].trim().split(/\s+/)[0];
-        const first_token_as_number = parseInt(first_token);
+        const first_token_as_number = parseInt(first_token, 10);
         const has_element_symbols = isNaN(first_token_as_number);
         if (has_element_symbols) {
             // VASP 5+ format - parse element symbols (may span multiple lines)
@@ -126,7 +152,7 @@ export function parse_poscar(content) {
                 if (line_index + lookahead_idx >= lines.length)
                     break;
                 const next_line_first_token = lines[line_index + lookahead_idx].trim().split(/\s+/)[0];
-                const next_token_as_number = parseInt(next_line_first_token);
+                const next_token_as_number = parseInt(next_line_first_token, 10);
                 if (!isNaN(next_token_as_number)) {
                     symbol_lines = lookahead_idx;
                     break;
@@ -213,28 +239,22 @@ export function parse_poscar(content) {
                             selective_dynamics = [tokens[3] === `T`, tokens[4] === `T`, tokens[5] === `T`];
                         }
                     }
-                    let xyz;
-                    let abc;
-                    if (is_direct) {
-                        // Store fractional coordinates, wrapping to [0, 1) range
-                        abc = wrap_to_unit_cell(coords);
-                        xyz = poscar_frac_to_cart(abc);
-                    }
-                    else {
-                        // Already Cartesian, scale if needed
-                        xyz = math.scale(coords, scale_factor);
-                        const raw_abc = poscar_cart_to_frac
-                            ? poscar_cart_to_frac(xyz)
-                            : approximate_cart_to_frac(xyz, poscar_axis_lengths);
-                        // Wrap fractional coordinates to [0, 1) range
-                        abc = wrap_to_unit_cell(raw_abc);
-                    }
+                    // Cartesian input is scaled then converted to fractional (axis-length fallback
+                    // for singular lattices); abc wraps to [0, 1) and xyz is recomputed from it so
+                    // both stay consistent (singular Cartesian keeps the scaled input as xyz)
+                    const cart = is_direct ? null : apply_axis_scale(coords);
+                    const raw_abc = cart
+                        ? (poscar_cart_to_frac?.(cart) ??
+                            approximate_cart_to_frac(cart, poscar_axis_lengths))
+                        : coords;
+                    const abc = wrap_to_unit_cell(raw_abc);
+                    const xyz = cart && !poscar_cart_to_frac ? cart : poscar_frac_to_cart(abc);
                     const site = {
                         species: [{ element, occu: 1, oxidation_state: 0 }],
                         abc,
                         xyz,
                         label: `${element}${atom_index + atom_count_idx + 1}`,
-                        properties: selective_dynamics ? { selective_dynamics: selective_dynamics } : {},
+                        properties: selective_dynamics ? { selective_dynamics } : {},
                     };
                     sites.push(site);
                 }
@@ -247,10 +267,8 @@ export function parse_poscar(content) {
             };
             return structure;
         }
-        else {
-            console.error(`Missing coordinate mode line in POSCAR`);
-            return null;
-        }
+        console.error(`Missing coordinate mode line in POSCAR`);
+        return null;
     }
     catch (error) {
         console.error(`Error parsing POSCAR file:`, error);
@@ -292,7 +310,7 @@ export function parse_xyz(content) {
             return null;
         }
         // Parse number of atoms (line 1)
-        const num_atoms = parseInt(lines[0].trim());
+        const num_atoms = parseInt(lines[0].trim(), 10);
         if (isNaN(num_atoms) || num_atoms <= 0) {
             console.error(`Invalid number of atoms in XYZ file`);
             return null;
@@ -369,7 +387,7 @@ const parse_symmetry_expression = (expr_input) => {
     const coefficients = [0, 0, 0];
     let translation = 0;
     // Remove all whitespace
-    const expr = expr_input.replace(/\s+/g, ``);
+    const expr = expr_input.replaceAll(/\s+/g, ``);
     if (!expr)
         return { coefficients, translation };
     // Tokenize: split into terms while preserving signs
@@ -480,13 +498,15 @@ const extract_cif_cell_parameters = (text, type, strict = true) => text
     .split(`\n`)
     .filter((line) => line.startsWith(`_${type}`))
     .map((line) => {
-    const tokens = line.split(/\s+/).filter((token) => token.length > 0);
+    // Strip trailing comment (# after whitespace) and take the value right after the tag
+    const sans_comment = line.replace(/\s#.*$/, ``);
+    const tokens = sans_comment.split(/\s+/).filter(Boolean);
     if (tokens.length < 2) {
         if (strict)
             throw new Error(`Invalid CIF cell parameter line format: ${line}`);
         return null;
     }
-    const value = parseFloat((tokens.at(-1) ?? ``).split(`(`)[0]);
+    const value = parseFloat(tokens[1].split(`(`)[0]);
     if (isNaN(value)) {
         if (strict)
             throw new Error(`Invalid CIF cell parameter in line: ${line}`);
@@ -541,11 +561,11 @@ const parse_cif_atom_data = (raw_data, indices, coords_type) => {
     const occu = occupancy >= 0 && raw_data[occupancy]
         ? parseFloat(raw_data[occupancy].split(`(`)[0]) || 1.0
         : 1.0;
-    const element_symbol = (symbol >= 0 && /^([A-Z][a-z]*)/.exec(raw_data[symbol])?.[1]) ||
-        raw_data[label]?.match(/([A-Z][a-z]*)/g)?.[0] ||
-        (() => {
-            throw new Error(`Could not extract element symbol from: ${raw_data.join(` `)}`);
-        })();
+    const from_symbol = symbol >= 0 ? /^([A-Z][a-z]*)/.exec(raw_data[symbol])?.[1] : undefined;
+    const element_symbol = from_symbol ?? raw_data[label]?.match(/([A-Z][a-z]*)/g)?.[0];
+    if (!element_symbol) {
+        throw new Error(`Could not extract element symbol from: ${raw_data.join(` `)}`);
+    }
     return {
         id: raw_data[label],
         element: element_symbol,
@@ -617,7 +637,7 @@ export function parse_cif(content, wrap_fractional_coords = true, strict = true)
                     if (line.startsWith(`;`)) {
                         let multi_line_data = ``;
                         while (jj < lines.length && !lines[jj].trim().endsWith(`;`)) {
-                            multi_line_data += lines[jj] + `\n`;
+                            multi_line_data += `${lines[jj]}\n`;
                             jj++;
                         }
                         multi_line_data += lines[jj];
@@ -632,7 +652,7 @@ export function parse_cif(content, wrap_fractional_coords = true, strict = true)
             if (atom_data_lines.length > 0)
                 break;
         }
-        if (!atom_headers.length || !atom_data_lines.length) {
+        if (atom_headers.length === 0 || atom_data_lines.length === 0) {
             console.error(`No valid atom site loop found in CIF file`);
             return null;
         }
@@ -660,8 +680,8 @@ export function parse_cif(content, wrap_fractional_coords = true, strict = true)
             .map((line) => {
             // Handle quoted multi-word values by splitting only on whitespace
             // that is not inside quotes.
-            const tokens = line.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
-            return tokens.map((token) => token.replace(/['"]/g, ``));
+            const tokens = line.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) ?? [];
+            return tokens.map((token) => token.replaceAll(/['"]/g, ``));
         })
             .filter((tokens) => {
             const { disorder } = header_indices;
@@ -679,7 +699,7 @@ export function parse_cif(content, wrap_fractional_coords = true, strict = true)
             }
         })
             .filter((atom) => atom !== null);
-        if (!atoms.length) {
+        if (atoms.length === 0) {
             console.error(`No valid atoms found in CIF file`);
             return null;
         }
@@ -703,8 +723,8 @@ export function parse_cif(content, wrap_fractional_coords = true, strict = true)
         const all_sites = [];
         // Normalize symmetry operations (trim/strip quotes) but preserve duplicates; we deduplicate positions later
         const normalized_ops = symmetry_ops
-            .map((op) => /['"]([^'"]+)['"]/.exec(op)?.[1] || op.trim())
-            .map((op) => op.replace(/\s+/g, ``));
+            .map((op) => /['"]([^'"]+)['"]/.exec(op)?.[1] ?? op.trim())
+            .map((op) => op.replaceAll(/\s+/g, ``));
         // Rely on symmetry operations list for all centering/translations to avoid double-counting
         // TODO: Support conventional cells with centering by discovering centering from space group metadata
         // when present (e.g. P, I, F, C, R centering types)
@@ -734,12 +754,12 @@ export function parse_cif(content, wrap_fractional_coords = true, strict = true)
                             lj++;
                             continue;
                         }
-                        const toks = (line.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || []).map((tok) => tok.replace(/['"]/g, ``));
+                        const toks = (line.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) ?? []).map((tok) => tok.replaceAll(/['"]/g, ``));
                         if (toks.length > Math.max(sym_idx, num_idx)) {
                             // Normalize type symbol to bare element (e.g. 'Sn2+' -> 'Sn')
                             const match = /^([A-Z][a-z]*)/.exec(toks[sym_idx]);
                             const sym = match ? match[1] : toks[sym_idx];
-                            const num = parseInt(toks[num_idx]);
+                            const num = parseInt(toks[num_idx], 10);
                             if (sym && !Number.isNaN(num))
                                 map[sym] = num;
                         }
@@ -887,10 +907,8 @@ export function parse_phonopy_yaml(content, cell_type) {
             const cell = get_phonopy_cell(data, cell_type);
             if (cell)
                 return convert_phonopy_cell(cell);
-            else {
-                console.error(`Requested cell type '${cell_type}' not found in phonopy YAML`);
-                return null;
-            }
+            console.error(`Requested cell type '${cell_type}' not found in phonopy YAML`);
+            return null;
         }
         // Auto mode: return preferred structure in order of preference
         // 1. supercell (most detailed)
@@ -982,6 +1000,19 @@ export function normalize_fractional_coords(structure) {
     });
     return { ...structure, sites: normalized_sites };
 }
+// Detect a structure inside already-stringified JSON (OPTIMADE or pymatgen/nested).
+// Throws if `content` isn't valid JSON; returns null if it holds no known structure.
+const detect_json_structure = (content) => {
+    const parsed = JSON.parse(content);
+    if (is_optimade_raw(parsed)) {
+        const result = parse_optimade_from_raw(parsed);
+        if (result)
+            return result;
+    }
+    // Otherwise try parsing as pymatgen/nested structure JSON
+    const structure = find_structure_in_json(parsed);
+    return structure ? normalize_fractional_coords(structure) : null;
+};
 // Auto-detect file format and parse accordingly
 export function parse_structure_file(content, filename) {
     // If a filename is provided, try to detect format by file extension first
@@ -998,27 +1029,18 @@ export function parse_structure_file(content, filename) {
         // CIF files
         if (ext === `cif`)
             return parse_cif(content);
-        // JSON files - try OPTIMADE JSON structure format first, then pymatgen
+        // JSON files - extension is authoritative, so failures return null
         if (ext === `json`) {
             try {
-                // Parse once, reuse for detection and parsing
-                const parsed = JSON.parse(content);
-                if (is_optimade_raw(parsed)) {
-                    const result = parse_optimade_from_raw(parsed);
-                    if (result)
-                        return result;
-                }
-                // Otherwise, try to parse as pymatgen/nested structure JSON
-                const structure = find_structure_in_json(parsed);
-                if (structure)
-                    return normalize_fractional_coords(structure);
+                const result = detect_json_structure(content);
+                if (result)
+                    return result;
                 console.error(`JSON file does not contain a valid structure format`);
-                return null;
             }
             catch (error) {
                 console.error(`Error parsing JSON file:`, error);
-                return null;
             }
+            return null;
         }
         // YAML files (phonopy)
         if (ext === `yaml` || ext === `yml`)
@@ -1028,31 +1050,24 @@ export function parse_structure_file(content, filename) {
             return parse_poscar(content);
         }
     }
-    // Try to auto-detect based on content
-    const lines = content.trim().split(/\r?\n/);
-    if (lines.length < 2) {
-        console.error(`File too short to determine format`);
-        return null;
-    }
-    // JSON format detection: try to parse as JSON first
+    // Try to auto-detect based on content.
+    // JSON detection must come before the line-count guard: minified JSON
+    // (e.g. fetched via extensionless blob: object URLs) is a single line.
     try {
-        const parsed = JSON.parse(content);
-        if (is_optimade_raw(parsed)) {
-            const result = parse_optimade_from_raw(parsed);
-            if (result)
-                return result;
-        }
-        // Otherwise try parsing as regular JSON structure
-        const structure = find_structure_in_json(parsed);
-        if (structure) {
-            return normalize_fractional_coords(structure);
-        }
+        const result = detect_json_structure(content);
+        if (result)
+            return result;
     }
     catch {
         // Not JSON, continue with other format detection
     }
+    const lines = content.trim().split(/\r?\n/);
+    if (lines.length < 2) {
+        console.error(`File too short to determine format`);
+        return null;
+    }
     // XYZ format detection: first line should be a number, second line is comment
-    const first_line_number = parseInt(lines[0].trim());
+    const first_line_number = parseInt(lines[0].trim(), 10);
     if (!isNaN(first_line_number) && first_line_number > 0) {
         // Check if this looks like XYZ format
         if (lines.length >= first_line_number + 2) {
@@ -1066,7 +1081,7 @@ export function parse_structure_file(content, filename) {
                     const coords = parts.slice(1, 4);
                     // Check if first token looks like an element symbol (not a number)
                     // and the next 3 tokens look like coordinates (numbers)
-                    const is_element_symbol = isNaN(parseInt(first_token)) && first_token.length <= 3;
+                    const is_element_symbol = isNaN(parseInt(first_token, 10)) && first_token.length <= 3;
                     const are_coordinates = coords.every((coord) => !isNaN(parseFloat(coord)));
                     if (is_element_symbol && are_coordinates) {
                         // First token is likely an element symbol, likely XYZ
@@ -1190,6 +1205,7 @@ export function parse_optimade_from_raw(raw) {
         if (lattice_matrix && !optimade_exact_cart_to_frac) {
             console.warn(`Failed to create exact coordinate converter for OPTIMADE structure`);
         }
+        const optimade_species = Array.isArray(attrs.species) ? attrs.species : undefined;
         const sites = [];
         for (let idx = 0; idx < positions.length; idx++) {
             const pos = positions[idx];
@@ -1202,7 +1218,7 @@ export function parse_optimade_from_raw(raw) {
                 console.warn(`Invalid position data at site ${idx}: ${error}`);
                 continue;
             }
-            const element = validate_element_symbol(element_symbol, idx);
+            const { symbol: element } = resolve_optimade_element(element_symbol, optimade_species, idx);
             // Calculate fractional coordinates if lattice is available
             const abc = optimade_cart_to_frac ? optimade_cart_to_frac(xyz) : [0, 0, 0];
             const site = {
@@ -1282,24 +1298,26 @@ export function optimade_to_crystal(optimade_structure) {
             vec3_from_values(lattice_vectors[2], `OPTIMADE lattice vector 3`),
         ];
         const lattice_params = math.calc_lattice_params(lattice_matrix);
-        // Build species lookup for site properties (mass, concentration, etc.)
-        const species_map = new Map(species?.map((spec) => [spec.name, spec]));
         const crystal_cart_to_frac = try_create_cart_to_frac(lattice_matrix) ??
             ((xyz) => approximate_cart_to_frac(xyz, [lattice_params.a, lattice_params.b, lattice_params.c]));
         const sites = cartesian_site_positions.map((pos, idx) => {
             const element_symbol = species_at_sites[idx];
             if (!element_symbol)
                 throw new Error(`Missing species for site ${idx}`);
-            const element = validate_element_symbol(element_symbol, idx);
+            const { symbol: element, sym_idx } = resolve_optimade_element(element_symbol, species, idx);
             const xyz = vec3_from_values(pos, `OPTIMADE atom position ${idx + 1}`);
             const abc = crystal_cart_to_frac ? crystal_cart_to_frac(xyz) : [0, 0, 0];
-            // Extract mass/concentration from species data
-            const spec = species_map.get(element_symbol);
+            // Extract mass/concentration for the chosen element. sym_idx indexes the (parallel)
+            // chemical_symbols/mass/concentration arrays; -1 (name resolved directly, no
+            // chemical_symbols) falls back to index 0 — the single-element entry.
+            const spec = species?.find((entry) => entry.name === element_symbol);
+            const spec_idx = Math.max(sym_idx, 0);
             const site_props = {};
-            if (spec?.mass?.[0] !== undefined)
-                site_props.mass = spec.mass[0];
-            if (spec?.concentration?.[0] !== undefined && spec.concentration[0] !== 1) {
-                site_props.concentration = spec.concentration[0];
+            if (spec?.mass?.[spec_idx] !== undefined)
+                site_props.mass = spec.mass[spec_idx];
+            if (spec?.concentration?.[spec_idx] !== undefined &&
+                spec.concentration[spec_idx] !== 1) {
+                site_props.concentration = spec.concentration[spec_idx];
             }
             return {
                 species: [{ element, occu: 1, oxidation_state: 0 }],

package/dist/structure/pbc.js

@@ -43,11 +43,15 @@ export function find_image_atoms(structure, { tolerance } = {}) {
         // but fall back to 0.05 fractional tolerance if it does
         return vec_len > 0 ? PHYSICAL_TOLERANCE / vec_len : 0.05;
     });
+    // Respect per-axis periodicity: no images across non-periodic (vacuum) directions
+    const pbc = structure.lattice.pbc ?? [true, true, true];
     for (const [idx, site] of structure.sites.entries()) {
         // Find edge dimensions and translation directions
         const edge_dims = [];
         // Find boundary dimensions
         for (let dim = 0; dim < 3; dim++) {
+            if (!pbc[dim])
+                continue;
             const coord = site.abc[dim];
             const dim_tolerance = tolerances[dim];
             if (Math.abs(coord) < dim_tolerance)

package/dist/symmetry/SymmetryStats.svelte

@@ -32,7 +32,7 @@
   const wyckoff_count = $derived(
     sym_data ? wyckoff_positions_from_moyo(sym_data).length : 0,
   )
-  const display_hm_symbol = $derived(sym_data?.hm_symbol?.replace(/\s+/g, ``) ?? `?`)
+  const display_hm_symbol = $derived(sym_data?.hm_symbol?.replaceAll(/\s+/g, ``) ?? `?`)
 
   const sym_ops_counts = $derived.by(() => {
     const EPS = 1e-10
@@ -83,7 +83,7 @@
   function get_step_from_order_of_magnitude(value: number): number {
     if (!Number.isFinite(value) || value <= 0) return 1e-5
     const exponent = Math.floor(Math.log10(value))
-    return Math.pow(10, exponent)
+    return 10 ** exponent
   }
 
   const symprec_step = $derived(get_step_from_order_of_magnitude(settings.symprec))

package/dist/symmetry/index.d.ts

@@ -35,7 +35,7 @@ export type SymmetryDataset = MoyoDataset & {
 };
 export declare function ensure_moyo_wasm_ready(wasm_url?: string): Promise<void>;
 export declare function to_cell_json(structure: Crystal): string;
-export declare function map_std_to_orig_site_indices(std_positions: Vec3[], std_numbers: number[], input_positions: Vec3[], input_numbers: number[], orig_site_indices_by_input_idx: number[][]): number[][];
+export declare const map_std_to_orig_site_indices: (std_positions: Vec3[], std_numbers: number[], input_positions: Vec3[], input_numbers: number[], orig_site_indices_by_input_idx: number[][]) => number[][];
 export declare function analyze_structure_symmetry(struct_or_mol: AnyStructure, settings: Partial<SymmetrySettings>): Promise<SymmetryDataset>;
 export declare function simplicity_score(vec: number[]): number;
 export declare function wyckoff_positions_from_moyo(sym_data: SymmetryDataset | null): WyckoffPos[];

package/dist/symmetry/index.js

@@ -93,25 +93,23 @@ export function to_cell_json(structure) {
 const fractional_sq_dist = (pos_1, pos_2) => (pos_1[0] - pos_2[0] - Math.round(pos_1[0] - pos_2[0])) ** 2 +
     (pos_1[1] - pos_2[1] - Math.round(pos_1[1] - pos_2[1])) ** 2 +
     (pos_1[2] - pos_2[2] - Math.round(pos_1[2] - pos_2[2])) ** 2;
-export function map_std_to_orig_site_indices(std_positions, std_numbers, input_positions, input_numbers, orig_site_indices_by_input_idx) {
-    return std_positions.map((std_pos, std_idx) => {
-        const std_number = std_numbers[std_idx];
-        let nearest_input_idx = -1;
-        let nearest_sq_dist = Infinity;
-        for (let input_idx = 0; input_idx < input_positions.length; input_idx += 1) {
-            if (input_numbers[input_idx] !== std_number)
-                continue;
-            const sq_dist = fractional_sq_dist(std_pos, input_positions[input_idx]);
-            if (sq_dist < nearest_sq_dist) {
-                nearest_sq_dist = sq_dist;
-                nearest_input_idx = input_idx;
-            }
+export const map_std_to_orig_site_indices = (std_positions, std_numbers, input_positions, input_numbers, orig_site_indices_by_input_idx) => std_positions.map((std_pos, std_idx) => {
+    const std_number = std_numbers[std_idx];
+    let nearest_input_idx = -1;
+    let nearest_sq_dist = Infinity;
+    for (let input_idx = 0; input_idx < input_positions.length; input_idx += 1) {
+        if (input_numbers[input_idx] !== std_number)
+            continue;
+        const sq_dist = fractional_sq_dist(std_pos, input_positions[input_idx]);
+        if (sq_dist < nearest_sq_dist) {
+            nearest_sq_dist = sq_dist;
+            nearest_input_idx = input_idx;
         }
-        if (nearest_input_idx === -1)
-            return [];
-        return orig_site_indices_by_input_idx[nearest_input_idx] ?? [];
-    });
-}
+    }
+    if (nearest_input_idx === -1)
+        return [];
+    return orig_site_indices_by_input_idx[nearest_input_idx] ?? [];
+});
 export async function analyze_structure_symmetry(struct_or_mol, settings) {
     await ensure_moyo_wasm_ready();
     if (!(`lattice` in struct_or_mol)) {
@@ -178,7 +176,7 @@ export function wyckoff_positions_from_moyo(sym_data) {
         };
     });
     rows.sort((w1, w2) => {
-        const [w1_mult, w2_mult] = [parseInt(w1.wyckoff), parseInt(w2.wyckoff)];
+        const [w1_mult, w2_mult] = [parseInt(w1.wyckoff, 10), parseInt(w2.wyckoff, 10)];
         if (w1_mult !== w2_mult)
             return w1_mult - w2_mult;
         return w1.wyckoff.localeCompare(w2.wyckoff);
@@ -190,10 +188,10 @@ export function apply_symmetry_operations(position, operations, _tolerance = 1e-
     const seen = new Set();
     return operations
         .map(({ rotation, translation }) => {
-        // Apply 3x3 rotation matrix and translation: new_pos = R * position + t
-        const new_pos = [0, 1, 2].map((dim) => rotation[dim * 3] * position[0] +
-            rotation[dim * 3 + 1] * position[1] +
-            rotation[dim * 3 + 2] * position[2] +
+        // new_pos = W·position + t; moyo serializes W COLUMN-major: W[dim][j] = rotation[dim + 3j]
+        const new_pos = [0, 1, 2].map((dim) => rotation[dim] * position[0] +
+            rotation[dim + 3] * position[1] +
+            rotation[dim + 6] * position[2] +
             translation[dim]);
         return new_pos.map(to_unit);
     })
@@ -211,7 +209,7 @@ export function map_wyckoff_to_all_atoms(wyckoff_positions, displayed_structure,
         return wyckoff_positions;
     }
     return wyckoff_positions.map((wyckoff_pos) => {
-        const indices = (wyckoff_pos.site_indices || [])
+        const indices = (wyckoff_pos.site_indices ?? [])
             .filter((idx) => idx < orig_structure.sites.length)
             .flatMap((orig_idx) => {
             const { abc: orig_abc, species } = orig_structure.sites[orig_idx];

package/dist/symmetry/spacegroups.d.ts

@@ -1,3 +1,4 @@
+import type { SunburstNode } from '../plot/core/types';
 export declare const CRYSTAL_SYSTEM_RANGES: Record<CrystalSystem, [number, number]>;
 export declare const CRYSTAL_SYSTEM_COLORS: Record<CrystalSystem, string>;
 export declare const CRYSTAL_SYSTEMS: readonly ["triclinic", "monoclinic", "orthorhombic", "tetragonal", "trigonal", "hexagonal", "cubic"];
@@ -7,3 +8,9 @@ export declare function spacegroup_to_crystal_sys(spacegroup: number | string):
 export declare function normalize_spacegroup(spacegroup: number | string): number | null;
 export declare const SPACEGROUP_SYMBOL_TO_NUM: Record<string, number>;
 export declare const SPACEGROUP_NUM_TO_SYMBOL: Record<number, string>;
+export interface SpacegroupSunburstMetadata {
+    spacegroup: number;
+    crystal_system: CrystalSystem;
+    [key: string]: unknown;
+}
+export declare function spacegroup_sunburst_data(spacegroups: readonly (number | string)[]): SunburstNode<SpacegroupSunburstMetadata>[];