matterviz 0.3.6 → 0.4.0

package/dist/xrd/broadening.js

@@ -0,0 +1,97 @@
+const LOG_2 = Math.log(2);
+export const DEFAULT_BROADENING = {
+    U: 0.04,
+    V: -0.02,
+    W: 0.02,
+    shape_factor: 0.5, // Mixed Gaussian/Lorentzian
+};
+// Calculates the Full Width at Half Maximum (FWHM) at a given theta angle
+// using the Caglioti formula: FWHM^2 = U * tan^2(theta) + V * tan(theta) + W
+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;
+    // Ensure non-negative squared width
+    return Math.sqrt(Math.max(1e-9, fwhm_sq));
+}
+// 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));
+    const exponent = -((x - x0) ** 2) / (2 * sigma ** 2);
+    return prefactor * Math.exp(exponent);
+}
+// 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);
+    const denominator = 1 + ((x - x0) / gamma) ** 2;
+    return prefactor / denominator;
+}
+// Pseudo-Voigt profile (linear combination of Gaussian and Lorentzian).
+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);
+}
+// 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`);
+    }
+    const [min_angle, max_angle] = range;
+    if (!Number.isFinite(min_angle) || !Number.isFinite(max_angle) || max_angle <= min_angle) {
+        throw new Error(`range must be finite and max > min`);
+    }
+    const { U, V, W, shape_factor } = params;
+    // Create x grid
+    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 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 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;
+        // Skip peaks outside range (with some buffer)
+        if (x0 < min_angle - 5 || x0 > max_angle + 5)
+            continue;
+        const fwhm = caglioti_fwhm(x0, U, V, W);
+        // Define window for calculation (e.g. +/- 10 * FWHM or fixed reasonable range)
+        // Lorentzian tails are long, so we need a decent window.
+        // 20 * FWHM is usually sufficient for visual purposes.
+        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 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[]
+    // We don't map hkls to continuous profile points usually,
+    // or we could try to map them to the nearest peak, but for now leave undefined.
+    return { x: Array.from(xs), y: Array.from(ys) };
+}

package/dist/xrd/calc-xrd.d.ts

@@ -0,0 +1,37 @@
+import type { Crystal } from '../structure/index';
+import type { PatternEntry, XrdOptions, XrdPattern } from './index';
+export declare const WAVELENGTHS: {
+    readonly CuKa: 1.54184;
+    readonly CuKa2: 1.54439;
+    readonly CuKa1: 1.54056;
+    readonly CuKb1: 1.39222;
+    readonly MoKa: 0.71073;
+    readonly MoKa2: 0.71359;
+    readonly MoKa1: 0.7093;
+    readonly MoKb1: 0.63229;
+    readonly CrKa: 2.291;
+    readonly CrKa2: 2.29361;
+    readonly CrKa1: 2.2897;
+    readonly CrKb1: 2.08487;
+    readonly FeKa: 1.93735;
+    readonly FeKa2: 1.93998;
+    readonly FeKa1: 1.93604;
+    readonly FeKb1: 1.75661;
+    readonly CoKa: 1.79026;
+    readonly CoKa2: 1.79285;
+    readonly CoKa1: 1.78896;
+    readonly CoKb1: 1.63079;
+    readonly AgKa: 0.560885;
+    readonly AgKa2: 0.563813;
+    readonly AgKa1: 0.559421;
+    readonly AgKb1: 0.497082;
+};
+export type RadiationKey = keyof typeof WAVELENGTHS;
+export declare function compute_xrd_pattern(structure: Crystal, options?: XrdOptions): XrdPattern;
+export declare function add_xrd_pattern(content: string | ArrayBufferLike, // File content as string or ArrayBuffer
+filename: string, // Name of the file (used to detect format)
+wavelength: number | null): Promise<{
+    pattern?: PatternEntry;
+    error?: string;
+}>;
+export declare const AVAILABLE_RADIATION: RadiationKey[];

package/dist/xrd/calc-xrd.js

@@ -0,0 +1,339 @@
+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
+import ATOMIC_SCATTERING_PARAMS from './atomic_scattering_params.json' with { type: 'json' };
+import { is_xrd_data_file, parse_xrd_file } from './parse';
+import { to_error } from '../utils';
+// XRD wavelengths in Angstrom (Å)
+export const WAVELENGTHS = {
+    CuKa: 1.54184,
+    CuKa2: 1.54439,
+    CuKa1: 1.54056,
+    CuKb1: 1.39222,
+    MoKa: 0.71073,
+    MoKa2: 0.71359,
+    MoKa1: 0.7093,
+    MoKb1: 0.63229,
+    CrKa: 2.291,
+    CrKa2: 2.29361,
+    CrKa1: 2.2897,
+    CrKb1: 2.08487,
+    FeKa: 1.93735,
+    FeKa2: 1.93998,
+    FeKa1: 1.93604,
+    FeKb1: 1.75661,
+    CoKa: 1.79026,
+    CoKa2: 1.79285,
+    CoKa1: 1.78896,
+    CoKb1: 1.63079,
+    AgKa: 0.560885,
+    AgKa2: 0.563813,
+    AgKa1: 0.559421,
+    AgKb1: 0.497082,
+};
+// Type guard to safely check if a string is a valid RadiationKey
+const is_radiation_key = (key) => key in WAVELENGTHS;
+// Tolerances from pymatgen.analysis.diffraction.core
+const TWO_THETA_TOL = 1e-5;
+const SCALED_INTENSITY_TOL = 1e-3;
+const ELEMENT_Z = Object.fromEntries(element_data.map((entry) => [entry.symbol, entry.number]));
+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((val) => Math.abs(val)).sort((x, y) => x - y);
+        const key = abs_sorted.join(`,`);
+        const list = key_map.get(key);
+        if (list)
+            list.push(hkl);
+        else
+            key_map.set(key, [hkl]);
+    }
+    // Choose representative with max tuple (lexicographic) like numpy max(val)
+    const family_map = new Map();
+    for (const group of key_map.values()) {
+        let representative = group[0];
+        for (const candidate of group) {
+            const better = candidate[0] > representative[0] ||
+                (candidate[0] === representative[0] &&
+                    (candidate[1] > representative[1] ||
+                        (candidate[1] === representative[1] && candidate[2] > representative[2])));
+            if (better)
+                representative = candidate;
+        }
+        family_map.set(representative.join(`,`), group.length);
+    }
+    return family_map;
+}
+function compute_reciprocal_lattice_rows(structure) {
+    // For row-wise lattice matrix A (rows are a, b, c), reciprocal rows are inv(A)^T
+    const direct = structure.lattice.matrix;
+    const inv = math.matrix_inverse_3x3(direct);
+    const recip = math.transpose_3x3_matrix(inv);
+    return recip;
+}
+function enumerate_reciprocal_points(recip_rows, direct_rows, max_radius, min_radius) {
+    const recip_b1 = recip_rows[0];
+    const recip_b2 = recip_rows[1];
+    const recip_b3 = recip_rows[2];
+    // Exact index bound: |h_i| = |g·a_i| ≤ R·|a_i| (since a_i·b_j = δ_ij). Bounds from
+    // reciprocal-row norms (R/|b_i| + 2) undercount for skewed cells, dropping reflections.
+    const [h_max, k_max, l_max] = direct_rows.map((row) => Math.ceil(max_radius * Math.hypot(...row)) + 1);
+    // Safety cap to avoid pathological enumeration volume
+    const CAP = 512;
+    if (Math.max(h_max, k_max, l_max) > CAP) {
+        throw new Error(`enumerate_reciprocal_points: max(h,k,l) exceeds cap ${CAP}`);
+    }
+    const points = [];
+    for (let h_idx = -h_max; h_idx <= h_max; h_idx++) {
+        for (let k_idx = -k_max; k_idx <= k_max; k_idx++) {
+            for (let l_idx = -l_max; l_idx <= l_max; l_idx++) {
+                if (h_idx === 0 && k_idx === 0 && l_idx === 0)
+                    continue;
+                const h_mul_b1 = math.scale(recip_b1, h_idx);
+                const k_mul_b2 = math.scale(recip_b2, k_idx);
+                const l_mul_b3 = math.scale(recip_b3, l_idx);
+                const g_vec = math.add(h_mul_b1, k_mul_b2, l_mul_b3);
+                const g_norm = Math.hypot(...g_vec);
+                if (g_norm < min_radius || g_norm > max_radius)
+                    continue;
+                points.push({ hkl: [h_idx, k_idx, l_idx], g_norm });
+            }
+        }
+    }
+    // Sort by (g_norm asc, -h, -k, -l) to mimic pymatgen ordering
+    points.sort((p1, p2) => p1.g_norm !== p2.g_norm
+        ? p1.g_norm - p2.g_norm
+        : p2.hkl[0] !== p1.hkl[0]
+            ? p2.hkl[0] - p1.hkl[0]
+            : p2.hkl[1] !== p1.hkl[1]
+                ? p2.hkl[1] - p1.hkl[1]
+                : p2.hkl[2] - p1.hkl[2]);
+    return points;
+}
+export function compute_xrd_pattern(structure, options = {}) {
+    const wl_input = options.wavelength ?? `CuKa`;
+    let wavelength;
+    if (typeof wl_input === `number`) {
+        if (!Number.isFinite(wl_input) || wl_input <= 0) {
+            throw new Error(`Invalid wavelength: ${wl_input}. Must be a finite positive number.`);
+        }
+        wavelength = wl_input;
+    }
+    else {
+        if (!is_radiation_key(wl_input)) {
+            throw new Error(`Unknown radiation key: ${wl_input}`);
+        }
+        wavelength = WAVELENGTHS[wl_input];
+    }
+    // Symmetry refinement (symprec > 0) is not implemented in TS version.
+    // Option retained for API parity.
+    // 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 [min_radius, max_radius] = two_theta_range === null
+        ? [0, 2 / wavelength]
+        : (([t_min, t_max]) => {
+            const r_min = (2 * Math.sin((t_min / 2) * (Math.PI / 180))) / wavelength;
+            const r_max = (2 * Math.sin((t_max / 2) * (Math.PI / 180))) / wavelength;
+            return [r_min, r_max];
+        })(two_theta_range);
+    const recip_points = enumerate_reciprocal_points(recip_rows, structure.lattice.matrix, max_radius, min_radius);
+    const coeffs = [];
+    const frac_coords = [];
+    const occus = [];
+    const dw_factors = [];
+    const debye_waller_factors = options.debye_waller_factors ?? {};
+    for (const site of structure.sites) {
+        for (const species of site.species) {
+            const element_symbol = species.element;
+            if (ELEMENT_Z[element_symbol] === undefined) {
+                throw new Error(`Unknown atomic number for element ${element_symbol}`);
+            }
+            const raw_coeff = ATOMIC_SCATTERING_PARAMS[element_symbol];
+            if (!raw_coeff) {
+                throw new Error(`No atomic scattering coefficients for ${element_symbol}. Extend ATOMIC_SCATTERING_PARAMS.`);
+            }
+            let coeff_entry;
+            if (Array.isArray(raw_coeff)) {
+                const a_arr = raw_coeff.map(([a]) => a);
+                const b_arr = raw_coeff.map(([_, b]) => b);
+                coeff_entry = { a: a_arr, b: b_arr, z: ELEMENT_Z[element_symbol] };
+            }
+            else {
+                coeff_entry = { a: raw_coeff.a.slice(), b: raw_coeff.b.slice(), c: raw_coeff.c };
+            }
+            coeffs.push(coeff_entry);
+            frac_coords.push(site.abc);
+            occus.push(species.occu);
+            dw_factors.push(debye_waller_factors[element_symbol] ?? 0);
+        }
+    }
+    // Accumulate peaks by merging two_thetas within tolerance
+    const peaks = new Map();
+    const two_thetas = [];
+    const merge_tol = options.peak_merge_tol ?? TWO_THETA_TOL;
+    const scaled_tol = options.scaled_intensity_tol ?? SCALED_INTENSITY_TOL;
+    for (const entry of recip_points) {
+        const hkl = entry.hkl;
+        const g_norm = entry.g_norm;
+        if (g_norm === 0)
+            continue;
+        const asin_arg = (wavelength * g_norm) / 2;
+        // asin domain can exceed 1 by FP error — clamp to avoid NaN
+        const clamped_asin_arg = Math.min(1, Math.max(-1, asin_arg));
+        const theta = Math.asin(clamped_asin_arg);
+        const sin_theta_over_lambda = g_norm / 2;
+        const sin_theta_over_lambda_sq = sin_theta_over_lambda * sin_theta_over_lambda;
+        // g.r for all fractional coords
+        const g_dot_r_all = frac_coords.map((frac_coord) => math.dot(frac_coord, hkl));
+        // Atomic scattering factors (vectorized style)
+        const f_scattering = coeffs.map((coeff_entry) => {
+            const { a: a_arr, b: b_arr, z } = coeff_entry;
+            const num_terms = Math.min(a_arr.length, b_arr.length);
+            const sum_terms = a_arr
+                .slice(0, num_terms)
+                .reduce((sum, a_i, term_idx) => sum + a_i * Math.exp(-b_arr[term_idx] * sin_theta_over_lambda_sq), 0);
+            // pymatgen-style fitted params: f = Z − 41.78214·s²·Σ aᵢ·exp(−bᵢ·s²)
+            if (z !== undefined)
+                return z - 41.78214 * sin_theta_over_lambda_sq * sum_terms;
+            return sum_terms + (coeff_entry.c ?? 0);
+        });
+        const dw_corr = dw_factors.map((dw_b) => Math.exp(-dw_b * sin_theta_over_lambda_sq));
+        // Structure factor sum: sum(fs * occu * exp(2πi g·r) * DW)
+        const { real: f_real, imag: f_imag } = f_scattering.reduce((acc, fs, idx) => {
+            const phase = 2 * Math.PI * g_dot_r_all[idx];
+            const weight = fs * occus[idx] * dw_corr[idx];
+            const real = acc.real + weight * Math.cos(phase);
+            const imag = acc.imag + weight * Math.sin(phase);
+            return { real, imag };
+        }, { 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);
+        // 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;
+        const intensity_hkl = (f_real * f_real + f_imag * f_imag) * lorentz;
+        const two_theta = math.to_degrees(2 * theta);
+        // Use (h, k, l) always. For hexagonal systems, pymatgen presents Miller–Bravais (h, k, i, l),
+        // but downstream components expect 3-index HKL. Keep 3-index form to match types/consumers.
+        const hkl_to_store = [hkl[0], hkl[1], hkl[2]];
+        // Merge peaks within tolerance
+        let found_index = null;
+        for (let idx = 0; idx < two_thetas.length; idx++) {
+            if (Math.abs(two_thetas[idx] - two_theta) < merge_tol) {
+                found_index = idx;
+                break;
+            }
+        }
+        if (found_index !== null) {
+            const key = two_thetas[found_index];
+            const item = peaks.get(key);
+            if (item) {
+                item.intensity += intensity_hkl;
+                item.hkls.push(hkl_to_store);
+            }
+        }
+        else {
+            const d_hkl = 1 / g_norm;
+            peaks.set(two_theta, { intensity: intensity_hkl, hkls: [hkl_to_store], d_hkl });
+            two_thetas.push(two_theta);
+        }
+    }
+    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((peak) => peak.intensity));
+    const xs = [];
+    const ys = [];
+    const hkls_out = [];
+    const d_out = [];
+    const sorted_two_thetas = Array.from(peaks.keys()).sort((a, b) => a - b);
+    for (const angle of sorted_two_thetas) {
+        const item = peaks.get(angle);
+        if (!item)
+            continue;
+        const scaled_val = (item.intensity / max_intensity) * 100;
+        if (scaled_val > scaled_tol) {
+            xs.push(angle);
+            ys.push(item.intensity);
+            const fam = get_unique_families(item.hkls);
+            const fam_array = [];
+            for (const [repr_key, multiplicity] of fam.entries()) {
+                const repr = repr_key.split(`,`).map((num_str) => parseInt(num_str, 10));
+                fam_array.push({ hkl: repr, multiplicity });
+            }
+            hkls_out.push(fam_array);
+            d_out.push(item.d_hkl);
+        }
+    }
+    // Final scaling if requested
+    if (options.scaled ?? true) {
+        const max_y = Math.max(1, ...ys);
+        for (let idx = 0; idx < ys.length; idx++)
+            ys[idx] = (ys[idx] / max_y) * 100;
+    }
+    return { x: xs, y: ys, hkls: hkls_out, d_hkls: d_out };
+}
+// Process dropped file content and return an XRD pattern.
+// Supports both direct XRD data files (.xy, .brml) and structure files
+// (which are used to compute theoretical XRD patterns).
+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)) {
+            // Convert ArrayBufferLike to ArrayBuffer if needed (handles SharedArrayBuffer)
+            let buffer_content;
+            if (typeof content === `string`) {
+                buffer_content = content;
+            }
+            else {
+                buffer_content =
+                    content instanceof ArrayBuffer ? content : new Uint8Array(content).slice().buffer;
+            }
+            const pattern = await parse_xrd_file(buffer_content, filename);
+            if (pattern && pattern.x.length > 0) {
+                return { pattern: { label: filename || `XRD data`, pattern } };
+            }
+            // Get base extension (strip .gz if present) for error message
+            const base_name = filename.toLowerCase().replace(/\.gz$/, ``);
+            // truthiness (not ??) so an empty extension (filename ending in `.`) falls back to XRD
+            const last_part = base_name.split(`.`).pop();
+            const ext = last_part ? last_part.toUpperCase() : `XRD`;
+            const format_hints = {
+                XY: `Expected 2-column format: "2theta intensity" (space/tab/comma separated)`,
+                XYE: `Expected 3-column format: "2theta intensity error" (space/tab/comma separated)`,
+                BRML: `Expected Bruker RAW/BRML ZIP archive with RawData XML`,
+                XRDML: `Expected PANalytical XRDML format with dataPoints section`,
+            };
+            const hint = format_hints[ext] || `Check file format and encoding`;
+            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 parsed_structure = parse_any_structure(text_content, filename);
+        if (is_crystal(parsed_structure)) {
+            const pattern = compute_xrd_pattern(parsed_structure, {
+                wavelength: typeof wavelength === `number` ? wavelength : undefined,
+            });
+            return { pattern: { label: filename || `Dropped structure`, pattern } };
+        }
+        return {
+            error: `Cannot compute XRD: structure must have a lattice and atomic sites. ` +
+                `Supported formats: CIF, POSCAR, JSON, XYZ`,
+        };
+    }
+    catch (exc) {
+        return {
+            error: `Failed to compute XRD pattern: ${to_error(exc).message}`,
+        };
+    }
+}
+export const AVAILABLE_RADIATION = Object.keys(WAVELENGTHS);

package/dist/xrd/index.d.ts

@@ -0,0 +1,37 @@
+import type { CompositionType } from '../composition';
+import type { Vec3 } from '../math';
+import type { RadiationKey } from './calc-xrd';
+export * from './broadening';
+export * from './calc-xrd';
+export * from './parse';
+export { default as XrdPlot } from './XrdPlot.svelte';
+export type Hkl = Vec3;
+export type HklObj = {
+    hkl: Hkl;
+    multiplicity?: number;
+};
+export type RecipPoint = {
+    hkl: Hkl;
+    g_norm: number;
+};
+export type HklFormat = `compact` | `full` | null;
+export type XrdPattern = {
+    x: number[];
+    y: number[];
+    hkls?: HklObj[][];
+    d_hkls?: number[];
+};
+export type XrdOptions = {
+    wavelength?: number | RadiationKey;
+    symprec?: number;
+    debye_waller_factors?: CompositionType;
+    scaled?: boolean;
+    two_theta_range?: [number, number] | null;
+    peak_merge_tol?: number;
+    scaled_intensity_tol?: number;
+};
+export interface PatternEntry {
+    label: string;
+    pattern: XrdPattern;
+    color?: string;
+}

package/dist/xrd/index.js

@@ -0,0 +1,4 @@
+export * from './broadening';
+export * from './calc-xrd';
+export * from './parse';
+export { default as XrdPlot } from './XrdPlot.svelte';

package/dist/xrd/parse.d.ts

@@ -0,0 +1,13 @@
+import type { XrdPattern } from './index';
+export declare function parse_xy_file(content: string): XrdPattern | null;
+export declare function parse_xye_file(content: string): XrdPattern | null;
+export declare function parse_ras_file(content: string): XrdPattern | null;
+export declare function parse_uxd_file(content: string): XrdPattern | null;
+export declare function parse_gsas_file(content: string): XrdPattern | null;
+export declare function parse_bruker_raw_file(data: ArrayBuffer): XrdPattern | null;
+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 declare function parse_xrd_file(content: string | ArrayBuffer, filename: string): Promise<XrdPattern | null>;
+export declare function is_xrd_data_file(filename: string): boolean;