matterviz 0.3.6 → 0.3.7

package/dist/symmetry/SymmetryStats.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { MoyoDataset } from '@spglib/moyo-wasm';
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+import type { SymmetrySettings } from './index';
+type SymmetrySnippet = Snippet<[
+    {
+        sym_data?: MoyoDataset | null;
+        settings: SymmetrySettings;
+    }
+]>;
+type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
+    sym_data?: MoyoDataset | null;
+    settings?: SymmetrySettings;
+    show_tooltips?: boolean;
+    children?: SymmetrySnippet;
+    label?: SymmetrySnippet | string;
+    header?: SymmetrySnippet;
+};
+declare const SymmetryStats: import("svelte").Component<$$ComponentProps, {}, "settings">;
+type SymmetryStats = ReturnType<typeof SymmetryStats>;
+export default SymmetryStats;

package/dist/symmetry/WyckoffTable.svelte

@@ -0,0 +1,120 @@
+<script lang="ts">
+  import { contrast_color } from '../colors'
+  import { format_fractional } from '../labels'
+  import { colors } from '../state.svelte'
+  import type { HTMLAttributes } from 'svelte/elements'
+  import type { WyckoffPos } from '.'
+
+  let {
+    wyckoff_positions,
+    on_hover,
+    on_click,
+    active_color = `#2563eb`,
+    ...rest
+  }: HTMLAttributes<HTMLTableElement> & {
+    wyckoff_positions: WyckoffPos[]
+    on_hover?: (site_indices: number[] | null) => void
+    on_click?: (site_indices: number[] | null) => void
+    active_color?: string
+  } = $props()
+
+  let selected_key = $state<string | null>(null)
+
+  const get_row_key = (wyckoff_pos: WyckoffPos, row_idx: number) =>
+    `${wyckoff_pos.wyckoff}-${wyckoff_pos.elem}-${
+      wyckoff_pos.site_indices?.join(`,`) ?? `none`
+    }-${row_idx}`
+  $effect(() => {
+    if (!selected_key || wyckoff_positions?.some((pos, idx) => get_row_key(pos, idx) === selected_key)) {
+      return
+    }
+    selected_key = null
+    on_click?.(null)
+  })
+</script>
+
+{#if wyckoff_positions && wyckoff_positions.length > 0}
+  <table {...rest} class="wyckoff-table {rest.class ?? ``}">
+    <thead>
+      <tr>
+        {#each [
+          [`Wyckoff`, `Wyckoff position: Multiplicity + Letter`],
+          [`Element`, `Chemical element symbol`],
+          [`Fractional Coords`, `Fractional coordinates within the unit cell`],
+        ] as
+          [col, title]
+          (col)
+        }
+          <th {title}>{col}</th>
+        {/each}
+      </tr>
+    </thead>
+    <tbody>
+      {#each wyckoff_positions as
+        wyckoff_pos,
+        row_idx
+        (get_row_key(wyckoff_pos, row_idx))
+      }
+        {@const { wyckoff, elem, abc, site_indices } = wyckoff_pos}
+        {@const row_key = get_row_key(wyckoff_pos, row_idx)}
+        {@const is_selected = selected_key === row_key}
+        <tr
+          class="wyckoff-row"
+          tabindex="0"
+          class:selected={is_selected}
+          style:--active-color={active_color}
+          style:--hover-color="#6cf0ff"
+          onmouseenter={() => on_hover?.(site_indices ?? null)}
+          onmouseleave={() => on_hover?.(null)}
+          onclick={() => {
+            selected_key = is_selected ? null : row_key
+            on_click?.(is_selected ? null : (wyckoff_pos.site_indices ?? null))
+          }}
+          onkeydown={(event) => {
+            if ([`Enter`, ` `].includes(event.key)) {
+              event.preventDefault()
+              selected_key = is_selected ? null : row_key
+              on_click?.(is_selected ? null : (wyckoff_pos.site_indices ?? null))
+            }
+          }}
+        >
+          <td>{wyckoff}</td>
+          <td>
+            <span
+              style:background-color={colors.element[elem]}
+              style="display: inline-block; padding: 0 6pt; border-radius: 3pt; line-height: 1.4"
+              {@attach contrast_color()}
+            >
+              {elem}
+            </span>
+          </td>
+          <td>({abc?.map(format_fractional).join(` , `) ?? `N/A`})</td>
+        </tr>
+      {/each}
+    </tbody>
+  </table>
+{/if}
+
+<style>
+  .wyckoff-table {
+    margin-top: 1em;
+  }
+  .wyckoff-table :is(th, td) {
+    padding: 2px 6px;
+    text-align: center;
+    vertical-align: middle;
+  }
+  .wyckoff-row {
+    cursor: pointer;
+    transition: background-color 0.2s ease;
+  }
+  .wyckoff-row:hover {
+    background-color: color-mix(in srgb, var(--hover-color) 25%, transparent);
+  }
+  .wyckoff-row.selected {
+    background-color: color-mix(in srgb, var(--active-color) 30%, transparent);
+  }
+  .wyckoff-row.selected:hover {
+    background-color: color-mix(in srgb, var(--active-color) 35%, transparent);
+  }
+</style>

package/dist/symmetry/WyckoffTable.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { HTMLAttributes } from 'svelte/elements';
+import type { WyckoffPos } from '.';
+type $$ComponentProps = HTMLAttributes<HTMLTableElement> & {
+    wyckoff_positions: WyckoffPos[];
+    on_hover?: (site_indices: number[] | null) => void;
+    on_click?: (site_indices: number[] | null) => void;
+    active_color?: string;
+};
+declare const WyckoffTable: import("svelte").Component<$$ComponentProps, {}, "">;
+type WyckoffTable = ReturnType<typeof WyckoffTable>;
+export default WyckoffTable;

package/dist/symmetry/cell-transform.d.ts

@@ -0,0 +1,12 @@
+import type { Crystal } from '../structure';
+import type { MoyoCell, MoyoDataset } from '@spglib/moyo-wasm';
+export type CellType = `original` | `conventional` | `primitive`;
+export declare function moyo_cell_to_structure(cell: MoyoCell, // The MoyoCell from symmetry analysis (std_cell or prim_std_cell)
+original_structure: Crystal): Crystal;
+export declare function get_conventional_cell(original_structure: Crystal, // The original input structure
+sym_data: MoyoDataset): Crystal;
+export declare function get_primitive_cell(original_structure: Crystal, // The original input structure
+sym_data: MoyoDataset): Crystal;
+export declare function transform_cell(structure: Crystal, // The original structure
+cell_type: CellType, // The desired cell type ('original', 'conventional', or 'primitive')
+sym_data: MoyoDataset | null): Crystal;

package/dist/symmetry/cell-transform.js

@@ -0,0 +1,91 @@
+import { ATOMIC_NUMBER_TO_SYMBOL } from '../composition/parse';
+import * as math from '../math';
+import { wrap_to_unit_cell } from '../structure/pbc';
+const transferable_properties = (properties) => {
+    if (properties === undefined)
+        return undefined;
+    const rest = { ...properties };
+    delete rest.bonds;
+    return Object.keys(rest).length > 0 ? rest : undefined;
+};
+// Convert a MoyoCell (from moyo-wasm symmetry analysis) to Crystal format.
+// MoyoCell has a flat 9-element basis array and atomic numbers; this converts to
+// the full Crystal with lattice parameters and element symbols.
+export function moyo_cell_to_structure(cell, // The MoyoCell from symmetry analysis (std_cell or prim_std_cell)
+original_structure) {
+    // Convert flat 9-element basis to 3x3 matrix
+    // moyo-wasm uses the same row-major serialization for both input and output
+    // (see to_cell_json comment: column-major(B) == row-major(RB))
+    // So the flat array is row-major: [a1, a2, a3, b1, b2, b3, c1, c2, c3]
+    // where each row is a lattice vector in the pymatgen convention
+    const basis = cell.lattice.basis;
+    const lattice_matrix = [
+        [basis[0], basis[1], basis[2]], // First lattice vector (a)
+        [basis[3], basis[4], basis[5]], // Second lattice vector (b)
+        [basis[6], basis[7], basis[8]], // Third lattice vector (c)
+    ];
+    // Calculate lattice parameters from matrix
+    const lattice_params = math.calc_lattice_params(lattice_matrix);
+    const frac_to_cart = math.create_frac_to_cart(lattice_matrix);
+    // Build sites from positions and atomic numbers
+    const sites = cell.positions.map((abc, idx) => {
+        const atomic_number = cell.numbers[idx];
+        const element = ATOMIC_NUMBER_TO_SYMBOL[atomic_number];
+        if (!element) {
+            throw new Error(`Unknown atomic number: ${atomic_number}`);
+        }
+        // Wrap fractional coordinates to [0, 1) range (moyo-wasm may return outside)
+        const wrapped_abc = wrap_to_unit_cell(abc);
+        const xyz = frac_to_cart(wrapped_abc);
+        // Oxidation state is set to 0 (unknown) because moyo-wasm only provides atomic numbers.
+        // transformed cell may have different/reordered sites, making it non-trivial to
+        // map oxidation states from original structure.
+        const species = [{ element, occu: 1, oxidation_state: 0 }];
+        return { species, abc: wrapped_abc, xyz, label: element, properties: {} };
+    });
+    const lattice = {
+        matrix: lattice_matrix,
+        pbc: original_structure.lattice.pbc,
+        ...lattice_params,
+    };
+    const properties = transferable_properties(original_structure.properties);
+    return {
+        lattice,
+        sites,
+        charge: original_structure.charge,
+        id: original_structure.id,
+        ...(properties === undefined ? {} : { properties }),
+    };
+}
+// Get the conventional (standardized) cell from symmetry analysis data.
+// The conventional cell is the standard crystallographic setting for the space group.
+export function get_conventional_cell(original_structure, // The original input structure
+sym_data) {
+    // The conventional cell as a Crystal
+    return moyo_cell_to_structure(sym_data.std_cell, original_structure);
+}
+// Get the primitive cell from symmetry analysis data.
+// The primitive cell is the smallest unit cell with one lattice point.
+export function get_primitive_cell(original_structure, // The original input structure
+sym_data) {
+    // The primitive cell as a Crystal
+    return moyo_cell_to_structure(sym_data.prim_std_cell, original_structure);
+}
+// Transform a structure based on the selected cell type.
+// Returns the original structure if cell_type is 'original' or if sym_data is not available.
+export function transform_cell(structure, // The original structure
+cell_type, // The desired cell type ('original', 'conventional', or 'primitive')
+sym_data) {
+    //transformed structure (or original if no transformation needed)
+    if (cell_type === `original` || !sym_data) {
+        return structure;
+    }
+    if (cell_type === `conventional`) {
+        return get_conventional_cell(structure, sym_data);
+    }
+    if (cell_type === `primitive`) {
+        return get_primitive_cell(structure, sym_data);
+    }
+    // Fallback to original (should never reach here with proper typing)
+    return structure;
+}

package/dist/symmetry/index.d.ts

@@ -0,0 +1,43 @@
+import type { Vec3 } from '../math';
+import type { AnyStructure, Crystal } from '../structure';
+import type { MoyoDataset } from '@spglib/moyo-wasm';
+export * from './cell-transform';
+export * from './spacegroups';
+export { default as SymmetryStats } from './SymmetryStats.svelte';
+export { default as WyckoffTable } from './WyckoffTable.svelte';
+export declare const BRAVAIS_LATTICES: {
+    readonly P: "Primitive";
+    readonly I: "Body-centered";
+    readonly F: "Face-centered";
+    readonly A: "A-face centered";
+    readonly B: "B-face centered";
+    readonly C: "C-face centered";
+    readonly R: "Rhombohedral";
+};
+export type BravaisLattice = (typeof BRAVAIS_LATTICES)[keyof typeof BRAVAIS_LATTICES];
+export type SymmetrySettings = {
+    symprec: number;
+    algo: `Moyo` | `Spglib`;
+};
+export declare const default_sym_settings: {
+    readonly symprec: number;
+    readonly algo: "Moyo" | "Spglib";
+};
+export type WyckoffPos = {
+    wyckoff: string;
+    elem: string;
+    abc: Vec3;
+    site_indices?: number[];
+};
+export type SymmetryDataset = MoyoDataset & {
+    orig_indices?: number[];
+    orig_site_indices_by_std_idx?: number[][];
+};
+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 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[];
+export declare function apply_symmetry_operations(position: Vec3, operations: MoyoDataset[`operations`], _tolerance?: number): Vec3[];
+export declare function map_wyckoff_to_all_atoms(wyckoff_positions: WyckoffPos[], displayed_structure: Crystal, orig_structure: Crystal, sym_data: MoyoDataset | null, tolerance?: number): WyckoffPos[];

package/dist/symmetry/index.js

@@ -0,0 +1,228 @@
+import { ATOMIC_NUMBER_TO_SYMBOL, SYMBOL_TO_ATOMIC_NUMBER } from '../composition/parse';
+import { DEFAULTS } from '../settings';
+import { merge_split_partial_sites } from '../structure/partial-occupancy';
+import init, { analyze_cell } from '@spglib/moyo-wasm';
+import moyo_wasm_url from '@spglib/moyo-wasm/moyo_wasm_bg.wasm?url';
+export * from './cell-transform';
+export * from './spacegroups';
+export { default as SymmetryStats } from './SymmetryStats.svelte';
+export { default as WyckoffTable } from './WyckoffTable.svelte';
+// Keys are standard crystallographic symbols (P, I, F, A, B, C, R)
+export const BRAVAIS_LATTICES = {
+    P: `Primitive`,
+    I: `Body-centered`,
+    F: `Face-centered`,
+    A: `A-face centered`,
+    B: `B-face centered`,
+    C: `C-face centered`,
+    R: `Rhombohedral`,
+};
+export const default_sym_settings = {
+    symprec: DEFAULTS.symmetry.symprec,
+    algo: DEFAULTS.symmetry.algo,
+};
+let initialized = false;
+const OCCUPANCY_EPS = 1e-8;
+const to_unit = (value) => value - Math.floor(value);
+const near_zero = (value) => Math.min(value, 1 - value);
+const near_half = (value) => Math.abs(value - 0.5);
+const symmetry_position_key = (pos) => pos.map((coord) => to_unit(coord).toFixed(8)).join(`,`);
+const periodic_distance = (pos1, pos2) => Math.sqrt(pos1.reduce((sum, coord, idx) => {
+    // Wrap delta into [-0.5, 0.5) using safe modulo
+    const delta = coord - pos2[idx];
+    const wrapped = ((((delta + 0.5) % 1) + 1) % 1) - 0.5;
+    const distance = Math.abs(wrapped);
+    return sum + distance * distance;
+}, 0));
+export async function ensure_moyo_wasm_ready(wasm_url) {
+    if (initialized)
+        return;
+    // Use provided URL (e.g. from VSCode webview data), otherwise use Vite-bundled URL
+    const url = wasm_url ?? moyo_wasm_url;
+    await init({ module_or_path: url });
+    initialized = true;
+}
+function get_site_atomic_number(site, site_idx) {
+    const occupancy_by_element = new Map();
+    for (const { element, occu } of site.species) {
+        if (occu <= OCCUPANCY_EPS)
+            continue;
+        occupancy_by_element.set(element, (occupancy_by_element.get(element) ?? 0) + occu);
+    }
+    let selected_element = site.species[0]?.element;
+    let best_occupancy = -Infinity;
+    occupancy_by_element.forEach((occupancy, element) => {
+        if (occupancy > best_occupancy ||
+            (occupancy === best_occupancy && element.localeCompare(selected_element ?? ``) < 0)) {
+            selected_element = element;
+            best_occupancy = occupancy;
+        }
+    });
+    if (selected_element === undefined) {
+        throw new Error(`Unknown element at site ${site_idx}: ${selected_element}`);
+    }
+    const atomic_number = SYMBOL_TO_ATOMIC_NUMBER[selected_element];
+    if (atomic_number === undefined) {
+        throw new Error(`Unknown element at site ${site_idx}: ${selected_element}`);
+    }
+    return atomic_number;
+}
+function build_moyo_input_cell(structure) {
+    const merged_render_sites = merge_split_partial_sites(structure.sites);
+    return {
+        positions: merged_render_sites.map(({ site }) => site.abc),
+        numbers: merged_render_sites.map(({ site, site_idx }) => get_site_atomic_number(site, site_idx)),
+        orig_site_indices_by_input_idx: merged_render_sites.map(({ source_site_indices }) => source_site_indices),
+    };
+}
+function build_moyo_cell(structure, positions, numbers) {
+    // nalgebra Matrix3 deserializes as a flat list in COLUMN-MAJOR of the internal basis B
+    // Internal B = transpose(row-basis RB). column-major(B) == row-major(RB).
+    // So supply row-major of the pymatgen lattice.matrix (RB).
+    const [v_a, v_b, v_c] = structure.lattice.matrix;
+    return {
+        lattice: { basis: [...v_a, ...v_b, ...v_c] },
+        positions,
+        numbers,
+    };
+}
+export function to_cell_json(structure) {
+    const { positions, numbers } = build_moyo_input_cell(structure);
+    return JSON.stringify(build_moyo_cell(structure, positions, numbers));
+}
+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;
+            }
+        }
+        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)) {
+        throw new Error(`Symmetry analysis requires a periodic structure with a lattice`);
+    }
+    const moyo_input_cell = build_moyo_input_cell(struct_or_mol);
+    const cell_json = JSON.stringify(build_moyo_cell(struct_or_mol, moyo_input_cell.positions, moyo_input_cell.numbers));
+    const { symprec, algo } = { ...default_sym_settings, ...settings };
+    // Map "Moyo" to "Standard" for moyo-wasm
+    const moyo_algo = algo === `Moyo` ? `Standard` : algo;
+    const sym_data = analyze_cell(cell_json, symprec, moyo_algo);
+    const orig_site_indices_by_std_idx = map_std_to_orig_site_indices(sym_data.std_cell.positions, sym_data.std_cell.numbers, moyo_input_cell.positions, moyo_input_cell.numbers, moyo_input_cell.orig_site_indices_by_input_idx);
+    return { ...sym_data, orig_site_indices_by_std_idx };
+}
+// Helper function to score coordinate simplicity for Wyckoff table
+export function simplicity_score(vec) {
+    const [ax, ay, az] = vec?.map(to_unit) ?? [];
+    return (near_zero(ax) +
+        near_zero(ay) +
+        near_zero(az) +
+        0.5 * (near_half(ax) + near_half(ay) + near_half(az)));
+}
+// Generate Wyckoff table rows from symmetry data
+export function wyckoff_positions_from_moyo(sym_data) {
+    if (!sym_data)
+        return [];
+    const { positions, numbers } = sym_data.std_cell;
+    const { wyckoffs, orig_indices, orig_site_indices_by_std_idx } = sym_data;
+    // Group sites by letter-element combination and track all indices
+    const groups = new Map();
+    // Process all atoms in the standardized cell
+    // Note: wyckoffs array may be shorter than std_cell when moyo combines symmetry-equivalent sites
+    for (let idx = 0; idx < numbers.length; idx++) {
+        // Use wyckoff letter if available, otherwise mark as non-symmetric
+        const full = idx < wyckoffs.length ? wyckoffs[idx] : null;
+        const letter = full?.match(/[a-z]+$/)?.[0] ?? full ?? ``;
+        const atomic_num = numbers[idx];
+        const elem = ATOMIC_NUMBER_TO_SYMBOL[atomic_num] ?? `?`;
+        const position = positions[idx];
+        const key = letter ? `${letter}|${elem}` : `nosym|${elem}|${idx}`;
+        const group = groups.get(key) ?? { letter, elem, indices: [], positions: [] };
+        group.indices.push(idx);
+        group.positions.push(position);
+        groups.set(key, group);
+    }
+    const rows = Array.from(groups.values()).map(({ letter, elem, indices, positions: group_positions }) => {
+        // Find the position with the best simplicity score to display
+        const best_pos = group_positions.reduce((best, pos) => {
+            const score = simplicity_score(pos);
+            return score < best.score ? { pos, score } : best;
+        }, { pos: group_positions[0], score: simplicity_score(group_positions[0]) }).pos;
+        // Map standardized cell indices back to original structure indices
+        const orig_site_indices = orig_site_indices_by_std_idx
+            ? indices.flatMap((std_idx) => orig_site_indices_by_std_idx[std_idx] ?? [])
+            : orig_indices
+                ? indices.map((std_idx) => orig_indices[std_idx]).filter((idx) => idx !== undefined)
+                : indices;
+        const wyckoff = letter ? `${indices.length}${letter}` : `1`;
+        return {
+            wyckoff,
+            elem,
+            abc: best_pos,
+            site_indices: [...new Set(orig_site_indices)].sort((idx_a, idx_b) => idx_a - idx_b),
+        };
+    });
+    rows.sort((w1, w2) => {
+        const [w1_mult, w2_mult] = [parseInt(w1.wyckoff), parseInt(w2.wyckoff)];
+        if (w1_mult !== w2_mult)
+            return w1_mult - w2_mult;
+        return w1.wyckoff.localeCompare(w2.wyckoff);
+    });
+    return rows;
+}
+// Apply symmetry operations to find all equivalent positions for a given fractional coordinate
+export function apply_symmetry_operations(position, operations, _tolerance = 1e-6) {
+    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] +
+            translation[dim]);
+        return new_pos.map(to_unit);
+    })
+        .filter((pos) => {
+        const pos_key = symmetry_position_key(pos);
+        if (seen.has(pos_key))
+            return false;
+        seen.add(pos_key);
+        return true;
+    });
+}
+// Map Wyckoff positions to all equivalent atoms in the displayed structure (including image atoms)
+export function map_wyckoff_to_all_atoms(wyckoff_positions, displayed_structure, orig_structure, sym_data, tolerance = 1e-5) {
+    if (!sym_data?.operations || !displayed_structure.sites || !orig_structure.sites) {
+        return wyckoff_positions;
+    }
+    return wyckoff_positions.map((wyckoff_pos) => {
+        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];
+            const element = species[0]?.element;
+            const equivalent_positions = apply_symmetry_operations(orig_abc, sym_data.operations, tolerance);
+            return displayed_structure.sites
+                .map((site, display_idx) => ({ site, display_idx }))
+                .filter(({ site }) => site.species[0]?.element === element)
+                .filter(({ site }) => equivalent_positions.some((equiv_pos) => periodic_distance(equiv_pos, site.abc) < tolerance))
+                .map(({ display_idx }) => display_idx);
+        });
+        return { ...wyckoff_pos, site_indices: [...new Set(indices)].sort((a, b) => a - b) };
+    });
+}

package/dist/symmetry/spacegroups.d.ts

@@ -0,0 +1,9 @@
+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"];
+export type CrystalSystem = (typeof CRYSTAL_SYSTEMS)[number];
+export declare function spacegroup_num_to_crystal_sys(spacegroup: number): CrystalSystem | null;
+export declare function spacegroup_to_crystal_sys(spacegroup: number | string): CrystalSystem | null;
+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>;