matterviz 0.3.4 → 0.3.6

package/dist/trajectory/index.js

@@ -1,126 +0,0 @@
-export { default as Trajectory } from './Trajectory.svelte';
-export { default as TrajectoryError } from './TrajectoryError.svelte';
-export { default as TrajectoryExportPane } from './TrajectoryExportPane.svelte';
-export { default as TrajectoryInfoPane } from './TrajectoryInfoPane.svelte';
-export function validate_trajectory(trajectory) {
-    // with detailed error reporting
-    const errors = [];
-    const { frames, total_frames, indexed_frames, plot_metadata, is_indexed } = trajectory;
-    if (!frames?.length)
-        return [`Trajectory must have at least one frame`];
-    frames.forEach((frame, idx) => {
-        if (!frame.structure?.sites?.length) {
-            errors.push(`Frame ${idx} missing structure or sites`);
-        }
-        if (typeof frame.step !== `number`) {
-            errors.push(`Frame ${idx} missing or invalid step number`);
-        }
-    });
-    // Validate streaming-related properties
-    if (total_frames !== undefined) {
-        if (typeof total_frames !== `number` || total_frames < 1) {
-            errors.push(`total_frames must be a positive number, got ${total_frames}`);
-        }
-        else if (indexed_frames?.length) {
-            const last_indexed_frame = indexed_frames.at(-1);
-            if (last_indexed_frame && last_indexed_frame.frame_number >= total_frames) {
-                errors.push(`indexed_frames contains frame_number >= total_frames (${total_frames})`);
-            }
-        }
-    }
-    if (is_indexed === true && !indexed_frames?.length) {
-        errors.push(`is_indexed is true but indexed_frames is missing or empty`);
-    }
-    if (indexed_frames) {
-        if (!Array.isArray(indexed_frames)) {
-            errors.push(`indexed_frames must be an array`);
-        }
-        else {
-            indexed_frames.forEach((frame_idx, idx) => {
-                if (typeof frame_idx.frame_number !== `number`) {
-                    errors.push(`indexed_frames[${idx}] missing or invalid frame_number`);
-                }
-                else if (frame_idx.frame_number < 0) {
-                    errors.push(`indexed_frames[${idx}] frame_number (${frame_idx.frame_number}) must be non-negative`);
-                }
-                else if (idx > 0 && frame_idx.frame_number <= indexed_frames[idx - 1].frame_number) {
-                    errors.push(`indexed_frames[${idx}] frame_number (${frame_idx.frame_number}) must be strictly increasing`);
-                }
-                if (typeof frame_idx.byte_offset !== `number`) {
-                    errors.push(`indexed_frames[${idx}] missing or invalid byte_offset`);
-                }
-                if (typeof frame_idx.estimated_size !== `number`) {
-                    errors.push(`indexed_frames[${idx}] missing or invalid estimated_size`);
-                }
-            });
-        }
-    }
-    if (plot_metadata) {
-        if (!Array.isArray(plot_metadata)) {
-            errors.push(`plot_metadata must be an array`);
-        }
-        else {
-            plot_metadata.forEach((meta, idx) => {
-                if (typeof meta.frame_number !== `number`) {
-                    errors.push(`plot_metadata[${idx}] missing or invalid frame_number`);
-                }
-                if (typeof meta.step !== `number`) {
-                    errors.push(`plot_metadata[${idx}] missing or invalid step`);
-                }
-                if (!meta.properties || typeof meta.properties !== `object`) {
-                    errors.push(`plot_metadata[${idx}] missing or invalid properties object`);
-                }
-            });
-        }
-    }
-    return errors;
-}
-export function get_trajectory_stats(trajectory) {
-    const { frames, total_frames, indexed_frames, plot_metadata } = trajectory;
-    const frame_count = total_frames || frames.length;
-    const stats = {
-        frame_count,
-        is_indexed: trajectory.is_indexed || false,
-    };
-    if (frames.length > 0) {
-        const [first_frame, last_frame] = [frames[0], frames.at(-1) ?? frames[0]];
-        const max_sample = 100;
-        const sampled = frames.length <= max_sample
-            ? frames
-            : (() => {
-                const interval = Math.floor(frames.length / max_sample);
-                const result = [first_frame];
-                for (let idx = interval; idx < frames.length - 1; idx += interval) {
-                    result.push(frames[idx]);
-                }
-                if (result.at(-1) !== last_frame)
-                    result.push(last_frame);
-                return result;
-            })();
-        const counts = sampled.map((frame) => frame.structure.sites.length);
-        const constant = counts.every((c) => c === counts[0]);
-        const all_counts = constant
-            ? [first_frame.structure.sites.length]
-            : frames.map((frame) => frame.structure.sites.length);
-        stats.steps = frames.map((frame) => frame.step);
-        stats.step_range = [first_frame.step, last_frame.step];
-        stats.constant_atom_count = constant;
-        if (constant)
-            stats.total_atoms = first_frame.structure.sites.length;
-        else
-            stats.atom_count_range = [Math.min(...all_counts), Math.max(...all_counts)];
-    }
-    else {
-        // Handle empty trajectory case
-        stats.steps = [];
-        stats.step_range = undefined;
-        stats.constant_atom_count = undefined;
-        stats.total_atoms = undefined;
-    }
-    // Additional metadata for large files
-    if (indexed_frames)
-        stats.indexed_frame_count = indexed_frames.length;
-    if (plot_metadata)
-        stats.plot_metadata_count = plot_metadata.length;
-    return stats;
-}

package/dist/trajectory/parse/ase.d.ts

@@ -1,2 +0,0 @@
-import type { TrajectoryType } from '../index';
-export declare function parse_ase_trajectory(buffer: ArrayBuffer, filename?: string): TrajectoryType;

package/dist/trajectory/parse/ase.js

@@ -1,77 +0,0 @@
-// ASE trajectory (.traj) parsing - binary format
-import { MAX_SAFE_STRING_LENGTH } from '../constants';
-import { convert_atomic_numbers, create_trajectory_frame, read_ndarray_from_view, validate_3x3_matrix, } from '../helpers';
-export function parse_ase_trajectory(buffer, filename) {
-    const view = new DataView(buffer);
-    let offset = 0;
-    const signature = new TextDecoder().decode(new Uint8Array(buffer, 0, 8));
-    if (signature !== `- of Ulm`)
-        throw new Error(`Invalid ASE trajectory`);
-    offset += 24;
-    const _version = Number(view.getBigInt64(offset, true));
-    offset += 8;
-    const n_items = Number(view.getBigInt64(offset, true));
-    offset += 8;
-    const offsets_pos = Number(view.getBigInt64(offset, true));
-    if (n_items <= 0)
-        throw new Error(`Invalid frame count`);
-    if (offsets_pos < 0 || offsets_pos + n_items * 8 > buffer.byteLength) {
-        throw new Error(`Invalid ASE frame offsets table bounds: offsets_pos=${offsets_pos}, n_items=${n_items}, byte_length=${buffer.byteLength}`);
-    }
-    const frame_offsets = Array.from({ length: n_items }, (_, idx) => Number(view.getBigInt64(offsets_pos + idx * 8, true)));
-    const frames = [];
-    let global_numbers;
-    for (let idx = 0; idx < n_items; idx++) {
-        try {
-            offset = frame_offsets[idx];
-            const json_length = Number(view.getBigInt64(offset, true));
-            offset += 8;
-            if (json_length > MAX_SAFE_STRING_LENGTH) {
-                console.warn(`Skipping frame ${idx + 1}/${n_items}: too large`);
-                continue;
-            }
-            const frame_data = JSON.parse(new TextDecoder().decode(new Uint8Array(buffer, offset, json_length)));
-            const positions_ref = frame_data[`positions.`] || frame_data.positions;
-            const positions = positions_ref?.ndarray
-                ? read_ndarray_from_view(view, positions_ref)
-                : positions_ref;
-            const numbers_ref = frame_data[`numbers.`] || frame_data.numbers || global_numbers;
-            const numbers = numbers_ref?.ndarray
-                ? read_ndarray_from_view(view, numbers_ref).flat()
-                : numbers_ref;
-            if (numbers)
-                global_numbers = numbers;
-            if (!numbers || !positions) {
-                console.warn(`Skipping ASE frame ${idx + 1}/${n_items}: missing ${!numbers ? `numbers` : `positions`}`);
-                continue;
-            }
-            const elements = convert_atomic_numbers(numbers);
-            const metadata = {
-                step: idx,
-                ...(frame_data.calculator || {}),
-                ...(frame_data.info || {}),
-            };
-            frames.push(create_trajectory_frame(positions, elements, frame_data.cell ? validate_3x3_matrix(frame_data.cell) : undefined, frame_data.pbc || [true, true, true], idx, metadata));
-        }
-        catch (error) {
-            console.warn(`Error processing frame ${idx + 1}/${n_items}:`, error);
-        }
-    }
-    if (frames.length === 0)
-        throw new Error(`No valid frames found`);
-    const first_struct = frames[0]?.structure;
-    const periodic_boundary_conditions = first_struct !== null &&
-        first_struct !== undefined &&
-        typeof first_struct === `object` &&
-        `lattice` in first_struct
-        ? first_struct.lattice.pbc
-        : [true, true, true];
-    const metadata = {
-        filename,
-        source_format: `ase_trajectory`,
-        frame_count: frames.length,
-        total_atoms: global_numbers?.length || 0,
-        periodic_boundary_conditions,
-    };
-    return { frames, metadata };
-}

package/dist/trajectory/parse/hdf5.d.ts

@@ -1,2 +0,0 @@
-import type { TrajectoryType } from '../index';
-export declare function parse_torch_sim_hdf5(buffer: ArrayBuffer, filename?: string): Promise<TrajectoryType>;

package/dist/trajectory/parse/hdf5.js

@@ -1,129 +0,0 @@
-// HDF5 trajectory parsing (torch-sim / generic format)
-import { calc_lattice_params, transpose_3x3_matrix } from '../../math';
-import * as h5wasm from 'h5wasm';
-import { convert_atomic_numbers, create_trajectory_frame, validate_3x3_matrix, } from '../helpers';
-const is_hdf5_dataset = (entity) => entity !== null && `to_array` in entity && entity instanceof h5wasm.Dataset;
-const is_hdf5_group = (entity) => entity !== null && `keys` in entity && entity instanceof h5wasm.Group;
-export async function parse_torch_sim_hdf5(buffer, filename) {
-    const { FS } = await h5wasm.ready;
-    const file_basename = filename
-        ?.split(`/`)
-        .at(-1)
-        ?.replace(/[^\w.-]/g, `_`) || `temp`;
-    const unique_suffix = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    const temp_filename = `${file_basename}-${unique_suffix}.h5`;
-    FS.writeFile(temp_filename, new Uint8Array(buffer));
-    let h5_file = null;
-    try {
-        h5_file = new h5wasm.File(temp_filename, `r`);
-        const found_paths = {};
-        let total_groups_found = 0;
-        const find_dataset = (names) => {
-            const discover = (parent, path = ``) => {
-                total_groups_found++;
-                for (const name of parent.keys()) {
-                    const item = parent.get(name);
-                    const full_path = path ? `${path}/${name}` : `/${name}`;
-                    if (names.includes(name) && is_hdf5_dataset(item)) {
-                        const found_name = names.find((n) => n === name);
-                        if (found_name)
-                            found_paths[found_name] = full_path;
-                        return item;
-                    }
-                    if (is_hdf5_group(item)) {
-                        const result = discover(item, full_path);
-                        if (result)
-                            return result;
-                    }
-                }
-                return null;
-            };
-            return discover(h5_file);
-        };
-        const positions_data = find_dataset([`positions`, `coords`, `coordinates`])?.to_array();
-        const atomic_numbers_data = find_dataset([
-            `atomic_numbers`,
-            `numbers`,
-            `Z`,
-            `species`,
-        ])?.to_array();
-        const cells_data = find_dataset([`cell`, `cells`, `lattice`])?.to_array();
-        const energies_data = find_dataset([`potential_energy`, `energy`])?.to_array();
-        if (!positions_data || !atomic_numbers_data) {
-            const missing_datasets = [];
-            if (!positions_data) {
-                missing_datasets.push(`positions (tried: positions, coords, coordinates)`);
-            }
-            if (!atomic_numbers_data) {
-                missing_datasets.push(`atomic numbers (tried: atomic_numbers, numbers, Z, species)`);
-            }
-            const missing_str = missing_datasets.join(`, `);
-            const available_str = Array.from(h5_file.keys()).join(`, `);
-            throw new Error(`Missing required dataset(s) in HDF5 file: ${missing_str}. Available datasets: ${available_str}`);
-        }
-        const positions_are_frames = positions_data.length > 0 &&
-            positions_data.every((entry) => Array.isArray(entry) && entry.every((coord) => Array.isArray(coord)));
-        const positions = positions_are_frames
-            ? positions_data
-            : [positions_data];
-        const atomic_numbers_are_frames = atomic_numbers_data.length > 0 &&
-            atomic_numbers_data.every((entry) => Array.isArray(entry));
-        const atomic_numbers = atomic_numbers_are_frames
-            ? atomic_numbers_data
-            : [atomic_numbers_data];
-        const frames = positions.map((frame_pos, idx) => {
-            const frame_atomic_numbers = atomic_numbers[idx] || atomic_numbers[0];
-            const frame_elements = convert_atomic_numbers(frame_atomic_numbers);
-            const cell = cells_data?.[idx];
-            const lattice_mat = cell ? transpose_3x3_matrix(validate_3x3_matrix(cell)) : undefined;
-            const energy_entry = energies_data?.[idx];
-            const energy = Array.isArray(energy_entry) ? energy_entry[0] : energy_entry;
-            const metadata = {};
-            if (energy !== undefined)
-                metadata.energy = energy;
-            if (lattice_mat) {
-                metadata.volume = calc_lattice_params(lattice_mat).volume;
-            }
-            const pbc = lattice_mat ? [true, true, true] : [false, false, false];
-            return create_trajectory_frame(frame_pos, frame_elements, lattice_mat, pbc, idx, metadata);
-        });
-        const first_frame_elements = frames[0]?.structure.sites.map((site) => site.species[0].element) ?? [];
-        return {
-            frames,
-            metadata: {
-                source_format: `hdf5_trajectory`,
-                frame_count: frames.length,
-                num_atoms: first_frame_elements.length,
-                periodic_boundary_conditions: cells_data ? [true, true, true] : [false, false, false],
-                element_counts: first_frame_elements.reduce((counts, element) => {
-                    counts[element] = (counts[element] || 0) + 1;
-                    return counts;
-                }, {}),
-                discovered_datasets: {
-                    positions: found_paths.positions ||
-                        found_paths.coords ||
-                        found_paths.coordinates ||
-                        `unknown`,
-                    atomic_numbers: found_paths.atomic_numbers ||
-                        found_paths.numbers ||
-                        found_paths.Z ||
-                        found_paths.species ||
-                        `unknown`,
-                    cells: found_paths.cell || found_paths.cells || found_paths.lattice,
-                    energies: found_paths.potential_energy || found_paths.energy,
-                },
-                total_groups_found,
-                has_cell_info: Boolean(cells_data),
-            },
-        };
-    }
-    finally {
-        h5_file?.close();
-        try {
-            FS.unlink(temp_filename);
-        }
-        catch {
-            /* temp file cleanup is best-effort */
-        }
-    }
-}

package/dist/trajectory/parse/index.d.ts

@@ -1,12 +0,0 @@
-import { is_trajectory_file } from '../format-detect';
-import { TrajFrameReader } from '../frame-reader';
-import type { FrameLoader, ParseProgress, TrajectoryType } from '../index';
-import type { AtomTypeMapping, LoadingOptions } from '../types';
-export { INDEX_SAMPLE_RATE, LARGE_FILE_THRESHOLD, MAX_BIN_FILE_SIZE, MAX_METADATA_SIZE, MAX_SAFE_STRING_LENGTH, MAX_TEXT_FILE_SIZE, } from '../constants';
-export type { AtomTypeMapping, LoadingOptions } from '../types';
-export { is_trajectory_file, TrajFrameReader };
-export declare function parse_trajectory_data(data: unknown, filename?: string, atom_type_mapping?: AtomTypeMapping): Promise<TrajectoryType>;
-export declare function get_unsupported_format_message(filename: string, content: string): string | null;
-export declare function parse_trajectory_async(data: ArrayBuffer | string, filename: string, on_progress?: (progress: ParseProgress) => void, options?: LoadingOptions): Promise<TrajectoryType>;
-export declare function create_frame_loader(filename: string): FrameLoader;
-export declare function load_binary_traj(resp: Response, type: string, fallback?: boolean): Promise<ArrayBuffer | string>;

package/dist/trajectory/parse/index.js

@@ -1,299 +0,0 @@
-import { is_binary } from '../../io/is-binary';
-import * as math from '../../math';
-import { parse_xyz } from '../../structure/parse';
-import { INDEX_SAMPLE_RATE, LARGE_FILE_THRESHOLD } from '../constants';
-import { FORMAT_PATTERNS, is_trajectory_file, strip_compression_extensions, } from '../format-detect';
-import { TrajFrameReader } from '../frame-reader';
-import { create_trajectory_frame, validate_3x3_matrix } from '../helpers';
-import { parse_ase_trajectory } from './ase';
-import { parse_torch_sim_hdf5 } from './hdf5';
-import { parse_lammps_trajectory } from './lammps';
-import { parse_vasp_xdatcar } from './vasp';
-import { parse_xyz_trajectory } from './xyz';
-// Silently swallow expected parse fallbacks — the caller throws if ALL formats fail
-const log_parse_debug = (_message, _error) => { };
-// Re-export constants and types for consumers
-export { INDEX_SAMPLE_RATE, LARGE_FILE_THRESHOLD, MAX_BIN_FILE_SIZE, MAX_METADATA_SIZE, MAX_SAFE_STRING_LENGTH, MAX_TEXT_FILE_SIZE, } from '../constants';
-export { is_trajectory_file, TrajFrameReader };
-export async function parse_trajectory_data(data, filename, atom_type_mapping) {
-    if (data instanceof ArrayBuffer) {
-        if (FORMAT_PATTERNS.ase(data, filename))
-            return parse_ase_trajectory(data, filename);
-        if (FORMAT_PATTERNS.hdf5(data, filename)) {
-            return await parse_torch_sim_hdf5(data, filename);
-        }
-        throw new Error(`Unsupported binary format${filename ? `: ${filename}` : ``}`);
-    }
-    if (typeof data === `string`) {
-        const content = data.trim();
-        if (FORMAT_PATTERNS.xyz_multi(content, filename))
-            return parse_xyz_trajectory(content);
-        if (FORMAT_PATTERNS.vasp(content, filename)) {
-            return parse_vasp_xdatcar(content, filename);
-        }
-        if (FORMAT_PATTERNS.lammpstrj(content, filename)) {
-            return parse_lammps_trajectory(content, filename, atom_type_mapping);
-        }
-        // Single XYZ fallback
-        if (filename?.toLowerCase().match(/\.(?:xyz|extxyz)$/)) {
-            try {
-                const structure = parse_xyz(content);
-                if (structure) {
-                    return {
-                        frames: [{ structure, step: 0, metadata: {} }],
-                        metadata: { source_format: `single_xyz`, frame_count: 1 },
-                    };
-                }
-            }
-            catch (error) {
-                // Single-frame XYZ parsing failed, continue to JSON parsing.
-                log_parse_debug(`Single XYZ parse fallback failed for ${filename ?? `unknown file`}:`, error);
-            }
-        }
-        try {
-            data = JSON.parse(content);
-        }
-        catch (error) {
-            log_parse_debug(`JSON parse failed for ${filename ?? `unknown file`}:`, error);
-            throw new Error(`Unsupported text format`, { cause: error });
-        }
-    }
-    if (!data || typeof data !== `object`)
-        throw new Error(`Invalid data format`);
-    // Handle JSON formats
-    if (Array.isArray(data)) {
-        const frames = data.map((frame_data, idx) => {
-            const frame_obj = frame_data;
-            const frame_step = frame_obj.step;
-            return {
-                structure: (frame_obj.structure || frame_obj),
-                step: typeof frame_step === `number` ? frame_step : idx,
-                metadata: frame_obj.metadata || {},
-            };
-        });
-        return { frames, metadata: { source_format: `array`, frame_count: frames.length } };
-    }
-    const obj = data;
-    // Pymatgen format
-    if (obj[`@class`] === `Trajectory` && obj.species && obj.coords && obj.lattice) {
-        const species = obj.species;
-        const frame_elements = species.map((specie) => specie.element);
-        const coords = obj.coords;
-        const matrix = validate_3x3_matrix(obj.lattice);
-        const frame_properties = obj.frame_properties || [];
-        const frac_to_cart = math.create_frac_to_cart(matrix);
-        const frames = coords.map((frame_coords, idx) => {
-            const positions = frame_coords.map((abc) => frac_to_cart(abc));
-            // Process frame properties to extract numpy arrays
-            const raw_properties = frame_properties[idx] || {};
-            const processed_properties = {};
-            Object.entries(raw_properties).forEach(([key, value]) => {
-                if (value &&
-                    typeof value === `object` &&
-                    value[`@class`] === `array`) {
-                    // Extract numpy array data
-                    const array_obj = value;
-                    processed_properties[key] = array_obj.data;
-                    // Calculate force statistics for forces
-                    if (key === `forces` && Array.isArray(array_obj.data)) {
-                        const forces = array_obj.data;
-                        const force_magnitudes = forces.map((force) => Math.hypot(...force));
-                        if (force_magnitudes.length > 0) {
-                            processed_properties.force_max = force_magnitudes.reduce((max_val, magnitude) => (magnitude > max_val ? magnitude : max_val), force_magnitudes[0]);
-                            processed_properties.force_norm = Math.sqrt(force_magnitudes.reduce((sum, f) => sum + f ** 2, 0) / force_magnitudes.length);
-                        }
-                    }
-                    // Calculate stress statistics for stress tensor
-                    if (key === `stress` && Array.isArray(array_obj.data)) {
-                        const stress_tensor = array_obj.data;
-                        if (!math.is_square_matrix(stress_tensor, 3)) {
-                            console.warn(`Invalid stress tensor structure in frame ${idx}`);
-                        }
-                        else {
-                            // Calculate stress components (diagonal elements represent normal stresses)
-                            const normal_stresses = [
-                                stress_tensor[0][0],
-                                stress_tensor[1][1],
-                                stress_tensor[2][2],
-                            ];
-                            processed_properties.stress_max = Math.max(...normal_stresses.map(Math.abs));
-                            // Calculate hydrostatic pressure (negative of mean normal stress)
-                            processed_properties.pressure =
-                                -(normal_stresses[0] + normal_stresses[1] + normal_stresses[2]) / 3;
-                        }
-                    }
-                }
-                else {
-                    processed_properties[key] = value;
-                }
-            });
-            return create_trajectory_frame(positions, frame_elements, matrix, [true, true, true], idx, processed_properties);
-        });
-        return {
-            frames,
-            metadata: {
-                filename,
-                source_format: `pymatgen_trajectory`,
-                frame_count: frames.length,
-                species_list: [...new Set(species.map((specie) => specie.element))],
-                periodic_boundary_conditions: [true, true, true],
-            },
-        };
-    }
-    // Object with frames
-    if (Array.isArray(obj.frames)) {
-        const metadata = (obj.metadata ?? {});
-        return {
-            frames: obj.frames,
-            metadata: { ...metadata, source_format: `object_with_frames` },
-        };
-    }
-    // Single structure
-    if (obj.sites) {
-        return {
-            frames: [{ structure: obj, step: 0, metadata: {} }],
-            metadata: { source_format: `single_structure`, frame_count: 1 },
-        };
-    }
-    throw new Error(`Unrecognized trajectory format`);
-}
-export function get_unsupported_format_message(filename, content) {
-    const lower = filename.toLowerCase();
-    // Check for unsupported compression formats first
-    const unsupported_compression = [
-        { ext: `.bz2`, name: `BZ2` },
-        { ext: `.xz`, name: `XZ` },
-        { ext: `.zip`, name: `ZIP` },
-    ];
-    for (const { ext, name } of unsupported_compression) {
-        if (lower.endsWith(ext)) {
-            return `🚫 ${name} compression not supported in browser\nPlease decompress the file first`;
-        }
-    }
-    // .dump files are LAMMPS binary dumps which require external tools to parse.
-    // .lammpstrj files are LAMMPS text-based trajectory files supported by parse_lammps_trajectory().
-    const formats = [
-        { extensions: [`.dump`], name: `LAMMPS binary dump`, tool: `pymatgen` },
-        { extensions: [`.nc`, `.netcdf`], name: `NetCDF`, tool: `MDAnalysis` },
-        { extensions: [`.dcd`], name: `DCD`, tool: `MDAnalysis` },
-    ];
-    for (const { extensions, name, tool } of formats) {
-        if (extensions.some((ext) => lower.endsWith(ext))) {
-            return `🚫 ${name} format not supported\nConvert with ${tool} first`;
-        }
-    }
-    return is_binary(content)
-        ? `🚫 Binary format not supported${filename ? `: ${filename}` : ``}`
-        : null;
-}
-// Unified async parser with streaming support
-export async function parse_trajectory_async(data, filename, on_progress, options = {}) {
-    const { use_indexing, index_sample_rate = INDEX_SAMPLE_RATE, extract_plot_metadata = true, atom_type_mapping, } = options;
-    const update_progress = (current, stage) => on_progress?.({ current, total: 100, stage });
-    try {
-        update_progress(0, `Detecting format...`);
-        const data_size = data instanceof ArrayBuffer ? data.byteLength : new TextEncoder().encode(data).byteLength;
-        const is_large_file = data_size > LARGE_FILE_THRESHOLD;
-        const should_use_indexing = use_indexing ?? is_large_file;
-        if (is_large_file) {
-            update_progress(5, `Large file detected (${Math.round(data_size / 1024 / 1024)}MB)`);
-        }
-        // Use indexed loading for supported large files (including compressed names).
-        const base_filename = strip_compression_extensions(filename);
-        if (should_use_indexing && /\.(xyz|extxyz|traj)$/.test(base_filename)) {
-            return await parse_with_unified_loader(data, filename, {
-                index_sample_rate,
-                extract_plot_metadata,
-            }, on_progress);
-        }
-        // Fallback to direct parsing
-        update_progress(10, `Parsing trajectory...`);
-        const result = await parse_trajectory_data(data, filename, atom_type_mapping);
-        update_progress(100, `Complete`);
-        return result;
-    }
-    catch (error) {
-        const error_message = error instanceof Error ? error.message : `Unknown error`;
-        update_progress(100, `Error: ${error_message}`);
-        throw error;
-    }
-}
-// Unified frame loading using new TrajFrameReader
-async function parse_with_unified_loader(data, filename, options, on_progress) {
-    const { index_sample_rate, extract_plot_metadata } = options;
-    const loader = new TrajFrameReader(filename);
-    on_progress?.({ current: 10, total: 100, stage: `Counting frames...` });
-    const total_frames = await loader.get_total_frames(data);
-    on_progress?.({ current: 20, total: 100, stage: `Building frame index...` });
-    const frame_index = await loader.build_frame_index(data, index_sample_rate, (progress) => {
-        const adjusted = 20 + (progress.current / 100) * 30;
-        on_progress?.({
-            current: adjusted,
-            total: 100,
-            stage: `Building index: ${progress.stage}`,
-        });
-    });
-    on_progress?.({ current: 50, total: 100, stage: `Loading initial frames...` });
-    const initial_frame_count = Math.min(10, total_frames);
-    const frame_promises = Array.from({ length: initial_frame_count }, (_, idx) => loader.load_frame(data, idx));
-    const loaded_frames = await Promise.all(frame_promises);
-    const frames = loaded_frames.filter((frame) => frame !== null);
-    let plot_metadata;
-    if (extract_plot_metadata) {
-        on_progress?.({ current: 70, total: 100, stage: `Extracting plot metadata...` });
-        try {
-            plot_metadata = await loader.extract_plot_metadata(data, { sample_rate: 1 }, (progress) => {
-                const adjusted = 70 + (progress.current / 100) * 20;
-                on_progress?.({
-                    current: adjusted,
-                    total: 100,
-                    stage: `Extracting: ${progress.stage}`,
-                });
-            });
-        }
-        catch (error) {
-            console.warn(`Failed to extract plot metadata:`, error);
-        }
-    }
-    const stage = `Ready: ${total_frames} frames indexed`;
-    on_progress?.({ current: 100, total: 100, stage });
-    const source_format = filename.toLowerCase().endsWith(`.traj`)
-        ? `ase_trajectory`
-        : `xyz_trajectory`;
-    return {
-        frames,
-        metadata: { source_format, frame_count: total_frames },
-        total_frames,
-        indexed_frames: frame_index,
-        plot_metadata,
-        is_indexed: true,
-        frame_loader: loader,
-    };
-}
-// Factory function for frame loader (simplified)
-export function create_frame_loader(filename) {
-    if (!/\.(xyz|extxyz|traj)$/.exec(filename.toLowerCase())) {
-        throw new Error(`Unsupported format for frame loading: ${filename}`);
-    }
-    return new TrajFrameReader(filename);
-}
-export async function load_binary_traj(resp, type, fallback = false) {
-    try {
-        // Read binary from a clone so the original can be used for text fallback
-        return await resp.clone().arrayBuffer();
-    }
-    catch (binary_error) {
-        if (fallback) {
-            console.warn(`Binary load failed for ${type}, using text fallback:`, binary_error);
-            try {
-                return await resp.text();
-            }
-            catch (text_error) {
-                const combined_error = new AggregateError([binary_error, text_error], `Failed to load ${type} as binary or text`);
-                console.error(`Binary and text fallback both failed for ${type}:`, combined_error);
-                throw combined_error;
-            }
-        }
-        throw new Error(`Failed to load ${type} as binary`, { cause: binary_error });
-    }
-}

package/dist/trajectory/parse/lammps.d.ts

@@ -1,5 +0,0 @@
-import * as math from '../../math';
-import type { TrajectoryType } from '../index';
-import type { AtomTypeMapping } from '../types';
-export declare function parse_lammps_box(box_lines: string[], is_triclinic: boolean): math.Matrix3x3 | null;
-export declare function parse_lammps_trajectory(content: string, filename?: string, atom_type_mapping?: AtomTypeMapping): TrajectoryType;