matterviz 0.4.1 → 0.4.2

package/dist/trajectory/Trajectory.svelte.d.ts

@@ -61,6 +61,6 @@ type $$ComponentProps = EventHandlers & HTMLAttributes<HTMLDivElement> & {
     wrapper?: HTMLDivElement;
     fullscreen?: boolean;
 };
-declare const Trajectory: import("svelte").Component<$$ComponentProps, {}, "trajectory" | "fullscreen" | "wrapper" | "hovered" | "controls_open" | "fps" | "info_pane_open" | "display_mode" | "current_step_idx" | "visible_properties">;
+declare const Trajectory: import("svelte").Component<$$ComponentProps, {}, "fullscreen" | "wrapper" | "hovered" | "controls_open" | "trajectory" | "fps" | "info_pane_open" | "display_mode" | "current_step_idx" | "visible_properties">;
 type Trajectory = ReturnType<typeof Trajectory>;
 export default Trajectory;

package/dist/trajectory/TrajectoryError.svelte

@@ -3,14 +3,17 @@
   import type { Snippet } from 'svelte'
   import type { HTMLAttributes } from 'svelte/elements'
 
-  let { error_msg, on_dismiss, error_snippet, ...rest }:
-    & HTMLAttributes<HTMLDivElement>
-    & {
-      error_msg: string
-      on_dismiss: () => void
-      // Custom error snippet for advanced error handling
-      error_snippet?: Snippet<[{ error_msg: string; on_dismiss: () => void }]>
-    } = $props()
+  let {
+    error_msg,
+    on_dismiss,
+    error_snippet,
+    ...rest
+  }: HTMLAttributes<HTMLDivElement> & {
+    error_msg: string
+    on_dismiss: () => void
+    // Custom error snippet for advanced error handling
+    error_snippet?: Snippet<[{ error_msg: string; on_dismiss: () => void }]>
+  } = $props()
 </script>
 
 <div {...rest}>

package/dist/trajectory/TrajectoryExportPane.svelte

@@ -62,7 +62,7 @@
     if (!canvas) return 0
     const pixels = canvas.width * canvas.height * resolution_multiplier ** 2
     const bitrate = estimate_video_bitrate(pixels, video_fps)
-    return (bitrate * export_frame_count / video_fps) / 8 / 1024 / 1024
+    return (bitrate * export_frame_count) / video_fps / 8 / 1024 / 1024
   })
 
   // Initialize end_frame when trajectory changes
@@ -84,9 +84,7 @@
     }
   })
 
-  let export_frame_count = $derived(
-    end_frame >= start_frame ? end_frame - start_frame + 1 : 0,
-  )
+  let export_frame_count = $derived(end_frame >= start_frame ? end_frame - start_frame + 1 : 0)
 
   async function handle_video_export(format: `webm` | `mp4` = `webm`) {
     export_error = null
@@ -96,8 +94,8 @@
       export_error = !trajectory
         ? `No trajectory`
         : !canvas
-        ? `Canvas not ready`
-        : `Invalid frame range`
+          ? `Canvas not ready`
+          : `Invalid frame range`
       return
     }
 
@@ -172,13 +170,7 @@
       <label>
         Frame Rate (FPS)
         <input type="number" min={10} max={60} bind:value={video_fps} />
-        <input
-          type="range"
-          min={10}
-          max={60}
-          bind:value={video_fps}
-          style="accent-color: var(--accent-color)"
-        />
+        <input type="range" min={10} max={60} bind:value={video_fps} />
       </label>
 
       <span class="field-label">
@@ -192,7 +184,9 @@
               class:active={resolution_multiplier === multiplier}
               onclick={() => (resolution_multiplier = multiplier)}
               {@attach tooltip({
-                content: canvas ? `${multiplier}x (${width_px}×${height_px})` : `${multiplier}x`,
+                content: canvas
+                  ? `${multiplier}x (${width_px}×${height_px})`
+                  : `${multiplier}x`,
               })}
             >
               {multiplier}x
@@ -214,7 +208,6 @@
           min={0}
           max={Math.max(0, total_frames_available - 1)}
           bind:value={start_frame}
-          style="accent-color: var(--accent-color)"
         />
       </label>
 
@@ -231,7 +224,6 @@
           min={start_frame}
           max={Math.max(0, total_frames_available - 1)}
           bind:value={end_frame}
-          style="accent-color: var(--accent-color)"
         />
       </label>
     </SettingsSection>
@@ -243,13 +235,7 @@
     {/if}
 
     <div class="export-buttons">
-      {#each [
-        { label: `WebM`, format: `webm`, hint: `Export as WebM video` },
-        { label: `MP4`, format: `mp4`, hint: `WebM + ffmpeg command` },
-      ] as const as
-        { label, format, hint }
-        (format)
-      }
+      {#each [{ label: `WebM`, format: `webm`, hint: `Export as WebM video` }, { label: `MP4`, format: `mp4`, hint: `WebM + ffmpeg command` }] as const as { label, format, hint } (format)}
         <div style="display: flex; align-items: center; gap: 4pt">
           {label}
           <button
@@ -267,15 +253,11 @@
     </div>
 
     <div class="export-info">
-      {(export_frame_count / video_fps).toFixed(1)}s ({export_frame_count} frames: {
-        start_frame
-      }–{end_frame})
+      {(export_frame_count / video_fps).toFixed(1)}s ({export_frame_count} frames: {start_frame}–{end_frame})
       {#if file_size_mb > 0}
-        • ~{
-          file_size_mb < 1
+        • ~{file_size_mb < 1
           ? `${(file_size_mb * 1024).toFixed(0)} KB`
-          : `${file_size_mb.toFixed(1)} MB`
-        }
+          : `${file_size_mb.toFixed(1)} MB`}
       {/if}
     </div>
 
@@ -292,7 +274,8 @@
     gap: 6pt;
     white-space: nowrap;
   }
-  .warning, .error-message {
+  .warning,
+  .error-message {
     padding: 1ex;
     border-radius: var(--traj-border-radius, var(--border-radius, 3pt));
     font-size: 0.9em;

package/dist/trajectory/TrajectoryInfoPane.svelte

@@ -2,7 +2,7 @@
   import type { PaneProps, PaneToggleProps } from '../overlays'
   import type { InfoItem } from '../layout'
   import InfoPaneCards from '../overlays/InfoPaneCards.svelte'
-  import { format_num } from '../labels'
+  import { format_bytes, format_num } from '../labels'
   import DraggablePane from '../overlays/DraggablePane.svelte'
   import { get_electro_neg_formula } from '../composition'
   import { SETTINGS_CONFIG } from '../settings'
@@ -34,11 +34,6 @@
   } = $props()
 
   // Helper functions
-  const format_size = (bytes: number) =>
-    bytes > 1024 * 1024
-      ? `${format_num(bytes / (1024 * 1024), `.2~f`)} MB`
-      : `${format_num(bytes / 1024, `.2~f`)} KB`
-
   const is_valid_number = (val: unknown): val is number =>
     typeof val === `number` && isFinite(val)
 
@@ -51,8 +46,7 @@
       return `${format_num(values[0], decimals)} ${unit}`.trim()
     }
     const [min, max] = [Math.min(...values), Math.max(...values)]
-    return `${format_num(min, decimals)} - ${format_num(max, decimals)} ${unit}`
-      .trim()
+    return `${format_num(min, decimals)} - ${format_num(max, decimals)} ${unit}`.trim()
   }
 
   const safe_item = (
@@ -60,7 +54,7 @@
     value: string | null,
     key?: string,
     tooltip?: string,
-  ): InfoItem | null => value ? { label, value, key, tooltip } : null
+  ): InfoItem | null => (value ? { label, value, key, tooltip } : null)
 
   // oxlint-disable-next-line eslint-plugin-unicorn/prefer-native-coercion-functions -- type predicate needed for narrowing
   const is_info_item = (item: unknown): item is InfoItem => Boolean(item)
@@ -79,7 +73,8 @@
       (!trajectory?.frames?.length && !trajectory?.total_frames) ||
       current_step_idx < 0 ||
       current_step_idx >= (trajectory.total_frames ?? trajectory.frames?.length ?? 0)
-    ) return []
+    )
+      return []
 
     // For indexed trajectories, we might not have the current frame loaded
     const current_frame = trajectory.frames?.[current_step_idx]
@@ -90,22 +85,18 @@
     // File info section
     const file_items = [
       current_filename &&
-      safe_item(
-        `Name`,
-        current_filename,
-        `file-name`,
-        current_file_path || undefined,
-      ),
-      file_size && file_size > 0 &&
-      safe_item(`File Size`, format_size(file_size), `file-size`),
+        safe_item(`Name`, current_filename, `file-name`, current_file_path || undefined),
+      file_size &&
+        file_size > 0 &&
+        safe_item(`File Size`, format_bytes(file_size), `file-size`),
       file_object?.lastModified &&
-      safe_item(
-        `Modified`,
-        new Date(file_object.lastModified).toLocaleString(),
-        `file-modified`,
-      ),
+        safe_item(
+          `Modified`,
+          new Date(file_object.lastModified).toLocaleString(),
+          `file-modified`,
+        ),
       trajectory.metadata?.source_format &&
-      safe_item(`Format`, String(trajectory.metadata.source_format), `file-format`),
+        safe_item(`Format`, String(trajectory.metadata.source_format), `file-format`),
     ].filter(is_info_item)
 
     if (file_items.length > 0) {
@@ -116,32 +107,33 @@
     const traj_items = [
       safe_item(
         `Total Frames`,
-        `${format_num(total_frames, `.3~s`)} (current: ${
-          format_num(current_step_idx + 1, `.3~s`)
-        })`,
+        `${format_num(total_frames, `.3~s`)} (current: ${format_num(
+          current_step_idx + 1,
+          `.3~s`,
+        )})`,
         `total-frames`,
       ),
       trajectory.is_indexed &&
-      safe_item(
-        `Indexed`,
-        `Yes`,
-        `indexed-mode`,
-        SETTINGS_CONFIG.trajectory.use_indexing.description,
-      ),
+        safe_item(
+          `Indexed`,
+          `Yes`,
+          `indexed-mode`,
+          SETTINGS_CONFIG.trajectory.use_indexing.description,
+        ),
       trajectory.indexed_frames &&
-      safe_item(
-        `Index Points`,
-        `${trajectory.indexed_frames.length}`,
-        `index-points`,
-        `Number of frames indexed for fast seeking`,
-      ),
+        safe_item(
+          `Index Points`,
+          `${trajectory.indexed_frames.length}`,
+          `index-points`,
+          `Number of frames indexed for fast seeking`,
+        ),
       trajectory.plot_metadata &&
-      safe_item(
-        `Plot Metadata`,
-        `${trajectory.plot_metadata.length} frames`,
-        `plot-metadata`,
-        `Pre-extracted metadata for plotting`,
-      ),
+        safe_item(
+          `Plot Metadata`,
+          `${trajectory.plot_metadata.length} frames`,
+          `plot-metadata`,
+          `Pre-extracted metadata for plotting`,
+        ),
     ].filter(is_info_item)
 
     if (traj_items.length > 0) {
@@ -158,30 +150,35 @@
       const structure_items = [
         safe_item(`Atoms`, `${structure.sites.length}`, `atoms`),
         formula && safe_item(`Formula`, String(formula), `formula`),
-        is_valid_number(volume) && volume > 0 &&
-        safe_item(`Volume`, `${format_num(volume, `.3~s`)} ų`, `volume`),
-        is_valid_number(volume) && volume > 0 && structure.sites.length > 0 &&
-        safe_item(
-          `Density`,
-          `${format_num(structure.sites.length / volume, `.4~s`)} atoms/ų`,
-          `density`,
-        ),
+        is_valid_number(volume) &&
+          volume > 0 &&
+          safe_item(`Volume`, `${format_num(volume, `.3~s`)} ų`, `volume`),
+        is_valid_number(volume) &&
+          volume > 0 &&
+          structure.sites.length > 0 &&
+          safe_item(
+            `Density`,
+            `${format_num(structure.sites.length / volume, `.4~s`)} atoms/ų`,
+            `density`,
+          ),
         [a, b, c].every(is_valid_number) &&
-        safe_item(
-          `Cell Lengths`,
-          `${format_num(a as number, `.3~f`)}, ${format_num(b as number, `.3~f`)}, ${
-            format_num(c as number, `.3~f`)
-          } Å`,
-          `cell-lengths`,
-        ),
+          safe_item(
+            `Cell Lengths`,
+            `${format_num(a as number, `.3~f`)}, ${format_num(b as number, `.3~f`)}, ${format_num(
+              c as number,
+              `.3~f`,
+            )} Å`,
+            `cell-lengths`,
+          ),
         [alpha, beta, gamma].every(is_valid_number) &&
-        safe_item(
-          `Cell Angles`,
-          `${format_num(alpha as number, `.2~f`)}°, ${
-            format_num(beta as number, `.2~f`)
-          }°, ${format_num(gamma as number, `.2~f`)}°`,
-          `cell-angles`,
-        ),
+          safe_item(
+            `Cell Angles`,
+            `${format_num(alpha as number, `.2~f`)}°, ${format_num(
+              beta as number,
+              `.2~f`,
+            )}°, ${format_num(gamma as number, `.2~f`)}°`,
+            `cell-angles`,
+          ),
       ].filter(is_info_item)
 
       if (structure_items.length > 0) {
@@ -212,11 +209,11 @@
 
         const energy_items = [
           is_valid_number(current_energy) &&
-          safe_item(
-            `Current Energy`,
-            `${format_num(current_energy, `.3~s`)} eV`,
-            `energy-current`,
-          ),
+            safe_item(
+              `Current Energy`,
+              `${format_num(current_energy, `.3~s`)} eV`,
+              `energy-current`,
+            ),
           energy_range && safe_item(`Energy Range`, energy_range, `energy-range`),
         ].filter(is_info_item)
 
@@ -235,11 +232,11 @@
 
         const force_items = [
           is_valid_number(current_force) &&
-          safe_item(
-            `Max Force`,
-            `${format_num(current_force, `.3~s`)} eV/Å`,
-            `force-current`,
-          ),
+            safe_item(
+              `Max Force`,
+              `${format_num(current_force, `.3~s`)} eV/Å`,
+              `force-current`,
+            ),
           force_range && safe_item(`Force Range`, force_range, `force-range`),
         ].filter(is_info_item)
 
@@ -250,29 +247,22 @@
     }
 
     // Volume change section (only for regular trajectories)
-    if (
-      !trajectory.is_indexed && current_frame?.structure &&
-      trajectory.frames.length > 1
-    ) {
-      const lattice = `lattice` in current_frame.structure
-        ? current_frame.structure.lattice
-        : null
+    if (!trajectory.is_indexed && current_frame?.structure && trajectory.frames.length > 1) {
+      const lattice =
+        `lattice` in current_frame.structure ? current_frame.structure.lattice : null
       if (lattice) {
-        const volumes = trajectory.frames.map((
-          { structure },
-        ) => (`lattice` in structure && structure.lattice?.volume))
+        const volumes = trajectory.frames
+          .map(({ structure }) => `lattice` in structure && structure.lattice?.volume)
           .filter(is_valid_number)
           .filter((volume) => volume > 0)
 
         if (volumes.length > 1) {
-          const vol_change = (Math.max(...volumes) - Math.min(...volumes)) /
-            Math.min(...volumes)
+          const vol_change =
+            (Math.max(...volumes) - Math.min(...volumes)) / Math.min(...volumes)
           if (Math.abs(vol_change) > 0.1 && is_valid_number(vol_change)) {
-            const vol_items = [safe_item(
-              `Volume Change`,
-              `${format_num(vol_change, `.2~%`)}`,
-              `vol-change`,
-            )].filter(is_info_item)
+            const vol_items = [
+              safe_item(`Volume Change`, `${format_num(vol_change, `.2~%`)}`, `vol-change`),
+            ].filter(is_info_item)
 
             if (vol_items.length > 0) {
               sections.push({ title: `Volume`, items: vol_items })
@@ -284,9 +274,7 @@
     return sections
   })
 
-  let info_cards = $derived(
-    info_pane_data.map(({ title, items }) => ({ title, rows: items })),
-  )
+  let info_cards = $derived(info_pane_data.map(({ title, items }) => ({ title, rows: items })))
   let n_info_items = $derived(
     info_pane_data.reduce((count, { items }) => count + items.length, 0),
   )

package/dist/trajectory/extract.js

@@ -52,6 +52,23 @@ export const force_stress_data_extractor = (frame) => {
     }
     return data;
 };
+// Data extractor for SCF/electronic-convergence properties. Parsers emit these
+// per frame (per ionic step, or per SCF step for static single-point runs) —
+// e.g. the vaspout.h5 parser fills them from VASP's OSZICAR data.
+const scf_data_extractor = (frame) => {
+    const data = {
+        Step: frame.step,
+    };
+    if (frame.metadata) {
+        copy_numeric_fields(data, frame.metadata, [
+            `n_scf_steps`,
+            `scf_energy_delta`,
+            `scf_rms`,
+            `scf_charge_rms`,
+        ]);
+    }
+    return data;
+};
 // Data extractor for structural properties
 export const structural_data_extractor = (frame) => {
     const data = {
@@ -93,50 +110,55 @@ export const structural_data_extractor = (frame) => {
     }
     return data;
 };
-// Helper function to check if a property varies across trajectory frames
-function property_varies(trajectory, property_key, tolerance = 1e-10) {
-    if (trajectory.frames.length <= 1)
-        return false;
-    const values = [];
+const LATTICE_PARAMS = [`a`, `b`, `c`, `alpha`, `beta`, `gamma`];
+// Cache per trajectory: full_data_extractor runs once per frame, so without this it
+// rescans all frames on every call (O(n²)). WeakMap → GC'd with the trajectory.
+const constant_params_cache = new WeakMap();
+// Lattice params constant across the trajectory, in a single pass (prefer lattice value,
+// else metadata; tol 1e-10). A param must be observed in ≥1 frame to count as constant;
+// params absent from every frame are excluded (not silently treated as "constant").
+function get_constant_lattice_params(trajectory) {
+    const cached = constant_params_cache.get(trajectory);
+    if (cached)
+        return cached;
+    const tolerance = 1e-10;
+    const first_values = new Map();
+    const varies = new Set();
     for (const frame of trajectory.frames) {
-        // Check both direct structure properties and metadata
-        let value;
-        if (`lattice` in frame.structure) {
-            const lattice_value = frame.structure.lattice[property_key];
-            if (typeof lattice_value === `number`)
-                value = lattice_value;
-        }
-        if (value === undefined && frame.metadata && property_key in frame.metadata) {
-            const metadata_value = frame.metadata[property_key];
-            if (typeof metadata_value === `number`) {
-                value = metadata_value;
-            }
-        }
-        if (value !== undefined) {
-            values.push(value);
+        const lattice = `lattice` in frame.structure
+            ? frame.structure.lattice
+            : null;
+        for (const param of LATTICE_PARAMS) {
+            if (varies.has(param))
+                continue; // already known to vary, skip
+            const lattice_value = lattice?.[param];
+            const value = typeof lattice_value === `number` ? lattice_value : frame.metadata?.[param];
+            // Number.isFinite: NaN is typeof `number` but Math.abs(next-NaN)=NaN → false constant
+            if (typeof value !== `number` || !Number.isFinite(value))
+                continue;
+            const first = first_values.get(param);
+            if (first === undefined)
+                first_values.set(param, value);
+            else if (Math.abs(value - first) > tolerance)
+                varies.add(param);
         }
     }
-    if (values.length <= 1)
-        return false;
-    const first_value = values[0];
-    return values.some((value) => Math.abs(value - first_value) > tolerance);
+    // only params observed in ≥1 frame; a never-present param is not "constant"
+    const constant = new Set([...first_values.keys()].filter((param) => !varies.has(param)));
+    constant_params_cache.set(trajectory, constant);
+    return constant;
 }
 // Combined data extractor that extracts all common properties
 export const full_data_extractor = (frame, trajectory) => {
-    const base_data = {
+    const result = {
         ...energy_data_extractor(frame, trajectory),
         ...force_stress_data_extractor(frame, trajectory),
+        ...scf_data_extractor(frame, trajectory),
         ...structural_data_extractor(frame, trajectory),
     };
-    // Check which lattice parameters vary
-    const lattice_params = [`a`, `b`, `c`, `alpha`, `beta`, `gamma`];
-    const result = { ...base_data };
-    // Add metadata to specify which properties don't vary
-    for (const param of lattice_params) {
-        if (!property_varies(trajectory, param)) {
-            // Mark individual lattice parameters as constant
-            result[`constant_${param}`] = 1;
-        }
+    // Mark individual lattice parameters that don't vary across the trajectory
+    for (const param of get_constant_lattice_params(trajectory)) {
+        result[`constant_${param}`] = 1;
     }
     return result;
 };

package/dist/trajectory/format-detect.js

@@ -1,10 +1,11 @@
 // Format detection for trajectory files
 import { CONFIG_DIRS_REGEX, MD_SIM_EXCLUDE_REGEX, TRAJ_EXTENSIONS_REGEX, TRAJ_FALLBACK_EXTENSIONS_REGEX, TRAJ_KEYWORDS_SIMPLE_REGEX, XDATCAR_REGEX, } from '../constants';
-import { strip_compression_extensions } from '../io';
+import { strip_compression_extensions } from '../io/decompress';
+import { parse_leading_num } from '../utils';
 import { count_xyz_frames } from './helpers';
 // 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)$/;
+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
@@ -29,7 +30,7 @@ export const FORMAT_PATTERNS = {
         return [0x2d, 0x20, 0x6f, 0x66, 0x20, 0x55, 0x6c, 0x6d].every((byte, idx) => view[idx] === byte);
     },
     hdf5: (data, filename) => {
-        if (ext_hint(filename, /\.(h5|hdf5)$/) === false)
+        if (ext_hint(filename, /\.(?:h5|hdf5)$/) === false)
             return false;
         if (!(data instanceof ArrayBuffer) || data.byteLength < 8)
             return false;
@@ -43,11 +44,11 @@ export const FORMAT_PATTERNS = {
         const lines = data.trim().split(/\r?\n/);
         return (lines.length >= 10 &&
             lines.some((line) => line.includes(`Direct configuration=`)) &&
-            !isNaN(parseFloat(lines[1])) &&
+            !isNaN(parse_leading_num(lines[1])) &&
             lines.slice(2, 5).every((line) => line.trim().split(/\s+/).length === 3));
     },
     xyz_multi: (data, filename) => {
-        if (ext_hint(filename, /\.(xyz|extxyz)$/) === false)
+        if (ext_hint(filename, /\.(?:xyz|extxyz)$/) === false)
             return false;
         return count_xyz_frames(data) >= 2;
     },
@@ -63,7 +64,7 @@ export function is_trajectory_file(filename, content) {
         return false;
     const base_name = strip_compression_extensions(filename);
     // For xyz/extxyz files, use content-based detection if available
-    if (/\.(xyz|extxyz)$/i.test(base_name)) {
+    if (/\.(?:xyz|extxyz)$/i.test(base_name)) {
         if (content)
             return count_xyz_frames(content) >= 2;
         return TRAJ_KEYWORDS_SIMPLE_REGEX.test(base_name);
@@ -74,9 +75,10 @@ export function is_trajectory_file(filename, content) {
     // Special exclusion for generic md_simulation pattern with certain extensions
     if (MD_SIM_EXCLUDE_REGEX.test(base_name))
         return false;
-    // For .h5/.hdf5 files, require trajectory keywords
-    if (/\.(h5|hdf5)$/i.test(base_name)) {
-        return TRAJ_KEYWORDS_SIMPLE_REGEX.test(base_name);
+    // For .h5/.hdf5 files, require trajectory keywords. vaspout.h5 (VASP's
+    // HDF5 output) is always trajectory-shaped regardless of keywords.
+    if (/\.(?:h5|hdf5)$/i.test(base_name)) {
+        return /vaspout/i.test(base_name) || TRAJ_KEYWORDS_SIMPLE_REGEX.test(base_name);
     }
     // For other extensions, require both keywords and specific extensions
     return (TRAJ_KEYWORDS_SIMPLE_REGEX.test(base_name) &&

package/dist/trajectory/frame-reader.d.ts

@@ -2,6 +2,7 @@ import type { FrameIndex, FrameLoader, ParseProgress, TrajectoryFrame, Trajector
 export declare class TrajFrameReader implements FrameLoader {
     private readonly format;
     private global_numbers?;
+    private xyz_cache?;
     constructor(filename: string);
     get_total_frames(data: string | ArrayBuffer): Promise<number>;
     build_frame_index(data: string | ArrayBuffer, sample_rate: number, on_progress?: (progress: ParseProgress) => void): Promise<FrameIndex[]>;
@@ -10,6 +11,7 @@ export declare class TrajFrameReader implements FrameLoader {
         sample_rate?: number;
         properties?: string[];
     }, on_progress?: (progress: ParseProgress) => void): Promise<TrajectoryMetadata[]>;
+    private get_xyz_cache;
     private load_xyz_frame;
     private load_ase_frame;
     private parse_ase_metadata;