matterviz 0.3.4 → 0.3.6

package/dist/structure/StructureScene.svelte.d.ts

@@ -1,104 +0,0 @@
-import type { D3InterpolateName } from '../colors';
-import type { ElementSymbol } from '../element';
-import type { IsosurfaceSettings, VolumetricData } from '../isosurface/types';
-import type { Vec3 } from '../math';
-import type { CameraProjection, ShowBonds, VectorColorMode, VectorLayerConfig } from '../settings';
-import type { AnyStructure, MeasureMode, Site } from './';
-import { Lattice } from './';
-import type { AtomColorConfig } from './atom-properties';
-import type { MoyoDataset } from '@spglib/moyo-wasm';
-import * as extras from '@threlte/extras';
-import { type ComponentProps, type Snippet } from 'svelte';
-import { SvelteMap } from 'svelte/reactivity';
-import { type Camera, type Scene } from 'three';
-import type { BondingStrategy } from './bonding';
-type $$ComponentProps = {
-    structure?: AnyStructure;
-    base_structure?: AnyStructure;
-    atom_radius?: number;
-    same_size_atoms?: boolean;
-    camera_position?: [x: number, y: number, z: number];
-    camera_target?: Vec3;
-    camera_projection?: CameraProjection;
-    rotation_damping?: number;
-    max_zoom?: number;
-    min_zoom?: number;
-    rotate_speed?: number;
-    zoom_speed?: number;
-    pan_speed?: number;
-    zoom_to_cursor?: boolean;
-    show_atoms?: boolean;
-    show_bonds?: ShowBonds;
-    show_site_labels?: boolean;
-    show_site_indices?: boolean;
-    vector_configs?: Record<string, VectorLayerConfig>;
-    vector_scale?: number;
-    vector_color?: string;
-    vector_color_mode?: VectorColorMode;
-    vector_color_scale?: D3InterpolateName;
-    vector_normalize?: boolean;
-    vector_uniform_thickness?: boolean;
-    vector_origin_gap?: number;
-    vector_shaft_radius?: number;
-    vector_arrow_head_radius?: number;
-    vector_arrow_head_length?: number;
-    gizmo?: boolean | ComponentProps<typeof extras.Gizmo>;
-    hovered_idx?: number | null;
-    hovered_site?: Site | null;
-    float_fmt?: string;
-    auto_rotate?: number;
-    initial_zoom?: number;
-    bond_thickness?: number;
-    bond_color?: string;
-    bonding_strategy?: BondingStrategy;
-    bonding_options?: Record<string, unknown>;
-    fov?: number;
-    ambient_light?: number;
-    directional_light?: number;
-    sphere_segments?: number;
-    lattice_props?: ComponentProps<typeof Lattice>;
-    atom_label?: Snippet<[{
-        site: Site;
-        site_idx: number;
-    }]>;
-    site_label_size?: number;
-    site_label_offset?: Vec3;
-    site_label_bg_color?: string;
-    site_label_color?: string;
-    site_label_padding?: number;
-    camera_is_moving?: boolean;
-    width?: number;
-    height?: number;
-    measure_mode?: MeasureMode;
-    selected_sites?: number[];
-    measured_sites?: number[];
-    added_bonds?: [number, number][];
-    removed_bonds?: [number, number][];
-    selection_highlight_color?: string;
-    active_sites?: number[];
-    active_highlight_color?: string;
-    rotation?: Vec3;
-    scene?: Scene;
-    camera?: Camera;
-    orbit_controls?: ComponentProps<typeof extras.OrbitControls>[`ref`];
-    rotation_target_ref?: Vec3;
-    initial_computed_zoom?: number;
-    hidden_elements?: Set<ElementSymbol>;
-    hidden_prop_vals?: Set<number | string>;
-    element_radius_overrides?: Partial<Record<ElementSymbol, number>>;
-    site_radius_overrides?: Map<number, number> | SvelteMap<number, number>;
-    atom_color_config?: Partial<AtomColorConfig>;
-    sym_data?: MoyoDataset | null;
-    on_sites_moved?: (scene_indices: number[], delta: Vec3) => void;
-    on_operation_start?: () => void;
-    on_add_atom?: (xyz: Vec3, element: ElementSymbol) => void;
-    add_atom_mode?: boolean;
-    add_element?: ElementSymbol;
-    cursor?: string;
-    dragging_atoms?: boolean;
-    volumetric_data?: VolumetricData;
-    isosurface_settings?: IsosurfaceSettings;
-};
-declare const StructureScene: import("svelte").Component<$$ComponentProps, {}, "cursor" | "site_label_offset" | "vector_configs" | "camera" | "scene" | "orbit_controls" | "hidden_elements" | "hidden_prop_vals" | "element_radius_overrides" | "site_radius_overrides" | "selected_sites" | "hovered_idx" | "hovered_site" | "camera_is_moving" | "measured_sites" | "added_bonds" | "removed_bonds" | "active_sites" | "rotation_target_ref" | "initial_computed_zoom" | "add_atom_mode" | "add_element" | "dragging_atoms">;
-type StructureScene = ReturnType<typeof StructureScene>;
-export default StructureScene;

package/dist/structure/atom-properties.d.ts

@@ -1,37 +0,0 @@
-import type { ColorScaleType, D3InterpolateName } from '../colors';
-import type { AtomColorMode } from '../settings';
-import type { AnyStructure, Site } from './';
-import type { BondingStrategy } from './bonding';
-import type { MoyoDataset } from '@spglib/moyo-wasm';
-export interface AtomColorConfig {
-    mode: AtomColorMode;
-    scale?: D3InterpolateName;
-    scale_type: ColorScaleType;
-    color_fn?: (site: Site, idx: number) => number | string;
-}
-export interface AtomPropertyColors {
-    colors: string[];
-    values: (number | string)[];
-    min_value?: number;
-    max_value?: number;
-    unique_values?: (number | string)[];
-}
-type SymmetryDataWithOrigMap = MoyoDataset & {
-    orig_site_indices_by_std_idx?: number[][];
-};
-export declare const get_d3_color_scales: () => string[];
-export declare function apply_color_scale(vals: number[], scale?: string, type?: ColorScaleType): {
-    colors: string[];
-    unique_values?: number[];
-};
-export declare const apply_categorical_color_scale: (vals: string[], scale?: string) => {
-    colors: string[];
-    unique_values: string[];
-};
-export declare const get_orig_site_idx: (site: Site | undefined, site_idx: number) => number;
-export declare function get_coordination_colors(structure: AnyStructure, strategy?: BondingStrategy, scale?: string, type?: ColorScaleType): AtomPropertyColors;
-export declare function get_wyckoff_colors(structure: AnyStructure, sym_data: SymmetryDataWithOrigMap | null, scale?: string): AtomPropertyColors;
-export declare function get_custom_colors(structure: AnyStructure, fn: (site: Site, idx: number) => number | string, scale?: string, type?: ColorScaleType): AtomPropertyColors;
-export declare function get_atom_colors(structure: AnyStructure, config: Partial<AtomColorConfig>, bonding_strategy?: BondingStrategy, sym_data?: MoyoDataset | null): AtomPropertyColors;
-export declare function get_property_colors(structure: AnyStructure | undefined, config: Partial<AtomColorConfig>, bonding_strategy: BondingStrategy, sym_data: MoyoDataset | null): AtomPropertyColors | null;
-export {};

package/dist/structure/atom-properties.js

@@ -1,198 +0,0 @@
-// Utility functions for computing atom properties and applying color scales
-import { calc_coordination_nums } from '../coordination';
-import * as math from '../math';
-import { wrap_to_unit_cell } from './pbc';
-import { rgb } from 'd3-color';
-import * as d3_sc from 'd3-scale-chromatic';
-const GRAY = `#808080`;
-const DEFAULT_COLOR_SCALE = `interpolateViridis`;
-export const get_d3_color_scales = () => Object.keys(d3_sc).filter((key) => key.startsWith(`interpolate`));
-const get_interpolator = (scale) => {
-    const interp_fn = d3_sc[scale];
-    if (typeof interp_fn !== `function`) {
-        console.warn(`Unknown D3 scale: ${scale}, using ${DEFAULT_COLOR_SCALE}`);
-        return d3_sc.interpolateViridis;
-    }
-    return interp_fn;
-};
-const to_hex = (interp_fn, t) => rgb(interp_fn(t)).formatHex();
-const build_image_site = (site, frac_to_cart, offset, orig_idx) => {
-    const img_abc = [
-        site.abc[0] + offset[0],
-        site.abc[1] + offset[1],
-        site.abc[2] + offset[2],
-    ];
-    return {
-        ...site,
-        abc: img_abc,
-        xyz: frac_to_cart(img_abc),
-        properties: { ...site.properties, orig_site_idx: orig_idx },
-    };
-};
-const get_all_offsets = (pbc) => [-1, 0, 1]
-    .flatMap((dx) => [-1, 0, 1].flatMap((dy) => [-1, 0, 1].map((dz) => [dx, dy, dz])))
-    .filter(([dx, dy, dz]) => !(dx === 0 && dy === 0 && dz === 0) &&
-    (pbc[0] || dx === 0) &&
-    (pbc[1] || dy === 0) &&
-    (pbc[2] || dz === 0));
-const make_categorical = (vals, scale, sort_fn) => {
-    const interp_fn = get_interpolator(scale);
-    const uniq = sort_fn ? [...new Set(vals)].sort(sort_fn) : [...new Set(vals)].sort();
-    const colors = uniq.map((_, idx) => to_hex(interp_fn, uniq.length === 1 ? 0.5 : idx / (uniq.length - 1)));
-    const map = new Map(uniq.map((val, idx) => [val, colors[idx]]));
-    return {
-        colors: vals.map((val) => map.get(val) ?? GRAY),
-        unique_values: uniq,
-    };
-};
-const build_prop_colors = (vals, colors, unique_values) => {
-    const uniq = unique_values ?? [...new Set(vals)].sort((val_a, val_b) => val_a - val_b);
-    // Use sorted uniq array to avoid spreading large arrays into Math.min/max
-    const min_value = uniq.length > 0 ? uniq[0] : undefined;
-    const max_value = uniq.at(-1);
-    return { colors, values: vals, min_value, max_value, unique_values: uniq };
-};
-export function apply_color_scale(vals, scale = DEFAULT_COLOR_SCALE, type = `continuous`) {
-    if (!vals.length)
-        return { colors: [] };
-    if (type === `categorical`) {
-        const result = make_categorical(vals, scale, (val_a, val_b) => val_a - val_b);
-        return { colors: result.colors, unique_values: result.unique_values };
-    }
-    const interp_fn = get_interpolator(scale);
-    // Compute min/max in single pass to avoid spreading large arrays
-    let [min, max] = [vals[0], vals[0]];
-    for (const val of vals) {
-        if (val < min)
-            min = val;
-        if (val > max)
-            max = val;
-    }
-    return {
-        colors: vals.map((val) => to_hex(interp_fn, max === min ? 0.5 : (val - min) / (max - min))),
-    };
-}
-export const apply_categorical_color_scale = (vals, scale = DEFAULT_COLOR_SCALE) => vals.length ? make_categorical(vals, scale) : { colors: [], unique_values: [] };
-// Get original site index for property color lookup.
-// Supercell atoms use orig_unit_cell_idx, image atoms use orig_site_idx, otherwise use site_idx.
-export const get_orig_site_idx = (site, site_idx) => typeof site?.properties?.orig_unit_cell_idx === `number`
-    ? site.properties.orig_unit_cell_idx
-    : typeof site?.properties?.orig_site_idx === `number`
-        ? site.properties.orig_site_idx
-        : site_idx;
-// Expand structure with PBC images - use minimal expansion based on atom positions
-function expand_structure_for_pbc(structure) {
-    if (!(`lattice` in structure) || !structure.lattice || !structure.sites.length) {
-        return structure;
-    }
-    const { sites, lattice } = structure;
-    const frac_to_cart = math.create_frac_to_cart(lattice.matrix);
-    const pbc = lattice.pbc ?? [true, true, true];
-    const all_offsets = get_all_offsets(pbc);
-    // Small structures: expand all atoms
-    if (sites.length < 20 || !pbc.some((periodic) => periodic)) {
-        const image_sites = sites.flatMap((site, orig_idx) => all_offsets.map((offset) => build_image_site(site, frac_to_cart, offset, orig_idx)));
-        return { ...structure, sites: [...sites, ...image_sites] };
-    }
-    // Large structures: only expand atoms near boundaries (within 5Å bond distance)
-    const cutoff = [5.0 / lattice.a, 5.0 / lattice.b, 5.0 / lattice.c];
-    const image_sites = sites.flatMap((site, orig_idx) => {
-        const norm = wrap_to_unit_cell(site.abc);
-        return all_offsets
-            .filter(([dx, dy, dz]) => (dx === 0 || (dx === -1 ? norm[0] <= cutoff[0] : norm[0] >= 1 - cutoff[0])) &&
-            (dy === 0 || (dy === -1 ? norm[1] <= cutoff[1] : norm[1] >= 1 - cutoff[1])) &&
-            (dz === 0 || (dz === -1 ? norm[2] <= cutoff[2] : norm[2] >= 1 - cutoff[2])))
-            .map((offset) => build_image_site(site, frac_to_cart, offset, orig_idx));
-    });
-    return { ...structure, sites: [...sites, ...image_sites] };
-}
-export function get_coordination_colors(structure, strategy = `electroneg_ratio`, scale = DEFAULT_COLOR_SCALE, type = `continuous`) {
-    const orig_site_count = structure.sites.length;
-    // Check if structure has periodic boundary conditions
-    const has_lattice = `lattice` in structure && structure.lattice !== undefined;
-    const pbc = has_lattice ? structure.lattice.pbc : undefined;
-    const has_pbc = has_lattice && (pbc === undefined || pbc.some((is_periodic) => is_periodic));
-    // For PBC structures, expand with images from neighboring cells for accurate coordination
-    const coord_structure = has_pbc ? expand_structure_for_pbc(structure) : structure;
-    // Calculate coordination numbers on the (potentially expanded) structure
-    const all_coord_data = calc_coordination_nums(coord_structure, strategy);
-    // Extract coordination numbers only for the original sites (not image atoms)
-    const coord_nums = all_coord_data.sites
-        .slice(0, orig_site_count)
-        .map((site) => site.coordination_num);
-    const { colors, unique_values } = apply_color_scale(coord_nums, scale, type);
-    return build_prop_colors(coord_nums, colors, unique_values);
-}
-export function get_wyckoff_colors(structure, sym_data, scale = DEFAULT_COLOR_SCALE) {
-    const n = structure.sites.length;
-    if (!sym_data?.wyckoffs || sym_data.wyckoffs.length === 0) {
-        return {
-            colors: Array(n).fill(GRAY),
-            values: Array(n).fill(`unknown`),
-            unique_values: [`unknown`],
-        };
-    }
-    const wyckoff_by_orig_idx = new Map();
-    const mapping_by_std_idx = sym_data.orig_site_indices_by_std_idx;
-    if (mapping_by_std_idx) {
-        for (let std_idx = 0; std_idx < sym_data.wyckoffs.length; std_idx += 1) {
-            const wyckoff = sym_data.wyckoffs[std_idx];
-            for (const orig_idx of mapping_by_std_idx[std_idx] ?? []) {
-                if (!wyckoff_by_orig_idx.has(orig_idx))
-                    wyckoff_by_orig_idx.set(orig_idx, wyckoff);
-            }
-        }
-    }
-    // Create unique orbit identifiers: Wyckoff position + element symbol
-    const orbit_ids = structure.sites.map((site, idx) => {
-        const sym_idx = get_orig_site_idx(site, idx);
-        const mapped_wyckoff = wyckoff_by_orig_idx.get(sym_idx);
-        if (mapped_wyckoff !== undefined) {
-            const element = site.species[0]?.element ?? `?`;
-            return mapped_wyckoff ? `${mapped_wyckoff}|${element}` : `unknown`;
-        }
-        if (sym_idx >= sym_data.wyckoffs.length) {
-            console.error(`[get_wyckoff_colors] Site ${idx} (maps to ${sym_idx}) has no Wyckoff data. ` +
-                `Structure has ${n} sites but symmetry data only has ${sym_data.wyckoffs.length}.`);
-            return `unknown`;
-        }
-        const wyckoff = sym_data.wyckoffs[sym_idx];
-        const element = site.species[0]?.element ?? `?`;
-        return wyckoff ? `${wyckoff}|${element}` : `unknown`;
-    });
-    const { colors, unique_values } = apply_categorical_color_scale(orbit_ids, scale);
-    return { colors, values: orbit_ids, unique_values };
-}
-export function get_custom_colors(structure, fn, scale = DEFAULT_COLOR_SCALE, type = `continuous`) {
-    const vals = structure.sites.map((site, idx) => fn(site, idx));
-    const is_num = vals.every((val) => typeof val === `number`);
-    if (is_num) {
-        const nums = vals;
-        const { colors, unique_values } = apply_color_scale(nums, scale, type);
-        return build_prop_colors(nums, colors, unique_values);
-    }
-    const strs = vals.map(String);
-    const { colors, unique_values } = apply_categorical_color_scale(strs, scale);
-    return { colors, values: strs, unique_values };
-}
-export function get_atom_colors(structure, config, bonding_strategy = `electroneg_ratio`, sym_data = null) {
-    const { mode = `element`, scale = DEFAULT_COLOR_SCALE, scale_type = `continuous` } = config;
-    if (mode === `coordination`) {
-        return get_coordination_colors(structure, bonding_strategy, scale, scale_type);
-    }
-    if (mode === `wyckoff`)
-        return get_wyckoff_colors(structure, sym_data, scale);
-    if (mode === `custom` && config.color_fn) {
-        return get_custom_colors(structure, config.color_fn, scale, scale_type);
-    }
-    // Element mode or custom without function, no property colors needed
-    return { colors: [], values: [] };
-}
-// Helper: Get property colors with null safety check
-// Returns null if structure is missing, mode is element, or no colors computed
-export function get_property_colors(structure, config, bonding_strategy, sym_data) {
-    if (!structure || config.mode === `element`)
-        return null;
-    const result = get_atom_colors(structure, config, bonding_strategy, sym_data);
-    return result.colors.length ? result : null;
-}

package/dist/structure/bonding.d.ts

@@ -1,33 +0,0 @@
-import type { Vec3 } from '../math';
-import type { AnyStructure, BondPair } from './';
-export declare function compute_bond_transform(pos_1: Vec3, pos_2: Vec3): Float32Array;
-export declare const BONDING_STRATEGIES: {
-    readonly electroneg_ratio: typeof electroneg_ratio;
-    readonly solid_angle: typeof solid_angle;
-};
-export type BondingStrategy = keyof typeof BONDING_STRATEGIES;
-export type BondingAlgo = (typeof BONDING_STRATEGIES)[BondingStrategy];
-export declare function electroneg_ratio(structure: AnyStructure, { electronegativity_threshold, // Max electronegativity difference for bonding
-max_distance_ratio, // Max distance as multiple of sum of covalent radii
-min_bond_dist, // Minimum bond distance in Angstroms
-metal_metal_penalty, // Strength penalty for metal-metal bonds
-metal_nonmetal_bonus, // Strength bonus for metal-nonmetal bonds
-similar_electronegativity_bonus, // Bonus for similar electronegativity
-same_species_penalty, // Penalty for bonds between same element
-strength_threshold, }?: {
-    electronegativity_threshold?: number | undefined;
-    max_distance_ratio?: number | undefined;
-    min_bond_dist?: number | undefined;
-    metal_metal_penalty?: number | undefined;
-    metal_nonmetal_bonus?: number | undefined;
-    similar_electronegativity_bonus?: number | undefined;
-    same_species_penalty?: number | undefined;
-    strength_threshold?: number | undefined;
-}): BondPair[];
-export declare function solid_angle(structure: AnyStructure, { min_solid_angle, min_face_area, max_distance, min_bond_dist, strength_threshold, }?: {
-    min_solid_angle?: number | undefined;
-    min_face_area?: number | undefined;
-    max_distance?: number | undefined;
-    min_bond_dist?: number | undefined;
-    strength_threshold?: number | undefined;
-}): BondPair[];

package/dist/structure/bonding.js

@@ -1,304 +0,0 @@
-// Bonding algorithms for structure visualization
-import { element_data } from '../element';
-import * as math from '../math';
-const element_lookup = new Map(element_data.map((el) => [el.symbol, el]));
-const covalent_radii = new Map(element_data
-    .filter((el) => el.covalent_radius !== null)
-    .map((el) => [el.symbol, el.covalent_radius]));
-// Get the species with highest occupancy from a site.
-const get_majority_species = (site) => (site.species ?? []).reduce((max_species, species) => (species.occu > max_species.occu ? species : max_species), site.species?.[0] ?? { element: ``, occu: -1 });
-// Helper to extract numeric index from site properties
-function get_orig_idx(site, fallback) {
-    const props = site.properties;
-    if (!props)
-        return fallback;
-    const raw = props.orig_unit_cell_idx ?? props.orig_site_idx;
-    if (raw === undefined)
-        return fallback;
-    const num = Number(raw);
-    return Number.isFinite(num) ? num : fallback;
-}
-// Compute 4x4 transformation matrix for bond cylinder between two positions.
-// Uses Y-up, right-handed coordinate system convention for Three.js compatibility.
-export function compute_bond_transform(pos_1, pos_2) {
-    const [dx, dy, dz] = math.subtract(pos_2, pos_1);
-    const height = Math.hypot(dx, dy, dz);
-    if (height < 1e-10) {
-        return new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-    }
-    const [dir_x, dir_y, dir_z] = [dx / height, dy / height, dz / height];
-    let [m00, m01, m02, m10, m11, m12, m20, m21, m22] = [0, 0, 0, 0, 0, 0, 0, 0, 0];
-    // Special case: bond pointing straight up (+Y)
-    if (Math.abs(dir_y - 1.0) < 1e-10) {
-        ;
-        [m00, m01, m02, m10, m11, m12, m20, m21, m22] = [1, 0, 0, 0, 1, 0, 0, 0, 1];
-    }
-    else if (Math.abs(dir_y + 1.0) < 1e-10) {
-        // Special case: bond pointing straight down (-Y)
-        ;
-        [m00, m01, m02, m10, m11, m12, m20, m21, m22] = [1, 0, 0, 0, -1, 0, 0, 0, 1];
-    }
-    else {
-        // General case: construct orthonormal basis (right, dir, up)
-        // Right vector: perpendicular to dir in XZ plane
-        const [rx, rz] = [-dir_z, dir_x];
-        const r_len = Math.hypot(rx, rz);
-        const [right_x, right_z] = [rx / r_len, rz / r_len];
-        // Up vector: cross product of dir and right
-        const [up_x, up_y, up_z] = [
-            dir_y * right_z,
-            dir_z * right_x - dir_x * right_z,
-            -dir_y * right_x,
-        ];
-        [m00, m01, m02, m10, m11, m12, m20, m21, m22] = [
-            right_x,
-            dir_x,
-            up_x,
-            0,
-            dir_y,
-            up_y,
-            right_z,
-            dir_z,
-            up_z,
-        ];
-    }
-    // Position at midpoint between the two atoms
-    const [px, py, pz] = [
-        (pos_1[0] + pos_2[0]) / 2,
-        (pos_1[1] + pos_2[1]) / 2,
-        (pos_1[2] + pos_2[2]) / 2,
-    ];
-    return new Float32Array([
-        // Return flattened column-major 4x4 matrix for Three.js
-        ...[m00, m10, m20, 0],
-        ...[m01 * height, m11 * height, m21 * height, 0],
-        ...[m02, m12, m22, 0],
-        ...[px, py, pz, 1],
-    ]);
-}
-// Build spatial grid by dividing 3D space into cubic cells.
-function build_spatial_grid(sites, cell_size) {
-    const grid = new Map();
-    for (let idx = 0; idx < sites.length; idx++) {
-        const [x, y, z] = sites[idx].xyz.map((coord) => Math.floor(coord / cell_size));
-        const key = `${x},${y},${z}`;
-        const cell = grid.get(key);
-        if (cell)
-            cell.push(idx);
-        else
-            grid.set(key, [idx]);
-    }
-    return grid;
-}
-// Get all site indices in 3x3x3 cube of cells around position.
-function get_neighbors_from_grid(pos, grid, cell_size) {
-    const [cx, cy, cz] = [
-        Math.floor(pos[0] / cell_size),
-        Math.floor(pos[1] / cell_size),
-        Math.floor(pos[2] / cell_size),
-    ];
-    const neighbors = [];
-    for (let dx = -1; dx <= 1; dx++) {
-        for (let dy = -1; dy <= 1; dy++) {
-            for (let dz = -1; dz <= 1; dz++) {
-                const cell = grid.get(`${cx + dx},${cy + dy},${cz + dz}`);
-                if (cell)
-                    neighbors.push(...cell);
-            }
-        }
-    }
-    return neighbors;
-}
-// Setup spatial decomposition for structures with >50 atoms.
-function setup_spatial_grid(sites, cutoff) {
-    const use_grid = sites.length > 50;
-    return use_grid ? { grid: build_spatial_grid(sites, cutoff), cell_size: cutoff } : null;
-}
-// Get candidate neighbor indices using spatial grid or all sites.
-const get_candidates = (pos, sites, spatial) => spatial
-    ? get_neighbors_from_grid(pos, spatial.grid, spatial.cell_size)
-    : Array.from({ length: sites.length }, (_, idx) => idx);
-export const BONDING_STRATEGIES = { electroneg_ratio, solid_angle };
-// Electronegativity-based bonding with chemical preferences.
-// This algorithm considers electronegativity differences between atoms, metal/nonmetal
-// properties, and distance to determine bond strength. Bonds are only created if the
-// computed strength exceeds the strength_threshold parameter (default: 0.3).
-export function electroneg_ratio(structure, { electronegativity_threshold = 1.7, // Max electronegativity difference for bonding
-max_distance_ratio = 2.0, // Max distance as multiple of sum of covalent radii
-min_bond_dist = 0.4, // Minimum bond distance in Angstroms
-metal_metal_penalty = 0.7, // Strength penalty for metal-metal bonds
-metal_nonmetal_bonus = 1.5, // Strength bonus for metal-nonmetal bonds
-similar_electronegativity_bonus = 1.2, // Bonus for similar electronegativity
-same_species_penalty = 0.5, // Penalty for bonds between same element
-strength_threshold = 0.3, // Minimum bond strength to include in results
- } = {}) {
-    const { sites } = structure;
-    if (sites.length < 2)
-        return [];
-    const bonds = [];
-    const min_dist_sq = min_bond_dist ** 2;
-    const closest = new Map();
-    const props = sites.map((site) => {
-        const majority = get_majority_species(site);
-        const elem = majority.element;
-        const data = element_lookup.get(elem);
-        return {
-            element: elem,
-            electroneg: data?.electronegativity ?? 2.0,
-            is_metal: data?.metal ?? false,
-            is_nonmetal: data?.nonmetal ?? false,
-            radius: elem ? covalent_radii.get(elem) : undefined,
-        };
-    });
-    let max_radius = 0;
-    for (const radius of covalent_radii.values()) {
-        if (radius > max_radius)
-            max_radius = radius;
-    }
-    const max_cutoff = max_radius * 2 * max_distance_ratio;
-    const spatial = setup_spatial_grid(sites, max_cutoff);
-    const potential_bonds = [];
-    for (let idx_a = 0; idx_a < sites.length - 1; idx_a++) {
-        const [x1, y1, z1] = sites[idx_a].xyz;
-        const props_a = props[idx_a];
-        for (const idx_b of get_candidates(sites[idx_a].xyz, sites, spatial)) {
-            if (idx_b <= idx_a)
-                continue;
-            const [x2, y2, z2] = sites[idx_b].xyz;
-            const props_b = props[idx_b];
-            const [dx, dy, dz] = [x2 - x1, y2 - y1, z2 - z1];
-            const dist_sq = dx * dx + dy * dy + dz * dz;
-            const dist = Math.sqrt(dist_sq);
-            if (dist_sq < min_dist_sq || !props_a.radius || !props_b.radius)
-                continue;
-            const expected = props_a.radius + props_b.radius;
-            if (dist > expected * max_distance_ratio)
-                continue;
-            const electroneg_diff = Math.abs(props_a.electroneg - props_b.electroneg);
-            const electroneg_ratio = electroneg_diff / (props_a.electroneg + props_b.electroneg);
-            let bond_strength = 1.0;
-            if (props_a.is_metal && props_b.is_metal) {
-                bond_strength *= metal_metal_penalty;
-            }
-            else if ((props_a.is_metal && props_b.is_nonmetal) ||
-                (props_a.is_nonmetal && props_b.is_metal)) {
-                bond_strength *= metal_nonmetal_bonus;
-                if (electroneg_diff > electronegativity_threshold)
-                    bond_strength *= 1.3;
-            }
-            else if (electroneg_diff < 0.5) {
-                bond_strength *= similar_electronegativity_bonus;
-            }
-            const dist_weight = Math.exp(-((dist / expected - 1) ** 2) / 0.18);
-            const electroneg_weight = 1.0 - 0.3 * electroneg_ratio;
-            let strength = bond_strength * dist_weight * electroneg_weight;
-            if (props_a.element === props_b.element)
-                strength *= same_species_penalty;
-            // If raw strength is already too low, we can skip early
-            // (penalty will only reduce it further)
-            if (strength <= strength_threshold)
-                continue;
-            // Use helper logic to handle both supercell and image atoms with robust normalization
-            const orig_idx_a = get_orig_idx(sites[idx_a], idx_a);
-            const orig_idx_b = get_orig_idx(sites[idx_b], idx_b);
-            // Update closest known normalized distance (dist / expected) for original atoms
-            // Normalized distance handles atoms of different sizes better than raw distance
-            // (e.g. C-H is short but C-C is longer; we don't want C-H to penalize C-C just because H is small)
-            const norm_dist = dist / expected;
-            const closest_dist_a = closest.get(orig_idx_a) ?? Infinity;
-            if (norm_dist < closest_dist_a)
-                closest.set(orig_idx_a, norm_dist);
-            const closest_dist_b = closest.get(orig_idx_b) ?? Infinity;
-            if (norm_dist < closest_dist_b)
-                closest.set(orig_idx_b, norm_dist);
-            potential_bonds.push({
-                site_idx_1: idx_a,
-                site_idx_2: idx_b,
-                dist,
-                expected_dist: expected,
-                base_strength: strength,
-                orig_idx_a,
-                orig_idx_b,
-            });
-        }
-    }
-    // Second pass: Apply penalties and filter
-    for (const bond of potential_bonds) {
-        const { site_idx_1, site_idx_2, dist, expected_dist, base_strength, orig_idx_a, orig_idx_b, } = bond;
-        const closest_dist_a = closest.get(orig_idx_a) ?? Infinity;
-        const closest_dist_b = closest.get(orig_idx_b) ?? Infinity;
-        const norm_dist = dist / expected_dist;
-        let strength = base_strength;
-        // Apply penalty if this bond is much longer (relative to radii) than the closest known bond
-        if (norm_dist > closest_dist_a) {
-            strength *= Math.exp(-(norm_dist / closest_dist_a - 1) / 0.5);
-        }
-        if (orig_idx_b !== orig_idx_a && norm_dist > closest_dist_b) {
-            strength *= Math.exp(-(norm_dist / closest_dist_b - 1) / 0.5);
-        }
-        if (strength > strength_threshold) {
-            bonds.push({
-                pos_1: sites[site_idx_1].xyz,
-                pos_2: sites[site_idx_2].xyz,
-                site_idx_1,
-                site_idx_2,
-                bond_length: dist,
-                strength,
-                transform_matrix: compute_bond_transform(sites[site_idx_1].xyz, sites[site_idx_2].xyz),
-            });
-        }
-    }
-    return bonds;
-}
-// Solid angle-based bonding using geometric proximity heuristics.
-// Inspired by Voronoi tessellation without having to actually compute Voronoi cells.
-// This algorithm computes bond strength based on the solid angle subtended by atoms
-// and their distance penalty. Bonds are only created if the computed strength exceeds
-// the strength_threshold parameter.
-export function solid_angle(structure, { min_solid_angle = 0.01, min_face_area = 0.05, max_distance = 5.0, min_bond_dist = 0.4, strength_threshold = 0.05, } = {}) {
-    const { sites } = structure;
-    if (sites.length < 2)
-        return [];
-    const bonds = [];
-    const min_dist_sq = min_bond_dist ** 2;
-    const max_dist_sq = max_distance ** 2;
-    const spatial = setup_spatial_grid(sites, max_distance);
-    for (let idx_a = 0; idx_a < sites.length - 1; idx_a++) {
-        const [x1, y1, z1] = sites[idx_a].xyz;
-        const majority_a = get_majority_species(sites[idx_a]);
-        const radius_a = majority_a.element ? covalent_radii.get(majority_a.element) : undefined;
-        for (const idx_b of get_candidates(sites[idx_a].xyz, sites, spatial)) {
-            if (idx_b <= idx_a)
-                continue;
-            const [x2, y2, z2] = sites[idx_b].xyz;
-            const majority_b = get_majority_species(sites[idx_b]);
-            const radius_b = majority_b.element ? covalent_radii.get(majority_b.element) : undefined;
-            const [dx, dy, dz] = [x2 - x1, y2 - y1, z2 - z1];
-            const dist_sq = dx * dx + dy * dy + dz * dz;
-            const dist = Math.sqrt(dist_sq);
-            if (dist_sq < min_dist_sq || dist_sq > max_dist_sq || !radius_a || !radius_b) {
-                continue;
-            }
-            const avg_radius = (radius_a + radius_b) / 2.0;
-            const face_area = Math.PI * avg_radius * avg_radius;
-            const solid_angle = face_area / dist_sq;
-            if (solid_angle < min_solid_angle || face_area < min_face_area)
-                continue;
-            const dist_penalty = Math.exp(-((dist / (radius_a + radius_b) - 1) ** 2) / 0.4);
-            const angle_strength = Math.min(solid_angle / (4.0 * Math.PI), 1.0);
-            const strength = angle_strength * dist_penalty;
-            if (strength > strength_threshold) {
-                bonds.push({
-                    pos_1: sites[idx_a].xyz,
-                    pos_2: sites[idx_b].xyz,
-                    site_idx_1: idx_a,
-                    site_idx_2: idx_b,
-                    bond_length: dist,
-                    strength,
-                    transform_matrix: compute_bond_transform(sites[idx_a].xyz, sites[idx_b].xyz),
-                });
-            }
-        }
-    }
-    return bonds;
-}