matterviz 0.3.2 → 0.3.4

package/dist/xrd/broadening.js

@@ -11,6 +11,7 @@ export function caglioti_fwhm(two_theta, // Angle in degrees (2θ)
 U, // Caglioti parameter U
 V, // Caglioti parameter V
 W) {
+    // FWHM in degrees (2θ)
     const theta_rad = (two_theta / 2) * (Math.PI / 180);
     const tan_theta = Math.tan(theta_rad);
     const fwhm_sq = U * tan_theta ** 2 + V * tan_theta + W;
@@ -19,6 +20,7 @@ W) {
 }
 // Normalized Gaussian profile. x: position, x0: peak center, fwhm: Full Width at Half Maximum
 function gaussian(x, x0, fwhm) {
+    // Intensity at x
     const safe_fwhm = Math.max(fwhm, 1e-9);
     const sigma = safe_fwhm / (2 * Math.sqrt(2 * LOG_2));
     const prefactor = 1 / (sigma * Math.sqrt(2 * Math.PI));
@@ -27,6 +29,7 @@ function gaussian(x, x0, fwhm) {
 }
 // Normalized Lorentzian profile. x: position, x0: peak center, fwhm: Full Width at Half Maximum
 function lorentzian(x, x0, fwhm) {
+    // Intensity at x
     const safe_fwhm = Math.max(fwhm, 1e-9);
     const gamma = safe_fwhm / 2;
     const prefactor = 1 / (Math.PI * gamma);
@@ -38,15 +41,17 @@ export function pseudo_voigt(x, // Position
 x0, // Peak center
 fwhm, // Full Width at Half Maximum
 eta) {
+    // Intensity at x
     // Clamp eta to [0, 1]
     const safe_eta = Math.max(0, Math.min(1, eta));
-    return (safe_eta * lorentzian(x, x0, fwhm) + (1 - safe_eta) * gaussian(x, x0, fwhm));
+    return safe_eta * lorentzian(x, x0, fwhm) + (1 - safe_eta) * gaussian(x, x0, fwhm);
 }
 // Computes a broadened XRD pattern from discrete peaks.
 export function compute_broadened_pattern(pattern, // Discrete XRD pattern (peaks)
 params, // Broadening parameters (U, V, W, shape_factor)
 range, // Angular range [min, max] in degrees
 step_size = 0.02) {
+    // Continuous broadened pattern
     if (!Number.isFinite(step_size) || step_size <= 0) {
         throw new Error(`step_size must be > 0 and finite`);
     }
@@ -59,14 +64,14 @@ step_size = 0.02) {
     const n_steps = Math.ceil((max_angle - min_angle) / step_size);
     const xs = new Float32Array(n_steps);
     const ys = new Float32Array(n_steps);
-    for (let i = 0; i < n_steps; i++) {
-        xs[i] = min_angle + i * step_size;
+    for (let idx = 0; idx < n_steps; idx++) {
+        xs[idx] = min_angle + idx * step_size;
     }
     const { x: peak_pos, y: peak_int } = pattern;
     // Optimization: Process each peak and add to grid
-    for (let p = 0; p < peak_pos.length; p++) {
-        const x0 = peak_pos[p];
-        const intensity = peak_int[p];
+    for (let peak_idx = 0; peak_idx < peak_pos.length; peak_idx++) {
+        const x0 = peak_pos[peak_idx];
+        const intensity = peak_int[peak_idx];
         // Skip negligible peaks
         if (intensity < 1e-5)
             continue;
@@ -80,9 +85,9 @@ step_size = 0.02) {
         const window = 20 * fwhm;
         const start_idx = Math.max(0, Math.floor((x0 - window - min_angle) / step_size));
         const end_idx = Math.min(n_steps - 1, Math.ceil((x0 + window - min_angle) / step_size));
-        for (let i = start_idx; i <= end_idx; i++) {
-            const x = xs[i];
-            ys[i] += intensity * pseudo_voigt(x, x0, fwhm, shape_factor);
+        for (let idx = start_idx; idx <= end_idx; idx++) {
+            const x = xs[idx];
+            ys[idx] += intensity * pseudo_voigt(x, x0, fwhm, shape_factor);
         }
     }
     // Convert back to number[]

package/dist/xrd/calc-xrd.js

@@ -2,11 +2,8 @@ import { element_data } from '../element';
 import * as math from '../math';
 import { parse_any_structure } from '../structure/parse';
 import { is_crystal } from '../structure/validation';
-// Single source of truth for atomic scattering params (shared with Rust/ferrox)
-// Development: imports from extensions/rust/src/, Production: copied to dist/xrd/ by package script
-import ATOMIC_SCATTERING_PARAMS from './atomic_scattering_params.json' with {
-    type: 'json'
-};
+// Single source of truth for atomic scattering params
+import ATOMIC_SCATTERING_PARAMS from './atomic_scattering_params.json' with { type: 'json' };
 import { is_xrd_data_file, parse_xrd_file } from './parse';
 // XRD wavelengths in Angstrom (Å)
 export const WAVELENGTHS = {
@@ -47,7 +44,7 @@ function get_unique_families(hkls) {
     // Port of pymatgen's get_unique_families: group Miller indices by absolute-value permutations
     const key_map = new Map();
     for (const hkl of hkls) {
-        const abs_sorted = [...hkl.map((v) => Math.abs(v))].sort((x, y) => x - y);
+        const abs_sorted = [...hkl.map((val) => Math.abs(val))].sort((x, y) => x - y);
         const key = abs_sorted.join(`,`);
         const list = key_map.get(key);
         if (list)
@@ -85,9 +82,9 @@ function enumerate_reciprocal_points(recip_rows, max_radius, min_radius) {
     const n1 = Math.max(Math.hypot(...recip_b1), 1e-12);
     const n2 = Math.max(Math.hypot(...recip_b2), 1e-12);
     const n3 = Math.max(Math.hypot(...recip_b3), 1e-12);
-    const h_max = Math.ceil((max_radius / n1) + 2);
-    const k_max = Math.ceil((max_radius / n2) + 2);
-    const l_max = Math.ceil((max_radius / n3) + 2);
+    const h_max = Math.ceil(max_radius / n1 + 2);
+    const k_max = Math.ceil(max_radius / n2 + 2);
+    const l_max = Math.ceil(max_radius / n3 + 2);
     // Safety cap to avoid pathological enumeration volume
     const CAP = 512;
     if (Math.max(h_max, k_max, l_max) > CAP) {
@@ -140,9 +137,7 @@ export function compute_xrd_pattern(structure, options = {}) {
     // const symprec = options.symprec ?? 0
     const recip_rows = compute_reciprocal_lattice_rows(structure);
     // Bragg condition bounds: reciprocal vector length r = 2 sin(theta) / lambda
-    const two_theta_range = options.two_theta_range === null
-        ? null
-        : options.two_theta_range ?? [0, 180];
+    const two_theta_range = options.two_theta_range === null ? null : (options.two_theta_range ?? [0, 180]);
     const [min_radius, max_radius] = two_theta_range === null
         ? [0, 2 / wavelength]
         : (([t_min, t_max]) => {
@@ -219,7 +214,7 @@ export function compute_xrd_pattern(structure, options = {}) {
         }, { real: 0, imag: 0 });
         const sin_theta = Math.sin(theta);
         const cos_theta = Math.cos(theta);
-        const denom_raw = (sin_theta * sin_theta) * Math.abs(cos_theta);
+        const denom_raw = sin_theta * sin_theta * Math.abs(cos_theta);
         // Clamp denominator away from zero to avoid Inf/NaN when 2θ → 180° (cosθ → 0)
         const denom = Math.max(denom_raw, 1e-12);
         const lorentz = (1 + Math.cos(2 * theta) ** 2) / denom;
@@ -253,7 +248,7 @@ export function compute_xrd_pattern(structure, options = {}) {
     if (peaks.size === 0)
         return { x: [], y: [] };
     // Scale intensities so that the max intensity is 100, and filter by scaled tol
-    const max_intensity = Math.max(...Array.from(peaks.values()).map((p) => p.intensity));
+    const max_intensity = Math.max(...Array.from(peaks.values()).map((peak) => peak.intensity));
     const xs = [];
     const ys = [];
     const hkls_out = [];
@@ -270,7 +265,7 @@ export function compute_xrd_pattern(structure, options = {}) {
             const fam = get_unique_families(item.hkls);
             const fam_array = [];
             for (const [repr_key, multiplicity] of fam.entries()) {
-                const repr = repr_key.split(`,`).map((n) => parseInt(n, 10));
+                const repr = repr_key.split(`,`).map((num_str) => parseInt(num_str, 10));
                 fam_array.push({ hkl: repr, multiplicity });
             }
             hkls_out.push(fam_array);
@@ -291,6 +286,7 @@ export function compute_xrd_pattern(structure, options = {}) {
 export async function add_xrd_pattern(content, // File content as string or ArrayBuffer
 filename, // Name of the file (used to detect format)
 wavelength) {
+    // Object with pattern entry or error message
     try {
         // Check if file is a direct XRD data file (.xy, .brml)
         if (is_xrd_data_file(filename)) {
@@ -319,9 +315,7 @@ wavelength) {
             return { error: `Failed to parse ${ext} file: no valid data found. ${hint}` };
         }
         // Otherwise, try to parse as a structure file and compute XRD pattern
-        const text_content = typeof content === `string`
-            ? content
-            : new TextDecoder().decode(content);
+        const text_content = typeof content === `string` ? content : new TextDecoder().decode(content);
         const parsed_structure = parse_any_structure(text_content, filename);
         if (is_crystal(parsed_structure)) {
             const pattern = compute_xrd_pattern(parsed_structure, {

package/dist/xrd/parse.d.ts

@@ -8,6 +8,6 @@ export declare function parse_bruker_raw_file(data: ArrayBuffer): XrdPattern | n
 export declare function parse_brml_file(data: ArrayBuffer): Promise<XrdPattern | null>;
 export declare function parse_xrdml_file(content: string): XrdPattern | null;
 export declare const XRD_FILE_EXTENSIONS: readonly ["xy", "xye", "csv", "dat", "asc", "txt", "ras", "uxd", "gsas", "gsa", "gda", "fxye", "xrdml", "brml", "raw"];
-export type XrdFileExtension = typeof XRD_FILE_EXTENSIONS[number];
+export type XrdFileExtension = (typeof XRD_FILE_EXTENSIONS)[number];
 export declare function parse_xrd_file(content: string | ArrayBuffer, filename: string): Promise<XrdPattern | null>;
 export declare function is_xrd_data_file(filename: string): boolean;

package/dist/xrd/parse.js

@@ -15,7 +15,11 @@ function create_pattern(start, step, intensities) {
     return { x: normalized.x, y: normalized.y };
 }
 // Parse whitespace-separated numbers from text. Used by multiple formats.
-const parse_number_list = (text) => text.trim().split(/\s+/).map(parseFloat).filter((val) => !isNaN(val));
+const parse_number_list = (text) => text
+    .trim()
+    .split(/\s+/)
+    .map(parseFloat)
+    .filter((val) => !isNaN(val));
 // Extract numeric value from header line matching "KEY=VALUE" or "KEY VALUE" pattern.
 // Returns null if not found or not a valid number.
 function extract_header_value(lines, key_pattern) {
@@ -71,7 +75,7 @@ function subsample_preserve_peaks(x_values, y_values, target_points) {
         .map((idx) => ({ idx, y: y_values[idx] }))
         .sort((a, b) => b.y - a.y)
         .slice(0, peak_slots)
-        .map((p) => p.idx);
+        .map((peak) => peak.idx);
     // Uniform sampling (guard against division by zero)
     const uniform_indices = new Set();
     if (uniform_slots > 1) {
@@ -174,14 +178,12 @@ export function parse_ras_file(content) {
     // Detect by: 2-3 values per line, multiple rows, first column monotonically increasing
     // (angles increase during a scan, intensities do not follow this pattern)
     const first_values = parse_number_list(data_lines[0]);
-    const has_column_structure = first_values.length >= 2 && first_values.length <= 3 &&
-        data_lines.length > 1;
+    const has_column_structure = first_values.length >= 2 && first_values.length <= 3 && data_lines.length > 1;
     if (has_column_structure) {
         // Check if first column values are monotonically increasing (characteristic of angle data)
         // Sample a few lines to verify the pattern
         const sample_count = Math.min(5, data_lines.length);
-        let is_monotonic = true;
-        let prev_angle = first_values[0];
+        let [is_monotonic, prev_angle] = [true, first_values[0]];
         for (let idx = 1; idx < sample_count; idx++) {
             const values = parse_number_list(data_lines[idx]);
             if (values.length < 2 || values[0] <= prev_angle) {
@@ -245,7 +247,7 @@ export function parse_gsas_file(content) {
     let bin_type = `CONST`; // CONST, RALF, or others
     let found_bank = false;
     for (const line of lines) {
-        const bank_match = line.match(/BANK\s+\d+\s+(\d+)\s+\d+\s+(\w+)\s+([\d.+-]+)\s+([\d.+-]+)/i);
+        const bank_match = /BANK\s+\d+\s+(\d+)\s+\d+\s+(\w+)\s+([\d.+-]+)\s+([\d.+-]+)/i.exec(line);
         if (bank_match) {
             bin_type = bank_match[2].toUpperCase();
             // For CONST type: BCOEF1 is start*100 (centidegrees), BCOEF2 is step*100
@@ -333,9 +335,9 @@ function parse_bruker_raw_v1(view, bytes) {
         // V1 has ASCII header with scan parameters followed by binary data
         const header_text = String.fromCharCode(...bytes.slice(0, 512));
         // Try to find scan parameters in ASCII header
-        const start_match = header_text.match(/START\s*=\s*([\d.+-]+)/i);
-        const step_match = header_text.match(/STEP\s*=\s*([\d.+-]+)/i);
-        const count_match = header_text.match(/(?:COUNT|POINTS|NPTS)\s*=\s*(\d+)/i);
+        const start_match = /START\s*=\s*([\d.+-]+)/i.exec(header_text);
+        const step_match = /STEP\s*=\s*([\d.+-]+)/i.exec(header_text);
+        const count_match = /(?:COUNT|POINTS|NPTS)\s*=\s*(\d+)/i.exec(header_text);
         const start = start_match ? parseFloat(start_match[1]) : 0;
         const step = step_match ? parseFloat(step_match[1]) : DEFAULT_STEP_SIZE;
         // Find where binary data starts (after header)
@@ -397,9 +399,9 @@ function parse_rigaku_raw_file(data) {
         const bytes = new Uint8Array(data);
         // Try to find ASCII header section with scan parameters
         const header_text = String.fromCharCode(...bytes.slice(0, Math.min(2048, bytes.length)));
-        const start_match = header_text.match(/(?:START|2THETA_START|SCAN_START)\s*[:=]?\s*([\d.+-]+)/i);
-        const step_match = header_text.match(/(?:STEP|STEP_SIZE|SCAN_STEP)\s*[:=]?\s*([\d.+-]+)/i);
-        const count_match = header_text.match(/(?:COUNT|POINTS|NPTS|STEPS)\s*[:=]?\s*(\d+)/i);
+        const start_match = /(?:START|2THETA_START|SCAN_START)\s*[:=]?\s*([\d.+-]+)/i.exec(header_text);
+        const step_match = /(?:STEP|STEP_SIZE|SCAN_STEP)\s*[:=]?\s*([\d.+-]+)/i.exec(header_text);
+        const count_match = /(?:COUNT|POINTS|NPTS|STEPS)\s*[:=]?\s*(\d+)/i.exec(header_text);
         if (!start_match && !step_match && !count_match)
             return null; // Not a recognizable Rigaku format
         const start = start_match ? parseFloat(start_match[1]) : 0;
@@ -457,7 +459,7 @@ function read_float32_array(view, offset, count) {
 // Extracts 2θ and intensity data from the RawData XML within the archive.
 export async function parse_brml_file(data) {
     try {
-        // Lazy import fflate to avoid bundling in SSR (Deno compatibility)
+        // Lazy import fflate to avoid bundling in SSR
         const { unzipSync } = await import(`fflate`);
         const files = unzipSync(new Uint8Array(data));
         // Find the RawData XML file (usually named RawData0.xml or similar)
@@ -703,9 +705,7 @@ export async function parse_xrd_file(content, filename) {
     if (!ext)
         return null;
     // Helper to get text content
-    const get_text = () => typeof content === `string`
-        ? content
-        : new TextDecoder().decode(content);
+    const get_text = () => typeof content === `string` ? content : new TextDecoder().decode(content);
     // Helper to get binary content
     const get_buffer = () => {
         if (typeof content === `string`) {

package/package.json

@@ -1,104 +1,26 @@
 {
   "name": "matterviz",
+  "version": "0.3.4",
   "description": "Interactive visualizations for materials science: periodic tables, 3D structures, MD trajectories, heatmaps, scatter plots.",
-  "author": "Janosh Riebesell <janosh.riebesell@gmail.com>",
-  "homepage": "https://janosh.github.io/matterviz",
-  "repository": "https://github.com/janosh/matterviz",
-  "license": "MIT",
-  "version": "0.3.2",
-  "type": "module",
-  "engines": {
-    "node": ">=24"
-  },
-  "svelte": "./dist/index.js",
-  "bugs": "https://github.com/janosh/matterviz/issues",
-  "scripts": {
-    "dev": "vite dev",
-    "build": "vite build",
-    "preview": "vite preview",
-    "test": "vitest --run && playwright test",
-    "package-dist-assets": "node scripts/package-dist-assets.mjs",
-    "package:dist": "svelte-package && pnpm run package-dist-assets",
-    "package": "pnpm run package:dist",
-    "prepare": "NODE_OPTIONS=--experimental-strip-types svelte-kit sync && pnpm run package:dist",
-    "prepublishOnly": "pnpm run package:dist"
-  },
-  "dependencies": {
-    "@spglib/moyo-wasm": "^0.7.9",
-    "@sveltejs/kit": "2.53.4",
-    "@threlte/core": "^8.4.1",
-    "@threlte/extras": "^9.8.1",
-    "@types/d3-force": "^3.0.10",
-    "@types/d3-hierarchy": "^3.1.7",
-    "@types/js-yaml": "^4.0.9",
-    "d3": "^7.9.0",
-    "d3-array": "^3.2.4",
-    "d3-color": "^3.1.0",
-    "d3-force": "^3.0.0",
-    "d3-format": "^3.1.2",
-    "d3-hierarchy": "^3.1.2",
-    "d3-interpolate-path": "^2.3.0",
-    "d3-scale": "^4.0.2",
-    "d3-scale-chromatic": "^3.1.0",
-    "d3-shape": "^3.2.0",
-    "fflate": "^0.8.2",
-    "h5wasm": "^0.9.0",
-    "highlight.js": "^11.11.1",
-    "js-yaml": "^4.1.1",
-    "svelte": "5.52.0",
-    "svelte-multiselect": "^11.6.2",
-    "svelte-toc": "^0.6.3",
-    "three": "^0.183.2"
-  },
-  "devDependencies": {
-    "@playwright/test": "^1.58.2",
-    "@rollup/plugin-yaml": "^4.1.2",
-    "@stylistic/eslint-plugin": "^5.9.0",
-    "@sveltejs/adapter-static": "3.0.10",
-    "@sveltejs/package": "^2.5.7",
-    "@sveltejs/vite-plugin-svelte": "^6.2.4",
-    "@types/d3-array": "^3.2.2",
-    "@types/d3-color": "^3.1.3",
-    "@types/d3-format": "^3.0.4",
-    "@types/d3-interpolate-path": "^2.0.3",
-    "@types/d3-scale": "^4.0.9",
-    "@types/d3-scale-chromatic": "^3.1.0",
-    "@types/d3-shape": "^3.1.8",
-    "@types/d3-time-format": "^4.0.3",
-    "@types/three": "^0.183.1",
-    "@typescript/native-preview": "7.0.0-dev.20260304.1",
-    "@vitest/coverage-v8": "^4.0.18",
-    "@wooorm/starry-night": "^3.9.0",
-    "abstract-syntax-tree": "^2.22.0",
-    "d3-time-format": "^4.1.0",
-    "eslint": "^10.0.2",
-    "eslint-plugin-svelte": "^3.15.0",
-    "happy-dom": "^20.8.3",
-    "matterviz-wasm": "^0.0.7",
-    "mdsvex": "^0.12.6",
-    "rehype-katex": "^7.0.1",
-    "remark-math": "3.0.1",
-    "svelte-check-rs": "0.9.5",
-    "svelte-preprocess": "^6.0.3",
-    "svelte2tsx": "^0.7.51",
-    "typedoc": "^0.28.17",
-    "typedoc-plugin-markdown": "^4.10.0",
-    "typescript": "5.9.3",
-    "typescript-eslint": "^8.56.1",
-    "vite": "^7.3.1",
-    "vitest": "^4.0.18"
-  },
   "keywords": [
-    "svelte",
-    "periodic table",
     "chemistry",
+    "component",
     "data viz",
+    "periodic table",
     "plotting",
-    "component"
+    "svelte"
   ],
-  "publishConfig": {
-    "access": "public"
-  },
+  "homepage": "https://janosh.github.io/matterviz",
+  "bugs": "https://github.com/janosh/matterviz/issues",
+  "license": "MIT",
+  "author": "Janosh Riebesell <janosh.riebesell@gmail.com>",
+  "repository": "https://github.com/janosh/matterviz",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "svelte": "./dist/index.js",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -211,7 +133,7 @@
     },
     "./theme/themes": {
       "types": "./dist/theme/themes.d.ts",
-      "default": "./dist/theme/themes.js"
+      "default": "./dist/theme/themes.mjs"
     },
     "./tooltip": {
       "types": "./dist/tooltip/index.d.ts",
@@ -235,13 +157,87 @@
     },
     "./xrd/atomic_scattering_params.json": "./dist/xrd/atomic_scattering_params.json"
   },
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "pnpm": {
-    "allowBuilds": [
-      "esbuild"
-    ]
-  }
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "vp dev",
+    "build": "vp build",
+    "preview": "vp preview",
+    "test": "vp test --run && playwright test",
+    "check": "vp check",
+    "lint": "vp lint",
+    "fmt": "vp fmt --write",
+    "package-dist-assets": "NODE_OPTIONS=--experimental-strip-types node scripts/package-dist-assets.ts",
+    "package:dist": "svelte-package && npm run package-dist-assets",
+    "package": "npm run package:dist",
+    "prepare": "NODE_OPTIONS=--experimental-strip-types svelte-kit sync && npm run package:dist",
+    "prepublishOnly": "npm run package:dist"
+  },
+  "dependencies": {
+    "@spglib/moyo-wasm": "^0.7.9",
+    "@sveltejs/kit": "2.58.0",
+    "@threlte/core": "^8.5.10",
+    "@threlte/extras": "^9.15.0",
+    "@types/d3-hierarchy": "^3.1.7",
+    "@types/js-yaml": "^4.0.9",
+    "d3": "^7.9.0",
+    "d3-array": "^3.2.4",
+    "d3-color": "^3.1.0",
+    "d3-format": "^3.1.2",
+    "d3-hierarchy": "^3.1.2",
+    "d3-interpolate-path": "^2.3.0",
+    "d3-scale": "^4.0.2",
+    "d3-scale-chromatic": "^3.1.0",
+    "d3-shape": "^3.2.0",
+    "dompurify": "^3.4.1",
+    "fflate": "^0.8.2",
+    "h5wasm": "^0.10.1",
+    "js-yaml": "^4.1.1",
+    "svelte-multiselect": "^11.7.0",
+    "three": "^0.184.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.59.1",
+    "@rollup/plugin-yaml": "^4.1.2",
+    "@sveltejs/adapter-static": "3.0.10",
+    "@sveltejs/package": "^2.5.7",
+    "@sveltejs/vite-plugin-svelte": "^7.0.0",
+    "@types/d3-array": "^3.2.2",
+    "@types/d3-color": "^3.1.3",
+    "@types/d3-format": "^3.0.4",
+    "@types/d3-interpolate-path": "^2.0.3",
+    "@types/d3-scale": "^4.0.9",
+    "@types/d3-scale-chromatic": "^3.1.0",
+    "@types/d3-shape": "^3.1.8",
+    "@types/d3-time-format": "^4.0.3",
+    "@types/node": "^25.6.0",
+    "@types/three": "^0.184.0",
+    "@typescript/native-preview": "7.0.0-dev.20260429.1",
+    "@vitest/coverage-v8": "4.1.5",
+    "@wooorm/starry-night": "^3.9.0",
+    "d3-time-format": "^4.1.0",
+    "happy-dom": "^20.9.0",
+    "matterviz-wasm": "^0.0.10",
+    "mdsvex": "^0.12.7",
+    "rehype-katex": "^7.0.1",
+    "remark-math": "3.0.1",
+    "svelte": "5.55.5",
+    "svelte-check-rs": "0.9.7",
+    "typescript": "6.0.3",
+    "vite": "npm:@voidzero-dev/vite-plus-core@^0.1.20",
+    "vite-plus": "latest",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@^0.1.20"
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "overrides": {
+    "vite": "npm:@voidzero-dev/vite-plus-core@^0.1.20",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@^0.1.20"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "packageManager": "pnpm@10.33.0"
 }

package/readme.md

@@ -55,7 +55,7 @@ Rich element pages with physical properties, electron configurations, Bohr atom
 ## 🔨   Installation
 
 ```sh
-pnpm add -D matterviz
+npm add -D matterviz
 ```
 
 ## 📙   Usage