matterviz 0.3.7 → 0.4.0

package/dist/trajectory/format-detect.d.ts

@@ -1,4 +1,5 @@
 export declare function strip_compression_extensions(filename: string): string;
+export declare function ext_hint(filename: string | undefined, ext_regex: RegExp): boolean | null;
 export declare const FORMAT_PATTERNS: {
     readonly ase: (data: unknown, filename?: string) => boolean;
     readonly hdf5: (data: unknown, filename?: string) => boolean;

package/dist/trajectory/format-detect.js

@@ -8,26 +8,42 @@ export function strip_compression_extensions(filename) {
     }
     return base_name;
 }
-// Unified format detection
+// Extensions that explicitly identify a format — when present, format detection trusts
+// the extension instead of sniffing content
+const KNOWN_FORMAT_EXT_REGEX = /\.(xyz|extxyz|traj|h5|hdf5|lammpstrj|json|cif|poscar|vasp|yaml|yml|xml|csv)$/;
+// Classify the filename hint for a format whose extensions match ext_regex:
+// true = filename matches, false = filename names a different known format,
+// null = no usable hint (missing filename or unrecognized extension, e.g. the UUID
+// basenames of blob: object URLs) — callers should fall back to content detection
+export function ext_hint(filename, ext_regex) {
+    if (!filename)
+        return null;
+    const base = strip_compression_extensions(filename);
+    if (ext_regex.test(base))
+        return true;
+    return KNOWN_FORMAT_EXT_REGEX.test(base) ? false : null;
+}
+// Unified format detection. Each pattern trusts a matching file extension when present
+// but falls back to content/magic-byte detection when the filename gives no hint
+// (e.g. blob: object URLs, extensionless API endpoints).
 export const FORMAT_PATTERNS = {
     ase: (data, filename) => {
-        const base_name = filename ? strip_compression_extensions(filename) : undefined;
-        if (!base_name?.endsWith(`.traj`) || !(data instanceof ArrayBuffer)) {
+        if (ext_hint(filename, /\.traj$/) === false || !(data instanceof ArrayBuffer)) {
             return false;
         }
         const view = new Uint8Array(data.slice(0, 24));
         return [0x2d, 0x20, 0x6f, 0x66, 0x20, 0x55, 0x6c, 0x6d].every((byte, idx) => view[idx] === byte);
     },
     hdf5: (data, filename) => {
-        const base_name = filename ? strip_compression_extensions(filename) : undefined;
-        const has_ext = base_name?.match(/\.(h5|hdf5)$/);
-        if (!has_ext || !(data instanceof ArrayBuffer) || data.byteLength < 8)
+        if (ext_hint(filename, /\.(h5|hdf5)$/) === false)
+            return false;
+        if (!(data instanceof ArrayBuffer) || data.byteLength < 8)
             return false;
         const signature = new Uint8Array(data.slice(0, 8));
         return [0x89, 0x48, 0x44, 0x46, 0x0d, 0x0a, 0x1a, 0x0a].every((b, idx) => signature[idx] === b);
     },
     vasp: (data, filename) => {
-        const basename = filename?.toLowerCase().split(`/`).pop() || ``;
+        const basename = filename?.toLowerCase().split(`/`).pop() ?? ``;
         if (basename === `xdatcar` || basename.startsWith(`xdatcar`))
             return true;
         const lines = data.trim().split(/\r?\n/);
@@ -37,14 +53,12 @@ export const FORMAT_PATTERNS = {
             lines.slice(2, 5).every((line) => line.trim().split(/\s+/).length === 3));
     },
     xyz_multi: (data, filename) => {
-        const base = filename ? strip_compression_extensions(filename) : ``;
-        if (!/\.(xyz|extxyz)$/.test(base))
+        if (ext_hint(filename, /\.(xyz|extxyz)$/) === false)
             return false;
         return count_xyz_frames(data) >= 2;
     },
     lammpstrj: (data, filename) => {
-        const base = filename ? strip_compression_extensions(filename) : ``;
-        if (!base.endsWith(`.lammpstrj`))
+        if (ext_hint(filename, /\.lammpstrj$/) === false)
             return false;
         return data.includes(`ITEM: TIMESTEP`) && data.includes(`ITEM: ATOMS`);
     },

package/dist/trajectory/frame-reader.js

@@ -1,7 +1,9 @@
+// Unified frame loader for XYZ and ASE trajectories (large file indexing)
 import * as math from '../math';
 import { MAX_METADATA_SIZE } from './constants';
-import { coerce_element_symbol, convert_atomic_numbers, count_xyz_frames, create_trajectory_frame, read_ndarray_from_view, validate_3x3_matrix, } from './helpers';
+import { convert_atomic_numbers, count_xyz_frames, create_trajectory_frame, read_ndarray_from_view, validate_3x3_matrix, } from './helpers';
 import { strip_compression_extensions } from './format-detect';
+import { parse_extxyz_lattice, parse_xyz_atom_lines, parse_xyz_comment_metadata, } from './parse/xyz';
 export class TrajFrameReader {
     format;
     global_numbers;
@@ -185,16 +187,12 @@ export class TrajFrameReader {
         const lines = data.trim().split(/\r?\n/);
         let [current_frame, line_idx] = [0, 0];
         while (line_idx < lines.length && current_frame < frame_number) {
-            if (!lines[line_idx]?.trim()) {
-                line_idx++;
+            const skip_atoms = parseInt(lines[line_idx].trim(), 10);
+            if (isNaN(skip_atoms) || skip_atoms <= 0) {
+                line_idx++; // skip blank/invalid lines until the next frame's atom-count line
                 continue;
             }
-            const num_atoms = parseInt(lines[line_idx].trim(), 10);
-            if (isNaN(num_atoms) || num_atoms <= 0) {
-                line_idx++;
-                continue;
-            }
-            line_idx += 2 + num_atoms;
+            line_idx += 2 + skip_atoms;
             current_frame++;
         }
         if (line_idx >= lines.length)
@@ -203,32 +201,14 @@ export class TrajFrameReader {
         if (isNaN(num_atoms) || line_idx + num_atoms + 1 >= lines.length)
             return null;
         const comment = lines[line_idx + 1] || ``;
-        const positions = [];
-        const elements = [];
-        for (let idx = 0; idx < num_atoms; idx++) {
-            const parts = lines[line_idx + 2 + idx]?.trim().split(/\s+/);
-            if (parts?.length >= 4) {
-                const x_coord = parseFloat(parts[1]);
-                const y_coord = parseFloat(parts[2]);
-                const z_coord = parseFloat(parts[3]);
-                if (!Number.isFinite(x_coord) ||
-                    !Number.isFinite(y_coord) ||
-                    !Number.isFinite(z_coord)) {
-                    console.warn(`Skipping XYZ atom with invalid coordinates in indexed frame ${frame_number} at line ${line_idx + 2 + idx}`);
-                    continue;
-                }
-                const raw_symbol = parts[0];
-                const element_symbol = coerce_element_symbol(raw_symbol);
-                if (!element_symbol) {
-                    console.warn(`Skipping XYZ atom with unknown element symbol "${raw_symbol}" in indexed frame ${frame_number}`);
-                    continue;
-                }
-                elements.push(element_symbol);
-                positions.push([x_coord, y_coord, z_coord]);
-            }
-        }
-        const metadata = this.parse_xyz_metadata(comment, frame_number);
-        return create_trajectory_frame(positions, elements, undefined, undefined, metadata.step, metadata.properties);
+        const lattice_matrix = parse_extxyz_lattice(comment);
+        const { elements, positions, force_stats } = parse_xyz_atom_lines(lines, line_idx + 2, num_atoms, comment, `indexed frame ${frame_number}`);
+        const { step, properties } = this.parse_xyz_metadata(comment, frame_number);
+        const metadata = { ...properties, ...force_stats };
+        // Derive volume from the lattice (parity with the eager parse_xyz_trajectory parser)
+        if (lattice_matrix)
+            metadata.volume = math.calc_lattice_params(lattice_matrix).volume;
+        return create_trajectory_frame(positions, elements, lattice_matrix, lattice_matrix ? [true, true, true] : undefined, step, metadata);
     }
     load_ase_frame(data, frame_number) {
         try {
@@ -274,21 +254,8 @@ export class TrajFrameReader {
         }
     }
     parse_xyz_metadata(comment, frame_number) {
-        const properties = {};
-        const patterns = {
-            energy: /(?:energy|E|etot)\s*[=:]?\s*([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/i,
-            volume: /(?:volume|vol|V)\s*[=:]?\s*([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/i,
-            pressure: /(?:pressure|press|P)\s*[=:]?\s*([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/i,
-            force_max: /(?:max_force|fmax)\s*[=:]?\s*([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/i,
-        };
-        Object.entries(patterns).forEach(([key, pattern]) => {
-            const match = pattern.exec(comment);
-            if (match)
-                properties[key] = parseFloat(match[1]);
-        });
-        const step_match = /(?:step|frame)\s*[=:]?\s*(\d+)/i.exec(comment);
-        const step = step_match ? parseInt(step_match[1]) : frame_number;
-        return { frame_number, step, properties };
+        const { step, properties } = parse_xyz_comment_metadata(comment);
+        return { frame_number, step: step ?? frame_number, properties };
     }
     parse_ase_metadata(frame_data, frame_number) {
         const properties = {};

package/dist/trajectory/helpers.js

@@ -147,7 +147,7 @@ export function count_xyz_frames(data) {
         let valid_coords = 0;
         for (let idx = 0; idx < Math.min(num_atoms, 3); idx++) {
             const parts = lines[line_idx + 2 + idx]?.trim().split(/\s+/);
-            if (parts?.length >= 4 && isNaN(parseInt(parts[0])) && parts[0].length <= 3) {
+            if (parts?.length >= 4 && isNaN(parseInt(parts[0], 10)) && parts[0].length <= 3) {
                 if (parts.slice(1, 4).every((coord) => !isNaN(parseFloat(coord))))
                     valid_coords++;
             }

package/dist/trajectory/index.js

@@ -77,7 +77,7 @@ export function validate_trajectory(trajectory) {
 }
 export function get_trajectory_stats(trajectory) {
     const { frames, total_frames, indexed_frames, plot_metadata } = trajectory;
-    const frame_count = total_frames || frames.length;
+    const frame_count = total_frames ?? frames.length;
     const stats = {
         frame_count,
         is_indexed: trajectory.is_indexed ?? false,

package/dist/trajectory/parse/hdf5.js

@@ -9,7 +9,7 @@ export async function parse_torch_sim_hdf5(buffer, filename) {
     const file_basename = filename
         ?.split(`/`)
         .at(-1)
-        ?.replace(/[^\w.-]/g, `_`) || `temp`;
+        ?.replaceAll(/[^\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));

package/dist/trajectory/parse/index.js

@@ -2,9 +2,9 @@ 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 { ext_hint, 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 { count_xyz_frames, 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';
@@ -33,8 +33,10 @@ export async function parse_trajectory_data(data, filename, atom_type_mapping) {
         if (FORMAT_PATTERNS.lammpstrj(content, filename)) {
             return parse_lammps_trajectory(content, filename, atom_type_mapping);
         }
-        // Single XYZ fallback
-        if (filename?.toLowerCase().match(/\.(?:xyz|extxyz)$/)) {
+        // Single XYZ fallback (content-sniffed when the filename gives no format hint,
+        // e.g. blob: object URLs whose basenames are UUIDs)
+        const xyz_hint = ext_hint(filename, /\.(xyz|extxyz)$/);
+        if (xyz_hint || (xyz_hint === null && count_xyz_frames(content) === 1)) {
             try {
                 const structure = parse_xyz(content);
                 if (structure) {
@@ -65,7 +67,7 @@ export async function parse_trajectory_data(data, filename, atom_type_mapping) {
             const frame_obj = frame_data;
             const frame_step = frame_obj.step;
             return {
-                structure: (frame_obj.structure || frame_obj),
+                structure: (frame_obj.structure ?? frame_obj),
                 step: typeof frame_step === `number` ? frame_step : idx,
                 metadata: frame_obj.metadata || {},
             };
@@ -198,8 +200,14 @@ export async function parse_trajectory_async(data, filename, on_progress, option
             update_progress(5, `Large file detected (${Math.round(data_size / 1024 / 1024)}MB)`);
         }
         // Use indexed loading for supported large files (including compressed names).
+        // When the filename gives no format hint (e.g. blob: URLs), sniff a content
+        // prefix for XYZ frames so large extensionless files still get indexed.
         const base_filename = strip_compression_extensions(filename);
-        if (should_use_indexing && /\.(xyz|extxyz|traj)$/.test(base_filename)) {
+        const can_index = /\.(xyz|extxyz|traj)$/.test(base_filename) ||
+            (typeof data === `string` &&
+                ext_hint(filename, /\.(xyz|extxyz)$/) === null &&
+                count_xyz_frames(data.slice(0, 2 ** 20)) >= 1);
+        if (should_use_indexing && can_index) {
             return await parse_with_unified_loader(data, filename, {
                 index_sample_rate,
                 extract_plot_metadata,

package/dist/trajectory/parse/vasp.js

@@ -1,42 +1,61 @@
 import * as math from '../../math';
 import { create_trajectory_frame, is_valid_element_symbol, validate_3x3_matrix, } from '../helpers';
+// Parse the 7-line XDATCAR header at lines[start]: title, scale factor, 3 lattice rows
+// (multiplied by scale), element names, element counts
+function parse_xdatcar_header(lines, start) {
+    const scale = parseFloat(lines[start + 1]);
+    const rows = lines.slice(start + 2, start + 5).map((line) => line
+        .trim()
+        .split(/\s+/)
+        .map((val) => parseFloat(val) * scale));
+    const names = lines[start + 5].trim().split(/\s+/);
+    const counts = lines[start + 6].trim().split(/\s+/).map(Number);
+    return { scale, rows, names, counts };
+}
 export function parse_vasp_xdatcar(content, filename) {
     const lines = content.trim().split(/\r?\n/);
     if (lines.length < 10)
         throw new Error(`XDATCAR file too short`);
-    const scale = parseFloat(lines[1]);
-    if (isNaN(scale))
+    const header = parse_xdatcar_header(lines, 0);
+    const { names: element_names, counts: element_counts } = header;
+    if (isNaN(header.scale))
         throw new Error(`Invalid scale factor`);
-    const lattice_matrix = validate_3x3_matrix(lines.slice(2, 5).map((line) => line
-        .trim()
-        .split(/\s+/)
-        .map((component) => parseFloat(component) * scale)));
-    const element_names = lines[5].trim().split(/\s+/);
-    const element_counts = lines[6].trim().split(/\s+/).map(Number);
+    let lattice_matrix = validate_3x3_matrix(header.rows);
     if (element_names.length !== element_counts.length) {
         throw new Error(`XDATCAR element names/counts mismatch: names=${element_names.length}, counts=${element_counts.length}`);
     }
     if (element_counts.some((count) => !Number.isFinite(count) || !Number.isInteger(count) || count <= 0)) {
         throw new Error(`XDATCAR contains invalid element counts: expected finite positive integers`);
     }
-    const validated_element_names = element_names.map((name) => {
-        if (!is_valid_element_symbol(name)) {
-            throw new Error(`Invalid element symbol in XDATCAR: ${name}`);
-        }
-        return name;
-    });
-    const elements = validated_element_names.flatMap((name, idx) => Array(element_counts[idx]).fill(name));
+    const bad_element = element_names.find((name) => !is_valid_element_symbol(name));
+    if (bad_element)
+        throw new Error(`Invalid element symbol in XDATCAR: ${bad_element}`);
+    let elements = element_names.flatMap((name, idx) => Array(element_counts[idx]).fill(name));
     const frames = [];
     let line_idx = 7;
-    const frac_to_cart = math.create_frac_to_cart(lattice_matrix);
+    let frac_to_cart = math.create_frac_to_cart(lattice_matrix);
     while (line_idx < lines.length) {
         const config_idx = lines.findIndex((line, idx) => idx >= line_idx && line.includes(`Direct configuration=`));
         if (config_idx === -1)
             break;
+        // Variable-cell runs (NPT/ISIF=3) repeat the full 7-line header before each configuration
+        if (config_idx - line_idx >= 7) {
+            const hdr = parse_xdatcar_header(lines, config_idx - 7);
+            if (Number.isFinite(hdr.scale) &&
+                hdr.rows.every((row) => row.length === 3 && row.every(Number.isFinite))) {
+                lattice_matrix = validate_3x3_matrix(hdr.rows);
+                frac_to_cart = math.create_frac_to_cart(lattice_matrix);
+                if (hdr.names.length === hdr.counts.length &&
+                    hdr.names.every(is_valid_element_symbol) &&
+                    hdr.counts.every((count) => Number.isInteger(count) && count > 0)) {
+                    elements = hdr.names.flatMap((name, idx) => Array(hdr.counts[idx]).fill(name));
+                }
+            }
+        }
         const config_line = lines[config_idx];
         line_idx = config_idx + 1;
         const step_match = /configuration=\s*(\d+)/.exec(config_line);
-        const step = step_match ? parseInt(step_match[1]) : frames.length + 1;
+        const step = step_match ? parseInt(step_match[1], 10) : frames.length + 1;
         const positions = [];
         for (let idx = 0; idx < elements.length && line_idx < lines.length; idx++) {
             const coords = lines[line_idx].trim().split(/\s+/).slice(0, 3).map(Number);

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

@@ -1,2 +1,26 @@
+import type { ElementSymbol } from '../../element/types';
+import * as math from '../../math';
 import type { TrajectoryType } from '../index';
+export declare function parse_extxyz_columns(comment: string): {
+    species_col: number;
+    pos_col: number;
+    forces_col: number;
+    min_cols: number;
+};
+export declare function parse_extxyz_lattice(comment: string): math.Matrix3x3 | undefined;
+export declare function parse_xyz_comment_metadata(comment: string): {
+    step?: number;
+    properties: Record<string, number>;
+};
+type ForceStats = {
+    forces: number[][];
+    force_max: number;
+    force_norm: number;
+};
+export declare function parse_xyz_atom_lines(lines: string[], start: number, num_atoms: number, comment: string, frame_label: string): {
+    elements: ElementSymbol[];
+    positions: number[][];
+    force_stats: ForceStats | null;
+};
 export declare function parse_xyz_trajectory(content: string): TrajectoryType;
+export {};

package/dist/trajectory/parse/xyz.js

@@ -1,103 +1,116 @@
 import * as math from '../../math';
 import { coerce_element_symbol, create_trajectory_frame } from '../helpers';
+// Resolve species/pos/forces column offsets from an extxyz Properties string of
+// name:type:ncols triples (e.g. "species:S:1:pos:R:3:forces:R:3"), falling back
+// to the conventional "symbol x y z" layout when absent or malformed
+export function parse_extxyz_columns(comment) {
+    const fields = /Properties\s*=\s*"?([^"\s]+)"?/i.exec(comment)?.[1].split(`:`) ?? [];
+    // Well-formed Properties is name:type:ncols triples; a non-multiple of 3 is malformed,
+    // so bail to the conventional default rather than trusting a partial layout
+    let layout = fields.length % 3 === 0 ? {} : null;
+    for (let idx = 0, offset = 0; layout && idx + 3 <= fields.length; idx += 3) {
+        const ncols = parseInt(fields[idx + 2], 10);
+        if (Number.isInteger(ncols) && ncols > 0) {
+            layout[fields[idx].toLowerCase()] = { offset, ncols };
+            offset += ncols;
+        }
+        else
+            layout = null;
+    }
+    const species_col = layout?.species?.offset ?? 0;
+    const pos_col = layout?.pos?.offset ?? 1;
+    const forces_col = layout?.forces && layout.forces.ncols >= 3 ? layout.forces.offset : -1;
+    return { species_col, pos_col, forces_col, min_cols: Math.max(pos_col + 3, species_col + 1) };
+}
+// Parse Lattice="ax ay az bx by bz cx cy cz" from an extxyz comment line
+export function parse_extxyz_lattice(comment) {
+    const vals = /Lattice\s*=\s*"([^"]+)"/i.exec(comment)?.[1].trim().split(/\s+/).map(Number);
+    if (vals?.length !== 9 || !vals.every(Number.isFinite))
+        return undefined;
+    return [vals.slice(0, 3), vals.slice(3, 6), vals.slice(6, 9)];
+}
+// Keys anchored at ^|\s and followed by [=:] so single-letter keys (E/V/P/T) don't match mid-word
+const make_pattern = (keys) => new RegExp(`(?:^|\\s)(?:${keys})\\s*[=:]\\s*([-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?)`, `i`);
+const METADATA_PATTERNS = {
+    energy: make_pattern(`energy|E|etot|total_energy`),
+    volume: make_pattern(`volume|vol|V`),
+    pressure: make_pattern(`pressure|press|P`),
+    temperature: make_pattern(`temperature|temp|T`),
+    force_max: make_pattern(`max_force|force_max|fmax`),
+    bandgap: make_pattern(`bandgap|E_gap|gap`),
+};
+// Extract step number and scalar properties from an (ext)XYZ comment line
+export function parse_xyz_comment_metadata(comment) {
+    const properties = {};
+    for (const [key, pattern] of Object.entries(METADATA_PATTERNS)) {
+        const match = pattern.exec(comment);
+        if (match)
+            properties[key] = parseFloat(match[1]);
+    }
+    const step = /(?:^|\s)(?:step|frame|ionic_step)\s*[=:]?\s*(\d+)/i.exec(comment)?.[1];
+    return { step: step ? parseInt(step, 10) : undefined, properties };
+}
+// Parse num_atoms atom lines starting at lines[start], reading species/pos/forces from
+// their Properties-declared column offsets; invalid atoms are skipped with a warning.
+// force_stats holds raw forces plus max and RMS force magnitudes when forces are present.
+export function parse_xyz_atom_lines(lines, start, num_atoms, comment, frame_label) {
+    const { species_col, pos_col, forces_col, min_cols } = parse_extxyz_columns(comment);
+    const elements = [];
+    const positions = [];
+    const forces = [];
+    for (let idx = 0; idx < num_atoms; idx++) {
+        const parts = lines[start + idx]?.trim().split(/\s+/) ?? [];
+        if (parts.length < min_cols)
+            continue;
+        const pos = parts.slice(pos_col, pos_col + 3).map(parseFloat);
+        if (!pos.every(Number.isFinite)) {
+            console.warn(`Skipping XYZ atom with invalid coordinates in ${frame_label} at line ${start + idx + 1}`);
+            continue;
+        }
+        const symbol = parts[species_col];
+        const element_symbol = coerce_element_symbol(symbol);
+        if (!element_symbol) {
+            console.warn(`Skipping XYZ atom with unknown element symbol "${symbol}" in ${frame_label}`);
+            continue;
+        }
+        elements.push(element_symbol);
+        positions.push(pos);
+        if (forces_col >= 0 && parts.length >= forces_col + 3) {
+            const force_vec = parts.slice(forces_col, forces_col + 3).map(parseFloat);
+            if (force_vec.every(Number.isFinite))
+                forces.push(force_vec);
+        }
+    }
+    if (forces.length === 0)
+        return { elements, positions, force_stats: null };
+    const mags = forces.map((force) => Math.hypot(...force));
+    const force_norm = Math.sqrt(mags.reduce((sum, mag) => sum + mag ** 2, 0) / mags.length);
+    return {
+        elements,
+        positions,
+        force_stats: { forces, force_max: Math.max(...mags), force_norm },
+    };
+}
 export function parse_xyz_trajectory(content) {
     const lines = content.trim().split(/\r?\n/);
     const frames = [];
     let line_idx = 0;
     while (line_idx < lines.length) {
-        if (!lines[line_idx]?.trim()) {
-            line_idx++;
-            continue;
-        }
         const num_atoms = parseInt(lines[line_idx].trim(), 10);
         if (isNaN(num_atoms) || num_atoms <= 0 || line_idx + num_atoms + 1 >= lines.length) {
-            line_idx++;
+            line_idx++; // skip blank/invalid lines until the next frame's atom-count line
             continue;
         }
-        const comment = lines[++line_idx] || ``;
-        const metadata = {};
-        // Extract properties efficiently
-        const extractors = {
-            step: /(?:step|frame|ionic_step)\s*[=:]?\s*(\d+)/i,
-            energy: /(?:energy|E|etot|total_energy)\s*[=:]?\s*([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/i,
-            volume: /(?:volume|vol|V)\s*[=:]?\s*([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/i,
-            pressure: /(?:pressure|press|P)\s*[=:]?\s*([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/i,
-            temperature: /(?:temperature|temp|T)\s*[=:]?\s*([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/i,
-            force_max: /(?:max_force|force_max|fmax)\s*[=:]?\s*([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/i,
-            bandgap: /(?:bandgap|E_gap|gap)\s*[=:]?\s*([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/i,
-        };
-        const step_match = extractors.step.exec(comment);
-        const step = step_match?.[1] ? parseInt(step_match[1]) : frames.length;
-        Object.entries(extractors).forEach(([key, pattern]) => {
-            if (key === `step`)
-                return;
-            const match = pattern.exec(comment);
-            if (match)
-                metadata[key] = parseFloat(match[1]);
-        });
-        // Extract lattice matrix
-        const lattice_match = /Lattice\s*=\s*"([^"]+)"/i.exec(comment);
-        let lattice_matrix;
-        if (lattice_match) {
-            const values = lattice_match[1].split(/\s+/).map(Number);
-            if (values.length === 9 && values.every((value) => Number.isFinite(value))) {
-                lattice_matrix = [
-                    [values[0], values[1], values[2]],
-                    [values[3], values[4], values[5]],
-                    [values[6], values[7], values[8]],
-                ];
-                metadata.volume = math.calc_lattice_params(lattice_matrix).volume;
-            }
-        }
-        // Parse atoms
-        const positions = [];
-        const elements = [];
-        const forces = [];
-        const has_forces = comment.includes(`forces:R:3`);
-        for (let idx = 0; idx < num_atoms; idx++) {
-            line_idx++;
-            if (line_idx >= lines.length)
-                break;
-            const parts = lines[line_idx].trim().split(/\s+/);
-            if (parts.length >= 4) {
-                const x_coord = parseFloat(parts[1]);
-                const y_coord = parseFloat(parts[2]);
-                const z_coord = parseFloat(parts[3]);
-                if (!Number.isFinite(x_coord) ||
-                    !Number.isFinite(y_coord) ||
-                    !Number.isFinite(z_coord)) {
-                    console.warn(`Skipping XYZ atom with invalid coordinates in frame ${frames.length} at line ${line_idx + 1}`);
-                    continue;
-                }
-                const raw_symbol = parts[0];
-                const element_symbol = coerce_element_symbol(raw_symbol);
-                if (!element_symbol) {
-                    console.warn(`Skipping XYZ atom with unknown element symbol "${raw_symbol}" in frame ${frames.length}`);
-                    continue;
-                }
-                elements.push(element_symbol);
-                positions.push([x_coord, y_coord, z_coord]);
-                if (has_forces && parts.length >= 7) {
-                    const force_x = parseFloat(parts[4]);
-                    const force_y = parseFloat(parts[5]);
-                    const force_z = parseFloat(parts[6]);
-                    if (Number.isFinite(force_x) &&
-                        Number.isFinite(force_y) &&
-                        Number.isFinite(force_z)) {
-                        forces.push([force_x, force_y, force_z]);
-                    }
-                }
-            }
-        }
-        if (forces.length > 0) {
-            metadata.forces = forces;
-            const magnitudes = forces.map((force) => Math.hypot(...force));
-            metadata.force_max = Math.max(...magnitudes);
-            // Calculate RMS (root mean square) of force magnitudes
-            metadata.force_norm = Math.sqrt(magnitudes.reduce((sum, mag) => sum + mag ** 2, 0) / magnitudes.length);
-        }
-        frames.push(create_trajectory_frame(positions, elements, lattice_matrix, lattice_matrix ? [true, true, true] : undefined, step, metadata));
-        line_idx++;
+        const comment = lines[line_idx + 1] || ``;
+        const { step, properties } = parse_xyz_comment_metadata(comment);
+        const metadata = { ...properties };
+        const lattice_matrix = parse_extxyz_lattice(comment);
+        if (lattice_matrix)
+            metadata.volume = math.calc_lattice_params(lattice_matrix).volume;
+        const { elements, positions, force_stats } = parse_xyz_atom_lines(lines, line_idx + 2, num_atoms, comment, `frame ${frames.length}`);
+        Object.assign(metadata, force_stats);
+        frames.push(create_trajectory_frame(positions, elements, lattice_matrix, lattice_matrix ? [true, true, true] : undefined, step ?? frames.length, metadata));
+        line_idx += num_atoms + 2;
     }
     return {
         frames,

package/dist/trajectory/plotting.d.ts

@@ -1,4 +1,4 @@
-import type { DataSeries } from '../plot/types';
+import type { DataSeries } from '../plot/core/types';
 import type { TrajectoryDataExtractor, TrajectoryMetadata, TrajectoryType } from './index';
 export interface PlotSeriesOptions {
     property_config?: Record<string, {