matsci-parse 0.2.0 → 0.3.1

package/dist/main.js

@@ -1,42 +1,61 @@
-class x {
-  constructor(t, e, i = {}) {
-    this.speciesIndex = t, this.cart = e, this.props = i;
+class S {
+  constructor(s, e, t = {}) {
+    this.speciesIndex = s, this.cart = e, this.props = t;
   }
-  getProp(t) {
-    return this.props[t];
+  getProp(s) {
+    return this.props[s];
   }
-  setProp(t, e) {
-    this.props[t] = e;
+  setProp(s, e) {
+    this.props[s] = e;
   }
 }
-function C(s) {
-  return s.sites.some((t) => Array.isArray(t.props.selectiveDynamics));
+function B(i) {
+  return i.sites.some((s) => Array.isArray(s.props.selectiveDynamics));
 }
-function F(s) {
-  return s * Math.PI / 180;
+function M(i) {
+  return i * Math.PI / 180;
 }
-function M(s, t) {
-  return s.map(
-    (e) => e[0] * t[0] + e[1] * t[1] + e[2] * t[2]
+function O(i, s) {
+  return i.map(
+    (e) => e[0] * s[0] + e[1] * s[1] + e[2] * s[2]
   );
 }
-function P(s, t, e, i, o, n) {
-  const a = F(i), h = F(o), l = F(n), p = [s, 0, 0], f = [
-    t * Math.cos(l),
-    t * Math.sin(l),
+function k(i, s, e, t, m, o) {
+  const n = M(t), u = M(m), a = M(o), b = [i, 0, 0], h = [
+    s * Math.cos(a),
+    s * Math.sin(a),
     0
-  ], r = e * Math.cos(h), u = e * (Math.cos(a) - Math.cos(h) * Math.cos(l)) / Math.sin(l), g = Math.sqrt(e * e - r * r - u * u);
-  return [p, f, [r, u, g]];
+  ], r = e * Math.cos(u), l = e * (Math.cos(n) - Math.cos(u) * Math.cos(a)) / Math.sin(a), y = Math.sqrt(e * e - r * r - l * l);
+  return [b, h, [r, l, y]];
 }
-function O(s, t) {
-  const [e, i, o] = t;
+function U(i, s) {
+  const [e, t, m] = s;
   return [
-    s[0] * e[0] + s[1] * i[0] + s[2] * o[0],
-    s[0] * e[1] + s[1] * i[1] + s[2] * o[1],
-    s[0] * e[2] + s[1] * i[2] + s[2] * o[2]
+    i[0] * e[0] + i[1] * t[0] + i[2] * m[0],
+    i[0] * e[1] + i[1] * t[1] + i[2] * m[1],
+    i[0] * e[2] + i[1] * t[2] + i[2] * m[2]
   ];
 }
-class S {
+function X(i) {
+  const [[s, e, t], [m, o, n], [u, a, b]] = i, h = o * b - n * a, r = -(m * b - n * u), l = m * a - o * u, y = -(e * b - t * a), c = s * b - t * u, p = -(s * a - e * u), N = e * n - t * o, g = -(s * n - t * m), _ = s * o - e * m, v = s * h + e * r + t * l;
+  if (Math.abs(v) < 1e-12)
+    throw new Error("Matrix is singular and cannot be inverted");
+  const f = 1 / v;
+  return [
+    [h * f, y * f, N * f],
+    [r * f, c * f, g * f],
+    [l * f, p * f, _ * f]
+  ];
+}
+function J(i, s) {
+  const [e, t, m] = s, o = [
+    [e[0], t[0], m[0]],
+    [e[1], t[1], m[1]],
+    [e[2], t[2], m[2]]
+  ], n = X(o);
+  return O(n, i);
+}
+class F {
   /**
    * Creates a new CrystalStructure.
    *
@@ -48,11 +67,11 @@ class S {
    * @throws Will throw an error if lattice is not 3x3, species is not an array of strings, or sites are invalid
    */
   constructor({
-    lattice: t,
+    lattice: s,
     species: e,
-    sites: i
+    sites: t
   }) {
-    this.lattice = this._validateLattice(t), this.species = this._validateSpecies(e), this.sites = this._validateSites(i);
+    this.lattice = this._validateLattice(s), this.species = this._validateSpecies(e), this.sites = this._validateSites(t);
   }
   // ---------- Simple methods ----------
   /** Number of sites in the structure */
@@ -63,22 +82,22 @@ class S {
    * Returns the site at the specified index.
    * @param i - Site index
    */
-  site(t) {
-    return this.sites[t];
+  site(s) {
+    return this.sites[s];
   }
   /**
    * Returns the Cartesian coordinates of a site.
    * @param i - Site index
    */
-  cartCoords(t) {
-    return this.sites[t].cart;
+  cartCoords(s) {
+    return this.sites[s].cart;
   }
   /**
    * Returns the chemical species of a site.
    * @param i - Site index
    */
-  siteSpecies(t) {
-    return this.species[this.sites[t].speciesIndex];
+  siteSpecies(s) {
+    return this.species[this.sites[s].speciesIndex];
   }
   /** Returns the array of elements (species) in the structure */
   get elements() {
@@ -92,11 +111,11 @@ class S {
    * @param cart - Cartesian coordinates of the new site
    * @param position - Optional index at which to insert the site. Defaults to appending at the end.
    */
-  addSite(t, e, i) {
-    let o = this.species.indexOf(t);
-    o === -1 && (this.species.push(t), o = this.species.length - 1);
-    const n = new x(o, e);
-    i === void 0 || i >= this.sites.length ? this.sites.push(n) : i < 0 ? this.sites.unshift(n) : this.sites.splice(i, 0, n);
+  addSite(s, e, t) {
+    let m = this.species.indexOf(s);
+    m === -1 && (this.species.push(s), m = this.species.length - 1);
+    const o = new S(m, e);
+    t === void 0 || t >= this.sites.length ? this.sites.push(o) : t < 0 ? this.sites.unshift(o) : this.sites.splice(t, 0, o);
   }
   /**
    * Removes a site from the crystal.
@@ -107,14 +126,14 @@ class S {
    *
    * @throws Will throw an error if index is out of bounds
    */
-  removeSite(t) {
-    if (t < 0 || t >= this.sites.length)
+  removeSite(s) {
+    if (s < 0 || s >= this.sites.length)
       throw new Error("siteIndex out of bounds");
-    const i = this.sites.splice(t, 1)[0].speciesIndex;
+    const t = this.sites.splice(s, 1)[0].speciesIndex;
     this.sites.some(
-      (n) => n.speciesIndex === i
-    ) || (this.species.splice(i, 1), this.sites.forEach((n) => {
-      n.speciesIndex > i && (n.speciesIndex -= 1);
+      (o) => o.speciesIndex === t
+    ) || (this.species.splice(t, 1), this.sites.forEach((o) => {
+      o.speciesIndex > t && (o.speciesIndex -= 1);
     }));
   }
   /**
@@ -127,11 +146,11 @@ class S {
    *
    * @throws Will throw an error if siteIndex is out of bounds
    */
-  replaceSite(t, e) {
-    if (t < 0 || t >= this.sites.length)
+  replaceSite(s, e) {
+    if (s < 0 || s >= this.sites.length)
       throw new Error("siteIndex out of bounds");
-    const i = [...this.sites[t].cart];
-    this.removeSite(t), this.addSite(e, i, t);
+    const t = [...this.sites[s].cart];
+    this.removeSite(s), this.addSite(e, t, s);
   }
   /**
    * Returns a new CrystalStructure transformed by a linear matrix.
@@ -146,39 +165,39 @@ class S {
    *
    * @throws Will throw an error if scale is not a number, a 3-element array, or a 3x3 matrix
    */
-  applyLatticeTransformation(t) {
+  applyLatticeTransformation(s) {
     let e;
-    if (typeof t == "number")
+    if (typeof s == "number")
       e = [
-        [t, 0, 0],
-        [0, t, 0],
-        [0, 0, t]
+        [s, 0, 0],
+        [0, s, 0],
+        [0, 0, s]
       ];
-    else if (Array.isArray(t) && t.length === 3 && t.every((n) => typeof n == "number"))
+    else if (Array.isArray(s) && s.length === 3 && s.every((o) => typeof o == "number"))
       e = [
-        [t[0], 0, 0],
-        [0, t[1], 0],
-        [0, 0, t[2]]
+        [s[0], 0, 0],
+        [0, s[1], 0],
+        [0, 0, s[2]]
       ];
-    else if (Array.isArray(t) && t.length === 3 && t.every((n) => Array.isArray(n) && n.length === 3))
-      e = t;
+    else if (Array.isArray(s) && s.length === 3 && s.every((o) => Array.isArray(o) && o.length === 3))
+      e = s;
     else
       throw new Error(
         "Scale must be a number, a 3-element array, or a 3x3 matrix"
       );
-    const i = this.lattice.map(
-      (n) => M(e, n)
-    ), o = this.sites.map((n) => {
-      const a = M(
+    const t = this.lattice.map(
+      (o) => O(e, o)
+    ), m = this.sites.map((o) => {
+      const n = O(
         e,
-        n.cart
+        o.cart
       );
-      return new x(n.speciesIndex, a, n.props);
+      return new S(o.speciesIndex, n, o.props);
     });
-    return new S({
-      lattice: i,
+    return new F({
+      lattice: t,
       species: [...this.species],
-      sites: o
+      sites: m
     });
   }
   // ---------- Internal validation ----------
@@ -186,35 +205,35 @@ class S {
    * Validates that the lattice is a 3x3 array of Cartesian vectors.
    * @throws Will throw an error if lattice is invalid
    */
-  _validateLattice(t) {
-    if (!Array.isArray(t) || t.length !== 3)
+  _validateLattice(s) {
+    if (!Array.isArray(s) || s.length !== 3)
       throw new Error("Lattice must be a 3x3 matrix");
-    return t.forEach((e) => {
+    return s.forEach((e) => {
       if (!Array.isArray(e) || e.length !== 3)
         throw new Error("Lattice vectors must be length 3");
-    }), t;
+    }), s;
   }
   /**
    * Validates that species is an array of strings.
    * @throws Will throw an error if species array is invalid
    */
-  _validateSpecies(t) {
-    if (!Array.isArray(t)) throw new Error("Species must be an array");
-    return t.forEach((e) => {
+  _validateSpecies(s) {
+    if (!Array.isArray(s)) throw new Error("Species must be an array");
+    return s.forEach((e) => {
       if (typeof e != "string")
         throw new Error("Species entries must be strings");
-    }), t;
+    }), s;
   }
   /**
    * Validates the sites array, ensuring each site is a Site instance or a valid object.
    * @throws Will throw an error if sites array is invalid
    */
-  _validateSites(t) {
-    if (!Array.isArray(t)) throw new Error("Sites must be an array");
-    return t.map((e) => {
-      if (e instanceof x) return e;
+  _validateSites(s) {
+    if (!Array.isArray(s)) throw new Error("Sites must be an array");
+    return s.map((e) => {
+      if (e instanceof S) return e;
       if (typeof e == "object" && typeof e.speciesIndex == "number" && Array.isArray(e.cart) && e.cart.length === 3)
-        return this._validateSpeciesIndex(e.speciesIndex), new x(
+        return this._validateSpeciesIndex(e.speciesIndex), new S(
           e.speciesIndex,
           e.cart,
           e.props ?? {}
@@ -228,230 +247,305 @@ class S {
    * Validates that a species index is within bounds.
    * @throws Will throw an error if index is out of range
    */
-  _validateSpeciesIndex(t) {
-    if (t < 0 || t >= this.species.length)
+  _validateSpeciesIndex(s) {
+    if (s < 0 || s >= this.species.length)
       throw new Error("speciesIndex out of bounds");
   }
 }
-function E(s) {
-  return s.split(/\r?\n/).map((t) => t.trim()).filter(Boolean);
+class Z {
+  constructor(s) {
+    this.spatialUnits = "angstrom", this._invalid = !0;
+    const { origin: e, basis: t, shape: m, values: o, components: n = 1, units: u } = s, [a, b, h] = m;
+    if (o.length !== a * b * h * n)
+      throw new Error(
+        `Invalid values length: expected ${a * b * h * n}, got ${o.length}`
+      );
+    this.origin = e, this.basis = t, this.shape = m, this.values = o, this.components = n, this.units = u;
+  }
+  invalidate() {
+    this._invalid = !0;
+  }
+  map(s) {
+    const [e, t, m] = this.shape;
+    for (let o = 0; o < m; o++)
+      for (let n = 0; n < t; n++)
+        for (let u = 0; u < e; u++)
+          for (let a = 0; a < this.components; a++) {
+            const b = this.index(u, n, o, a);
+            this.values[b] = s(this.values[b], u, n, o, a);
+          }
+    this.invalidate();
+  }
+  min() {
+    return (this._invalid || this._min === void 0) && this.computeStats(), this._min;
+  }
+  max() {
+    return (this._invalid || this._max === void 0) && this.computeStats(), this._max;
+  }
+  mean() {
+    return (this._invalid || this._mean === void 0) && this.computeStats(), this._mean;
+  }
+  index(s, e, t, m = 0) {
+    const [o, n] = this.shape;
+    return (s + o * (e + n * t)) * this.components + m;
+  }
+  get(s, e, t, m = 0) {
+    return this.values[this.index(s, e, t, m)];
+  }
+  set(s, e, t, m, o = 0) {
+    this.values[this.index(s, e, t, o)] = m, this.invalidate();
+  }
+  normalize() {
+    const s = this.min(), e = this.max();
+    this.map((t) => (t - s) / (e - s));
+  }
+  /** Convert grid index → Cartesian position */
+  position(s, e, t) {
+    const [m, o, n] = this.basis;
+    return [
+      this.origin[0] + s * m[0] + e * o[0] + t * n[0],
+      this.origin[1] + s * m[1] + e * o[1] + t * n[1],
+      this.origin[2] + s * m[2] + e * o[2] + t * n[2]
+    ];
+  }
+  voxelVolume() {
+    const [s, e, t] = this.basis;
+    return Math.abs(
+      s[0] * (e[1] * t[2] - e[2] * t[1]) - s[1] * (e[0] * t[2] - e[2] * t[0]) + s[2] * (e[0] * t[1] - e[1] * t[0])
+    );
+  }
+  integral() {
+    return this.mean() * this.values.length * this.voxelVolume();
+  }
+  computeStats() {
+    const s = this.values.length;
+    let e = 1 / 0, t = -1 / 0, m = 0;
+    for (let o = 0; o < s; o++) {
+      const n = this.values[o];
+      n < e && (e = n), n > t && (t = n), m += n;
+    }
+    this._min = e, this._max = t, this._mean = m / s, this._invalid = !1;
+  }
+}
+function I(i) {
+  return i.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
 }
-function D(s, t = 6) {
-  const e = [], i = C(s);
-  e.push("Generated by matsci-parse"), e.push("1.0"), s.lattice.forEach((a) => {
-    e.push(a.map((h) => h.toFixed(t)).join(" "));
+function Q(i, s = 6) {
+  const e = [], t = B(i);
+  e.push("Generated by matsci-parse"), e.push("1.0"), i.lattice.forEach((n) => {
+    e.push(n.map((u) => u.toFixed(s)).join(" "));
   });
-  const o = Array.from(
-    new Set(s.sites.map((a) => s.species[a.speciesIndex]))
-  ), n = o.map(
-    (a) => s.sites.filter((h) => s.species[h.speciesIndex] === a).length
+  const m = Array.from(
+    new Set(i.sites.map((n) => i.species[n.speciesIndex]))
+  ), o = m.map(
+    (n) => i.sites.filter((u) => i.species[u.speciesIndex] === n).length
   );
-  return e.push(o.join(" ")), e.push(n.join(" ")), i && e.push("Selective dynamics"), e.push("Cartesian"), o.forEach((a) => {
-    s.sites.filter((h) => s.species[h.speciesIndex] === a).forEach((h) => {
-      const l = h.cart.map((p) => p.toFixed(t)).join(" ");
-      if (i) {
-        const f = (Array.isArray(h.props?.selectiveDynamics) ? h.props.selectiveDynamics : [!0, !0, !0]).map((r) => r ? "T" : "F").join(" ");
-        e.push(`${l} ${f}`);
+  return e.push(m.join(" ")), e.push(o.join(" ")), t && e.push("Selective dynamics"), e.push("Cartesian"), m.forEach((n) => {
+    i.sites.filter((u) => i.species[u.speciesIndex] === n).forEach((u) => {
+      const a = u.cart.map((b) => b.toFixed(s)).join(" ");
+      if (t) {
+        const h = (Array.isArray(u.props?.selectiveDynamics) ? u.props.selectiveDynamics : [!0, !0, !0]).map((r) => r ? "T" : "F").join(" ");
+        e.push(`${a} ${h}`);
       } else
-        e.push(l);
+        e.push(a);
     });
   }), e.join(`
 `);
 }
-function R(s) {
-  let t = 0;
-  t++;
-  const e = parseFloat(s[t++]), i = [];
+function z(i) {
+  let s = 0;
+  s++;
+  const e = parseFloat(i[s++]), t = [];
   for (let r = 0; r < 3; r++)
-    i.push(
-      s[t++].split(/\s+/).map((u) => parseFloat(u) * e)
+    t.push(
+      i[s++].split(/\s+/).map((l) => parseFloat(l) * e)
     );
-  let o = s[t].trim(), n;
-  /^[A-Za-z]/.test(o) && (n = o.split(/\s+/), t++);
-  const a = s[t++].split(/\s+/).map(Number);
-  n || (n = a.map((r, u) => `X${u + 1}`));
-  let h = !1;
-  s[t]?.toLowerCase().startsWith("s") && (h = !0, t++);
-  const p = s[t++].toLowerCase().startsWith("d"), f = [];
-  return n.forEach((r, u) => {
-    for (let g = 0; g < a[u]; g++) {
-      const c = s[t++].split(/\s+/).map(Number);
-      let m;
-      p ? m = [
-        c[0] * i[0][0] + c[1] * i[1][0] + c[2] * i[2][0],
-        c[0] * i[0][1] + c[1] * i[1][1] + c[2] * i[2][1],
-        c[0] * i[0][2] + c[1] * i[1][2] + c[2] * i[2][2]
-      ] : m = c.slice(0, 3);
-      const w = {};
-      if (h) {
-        const y = c.slice(3, 6).map((b) => b === 1);
-        y.length === 3 && (w.selectiveDynamics = y);
+  let m = i[s].trim(), o;
+  /^[A-Za-z]/.test(m) && (o = m.split(/\s+/), s++);
+  const n = i[s++].split(/\s+/).map(Number);
+  o || (o = n.map((r, l) => `X${l + 1}`));
+  let u = !1;
+  i[s]?.toLowerCase().startsWith("s") && (u = !0, s++);
+  const b = i[s++].toLowerCase().startsWith("d"), h = [];
+  return o.forEach((r, l) => {
+    for (let y = 0; y < n[l]; y++) {
+      const c = i[s++].split(/\s+/).map(Number);
+      let p;
+      b ? p = [
+        c[0] * t[0][0] + c[1] * t[1][0] + c[2] * t[2][0],
+        c[0] * t[0][1] + c[1] * t[1][1] + c[2] * t[2][1],
+        c[0] * t[0][2] + c[1] * t[1][2] + c[2] * t[2][2]
+      ] : p = c.slice(0, 3);
+      const N = {};
+      if (u) {
+        const g = c.slice(3, 6).map((_) => _ === 1);
+        g.length === 3 && (N.selectiveDynamics = g);
       }
-      f.push(new x(u, m, w));
+      h.push(new S(l, p, N));
     }
   }), {
-    structure: new S({ lattice: i, species: n, sites: f }),
-    linesConsumed: t
+    structure: new F({ lattice: t, species: o, sites: h }),
+    linesConsumed: s
   };
 }
-function W(s) {
-  const t = E(s);
-  return R(t).structure;
+function ss(i) {
+  const s = I(i);
+  return z(s).structure;
 }
-function k(s, t = 6) {
+function es(i, s = 6) {
   const e = [];
-  return e.push("CRYSTAL"), e.push("PRIMVEC"), s.lattice.forEach((i) => {
-    e.push(i.map((o) => o.toFixed(t)).join(" "));
-  }), e.push("PRIMCOORD"), e.push(`${s.numSites} 1`), s.sites.forEach((i) => {
-    const o = s.species[i.speciesIndex];
+  return e.push("CRYSTAL"), e.push("PRIMVEC"), i.lattice.forEach((t) => {
+    e.push(t.map((m) => m.toFixed(s)).join(" "));
+  }), e.push("PRIMCOORD"), e.push(`${i.numSites} 1`), i.sites.forEach((t) => {
+    const m = i.species[t.speciesIndex];
     e.push(
-      `${o} ${i.cart.map((n) => n.toFixed(t)).join(" ")}`
+      `${m} ${t.cart.map((o) => o.toFixed(s)).join(" ")}`
     );
   }), e.join(`
 `);
 }
-function X(s) {
-  const t = E(s), e = [], i = [], o = [];
-  let n = 0;
-  for (; n < t.length && t[n].toUpperCase() !== "PRIMVEC"; ) n++;
-  if (n === t.length) throw new Error("PRIMVEC block not found in XSF");
-  n++;
-  for (let h = 0; h < 3; h++)
-    e.push(t[n++].split(/\s+/).map(Number));
-  for (; n < t.length && t[n].toUpperCase() !== "PRIMCOORD"; ) n++;
-  if (n === t.length) throw new Error("PRIMCOORD block not found in XSF");
-  n++;
-  const [a] = t[n++].split(/\s+/).map(Number);
-  for (let h = 0; h < a; h++) {
-    const l = t[n++].split(/\s+/), p = l[0], f = l.slice(1, 4).map(Number);
-    let r = i.indexOf(p);
-    r === -1 && (i.push(p), r = i.length - 1), o.push(new x(r, f));
-  }
-  return new S({ lattice: e, species: i, sites: o });
+function ts(i) {
+  const s = I(i), e = [], t = [], m = [];
+  let o = 0;
+  for (; o < s.length && s[o].toUpperCase() !== "PRIMVEC"; ) o++;
+  if (o === s.length) throw new Error("PRIMVEC block not found in XSF");
+  o++;
+  for (let u = 0; u < 3; u++)
+    e.push(s[o++].split(/\s+/).map(Number));
+  for (; o < s.length && s[o].toUpperCase() !== "PRIMCOORD"; ) o++;
+  if (o === s.length) throw new Error("PRIMCOORD block not found in XSF");
+  o++;
+  const [n] = s[o++].split(/\s+/).map(Number);
+  for (let u = 0; u < n; u++) {
+    const a = s[o++].split(/\s+/), b = a[0], h = a.slice(1, 4).map(Number);
+    let r = t.indexOf(b);
+    r === -1 && (t.push(b), r = t.length - 1), m.push(new S(r, h));
+  }
+  return new F({ lattice: e, species: t, sites: m });
 }
-function z(s, t = 6) {
-  const e = [], i = s.sites.length;
-  e.push(String(i));
-  const o = C(s), n = s.lattice, a = [
-    n[0][0],
-    n[1][0],
-    n[2][0],
-    n[0][1],
-    n[1][1],
-    n[2][1],
-    n[0][2],
-    n[1][2],
-    n[2][2]
-  ].join(" "), h = [
+function os(i, s = 6) {
+  const e = [], t = i.sites.length;
+  e.push(String(t));
+  const m = B(i), o = i.lattice, n = [
+    o[0][0],
+    o[1][0],
+    o[2][0],
+    o[0][1],
+    o[1][1],
+    o[2][1],
+    o[0][2],
+    o[1][2],
+    o[2][2]
+  ].join(" "), u = [
     "species:S:1",
     "pos:R:3",
-    o ? "selectiveDynamics:L:3" : null
+    m ? "selectiveDynamics:L:3" : null
   ].filter(Boolean).join(":");
-  e.push(`Lattice="${a}" Properties=${h}`);
-  for (const l of s.sites) {
-    const p = s.species[l.speciesIndex], [f, r, u] = l.cart;
-    let g = `${p} ${f.toFixed(t)} ${r.toFixed(t)} ${u.toFixed(t)}`;
-    if (o) {
-      const c = Array.isArray(l.props?.selectiveDynamics) ? l.props.selectiveDynamics : [!0, !0, !0];
-      g += " " + c.map((m) => m ? "T" : "F").join(" ");
+  e.push(`Lattice="${n}" Properties=${u}`);
+  for (const a of i.sites) {
+    const b = i.species[a.speciesIndex], [h, r, l] = a.cart;
+    let y = `${b} ${h.toFixed(s)} ${r.toFixed(s)} ${l.toFixed(s)}`;
+    if (m) {
+      const c = Array.isArray(a.props?.selectiveDynamics) ? a.props.selectiveDynamics : [!0, !0, !0];
+      y += " " + c.map((p) => p ? "T" : "F").join(" ");
     }
-    e.push(g);
+    e.push(y);
   }
   return e.join(`
 `);
 }
-function Z(s) {
-  const t = E(s);
+function is(i) {
+  const s = I(i);
   let e = 0;
-  const i = parseInt(t[e++], 10);
-  if (!Number.isFinite(i))
+  const t = parseInt(s[e++], 10);
+  if (!Number.isFinite(t))
     throw new Error("Invalid XYZ: first line must be atom count");
-  const o = t[e++], n = {}, a = /(\w+)=(".*?"|\S+)/g;
-  for (const c of o.matchAll(a)) {
-    let m = c[2];
-    m.startsWith('"') && (m = m.slice(1, -1)), n[c[1]] = m;
-  }
-  let h;
-  if (n.Lattice) {
-    const c = n.Lattice.split(/\s+/).map(Number);
+  const m = s[e++], o = {}, n = /(\w+)=(".*?"|\S+)/g;
+  for (const c of m.matchAll(n)) {
+    let p = c[2];
+    p.startsWith('"') && (p = p.slice(1, -1)), o[c[1]] = p;
+  }
+  let u;
+  if (o.Lattice) {
+    const c = o.Lattice.split(/\s+/).map(Number);
     if (c.length !== 9) throw new Error("Invalid Lattice in extended XYZ");
-    h = [
+    u = [
       [c[0], c[3], c[6]],
       [c[1], c[4], c[7]],
       [c[2], c[5], c[8]]
     ];
   } else
     throw new Error("Lattice must be present in extended XYZ format");
-  let l = 0, p = 1, f = null;
-  if (n.Properties) {
-    const c = n.Properties.split(":");
-    let m = 0;
-    for (let w = 0; w < c.length; w += 3) {
-      const y = c[w], b = parseInt(c[w + 2], 10);
-      y === "species" && (l = m), y === "pos" && (p = m), y === "selectiveDynamics" && (f = m), m += b;
+  let a = 0, b = 1, h = null;
+  if (o.Properties) {
+    const c = o.Properties.split(":");
+    let p = 0;
+    for (let N = 0; N < c.length; N += 3) {
+      const g = c[N], _ = parseInt(c[N + 2], 10);
+      g === "species" && (a = p), g === "pos" && (b = p), g === "selectiveDynamics" && (h = p), p += _;
     }
   }
-  const r = [], u = /* @__PURE__ */ new Map(), g = [];
-  for (let c = 0; c < i; c++) {
-    const m = t[e++].split(/\s+/), w = m[l];
-    u.has(w) || (u.set(w, r.length), r.push(w));
-    const y = u.get(w), b = m.slice(p, p + 3).map(Number), I = {};
-    if (f !== null) {
-      const _ = m.slice(f, f + 3).map((d) => d.toUpperCase() === "T");
-      _.length === 3 && (I.selectiveDynamics = _);
+  const r = [], l = /* @__PURE__ */ new Map(), y = [];
+  for (let c = 0; c < t; c++) {
+    const p = s[e++].split(/\s+/), N = p[a];
+    l.has(N) || (l.set(N, r.length), r.push(N));
+    const g = l.get(N), _ = p.slice(b, b + 3).map(Number), v = {};
+    if (h !== null) {
+      const f = p.slice(h, h + 3).map((d) => d.toUpperCase() === "T");
+      f.length === 3 && (v.selectiveDynamics = f);
     }
-    g.push(new x(y, b, I));
+    y.push(new S(g, _, v));
   }
-  return new S({ lattice: h, species: r, sites: g });
+  return new F({ lattice: u, species: r, sites: y });
 }
-function A(s, t) {
-  return s[0] * t[0] + s[1] * t[1] + s[2] * t[2];
+function C(i, s) {
+  return i[0] * s[0] + i[1] * s[1] + i[2] * s[2];
 }
-function T(s) {
-  return Math.sqrt(A(s, s));
+function L(i) {
+  return Math.sqrt(C(i, i));
 }
-function L(s) {
-  return s * 180 / Math.PI;
+function P(i) {
+  return i * 180 / Math.PI;
 }
-function j(s, t) {
-  const [e, i, o] = t, n = e[0] * (i[1] * o[2] - i[2] * o[1]) - e[1] * (i[0] * o[2] - i[2] * o[0]) + e[2] * (i[0] * o[1] - i[1] * o[0]);
-  if (Math.abs(n) < 1e-12)
+function G(i, s) {
+  const [e, t, m] = s, o = e[0] * (t[1] * m[2] - t[2] * m[1]) - e[1] * (t[0] * m[2] - t[2] * m[0]) + e[2] * (t[0] * m[1] - t[1] * m[0]);
+  if (Math.abs(o) < 1e-12)
     throw new Error("Singular lattice matrix");
-  const a = [
+  const n = [
     [
-      (i[1] * o[2] - i[2] * o[1]) / n,
-      (e[2] * o[1] - e[1] * o[2]) / n,
-      (e[1] * i[2] - e[2] * i[1]) / n
+      (t[1] * m[2] - t[2] * m[1]) / o,
+      (e[2] * m[1] - e[1] * m[2]) / o,
+      (e[1] * t[2] - e[2] * t[1]) / o
     ],
     [
-      (i[2] * o[0] - i[0] * o[2]) / n,
-      (e[0] * o[2] - e[2] * o[0]) / n,
-      (e[2] * i[0] - e[0] * i[2]) / n
+      (t[2] * m[0] - t[0] * m[2]) / o,
+      (e[0] * m[2] - e[2] * m[0]) / o,
+      (e[2] * t[0] - e[0] * t[2]) / o
     ],
     [
-      (i[0] * o[1] - i[1] * o[0]) / n,
-      (e[1] * o[0] - e[0] * o[1]) / n,
-      (e[0] * i[1] - e[1] * i[0]) / n
+      (t[0] * m[1] - t[1] * m[0]) / o,
+      (e[1] * m[0] - e[0] * m[1]) / o,
+      (e[0] * t[1] - e[1] * t[0]) / o
     ]
   ];
   return [
-    s[0] * a[0][0] + s[1] * a[1][0] + s[2] * a[2][0],
-    s[0] * a[0][1] + s[1] * a[1][1] + s[2] * a[2][1],
-    s[0] * a[0][2] + s[1] * a[1][2] + s[2] * a[2][2]
+    i[0] * n[0][0] + i[1] * n[1][0] + i[2] * n[2][0],
+    i[0] * n[0][1] + i[1] * n[1][1] + i[2] * n[2][1],
+    i[0] * n[0][2] + i[1] * n[1][2] + i[2] * n[2][2]
   ];
 }
-function V(s, t = 6) {
-  const [e, i, o] = s.lattice, n = T(e), a = T(i), h = T(o), l = L(Math.acos(A(i, o) / (a * h))), p = L(Math.acos(A(e, o) / (n * h))), f = L(Math.acos(A(e, i) / (n * a)));
+function ms(i, s = 6) {
+  const [e, t, m] = i.lattice, o = L(e), n = L(t), u = L(m), a = P(Math.acos(C(t, m) / (n * u))), b = P(Math.acos(C(e, m) / (o * u))), h = P(Math.acos(C(e, t) / (o * n)));
   let r = `data_made_with_matsci-parse
     _symmetry_space_group_name_H-M   'P 1'
     _symmetry_Int_Tables_number    1
 
-    _cell_length_a   ${n.toFixed(t)}
-    _cell_length_b   ${a.toFixed(t)}
-    _cell_length_c   ${h.toFixed(t)}
-    _cell_angle_alpha   ${l.toFixed(t)}
-    _cell_angle_beta    ${p.toFixed(t)}
-    _cell_angle_gamma   ${f.toFixed(t)}
+    _cell_length_a   ${o.toFixed(s)}
+    _cell_length_b   ${n.toFixed(s)}
+    _cell_length_c   ${u.toFixed(s)}
+    _cell_angle_alpha   ${a.toFixed(s)}
+    _cell_angle_beta    ${b.toFixed(s)}
+    _cell_angle_gamma   ${h.toFixed(s)}
 
     loop_
     _atom_site_label
@@ -460,134 +554,407 @@ function V(s, t = 6) {
     _atom_site_fract_y
     _atom_site_fract_z
 `;
-  return s.sites.forEach((u, g) => {
-    const c = s.species[u.speciesIndex], m = j(u.cart, s.lattice);
-    r += `${c}${g + 1} ${c} ${m[0].toFixed(t)} ${m[1].toFixed(
+  return i.sites.forEach((l, y) => {
+    const c = i.species[l.speciesIndex], p = G(l.cart, i.lattice);
+    r += `${c}${y + 1} ${c} ${p[0].toFixed(s)} ${p[1].toFixed(
       6
-    )} ${m[2].toFixed(t)}
+    )} ${p[2].toFixed(s)}
 `;
   }), r;
 }
-function U(s) {
-  const t = E(s);
-  let e = 0, i = 0, o = 0, n = 0, a = 0, h = 0, l = [];
-  const p = [];
-  let f = !1, r = [], u = !1;
-  for (const _ of t) {
-    const d = _.trim();
+function ns(i) {
+  const s = I(i);
+  let e = 0, t = 0, m = 0, o = 0, n = 0, u = 0, a = [];
+  const b = [];
+  let h = !1, r = [], l = !1;
+  for (const f of s) {
+    const d = f.trim();
     if (d) {
       if (d.startsWith("_cell_length_a")) e = parseFloat(d.split(/\s+/)[1]);
       else if (d.startsWith("_cell_length_b"))
-        i = parseFloat(d.split(/\s+/)[1]);
+        t = parseFloat(d.split(/\s+/)[1]);
       else if (d.startsWith("_cell_length_c"))
-        o = parseFloat(d.split(/\s+/)[1]);
+        m = parseFloat(d.split(/\s+/)[1]);
       else if (d.startsWith("_cell_angle_alpha"))
-        n = parseFloat(d.split(/\s+/)[1]);
+        o = parseFloat(d.split(/\s+/)[1]);
       else if (d.startsWith("_cell_angle_beta"))
-        a = parseFloat(d.split(/\s+/)[1]);
+        n = parseFloat(d.split(/\s+/)[1]);
       else if (d.startsWith("_cell_angle_gamma"))
-        h = parseFloat(d.split(/\s+/)[1]);
+        u = parseFloat(d.split(/\s+/)[1]);
       else if (d.startsWith("loop_")) {
-        f = !0, r = [], u = !1;
+        h = !0, r = [], l = !1;
         continue;
       }
-      if (f && d.startsWith("_")) {
-        r.push(d), d.includes("_atom_site_") && (u = !0);
+      if (h && d.startsWith("_")) {
+        r.push(d), d.includes("_atom_site_") && (l = !0);
         continue;
       }
-      if (f && !d.startsWith("_")) {
-        u && (l.length === 0 && (l = [...r]), p.push(d.split(/\s+/)));
+      if (h && !d.startsWith("_")) {
+        l && (a.length === 0 && (a = [...r]), b.push(d.split(/\s+/)));
         continue;
       }
     }
   }
-  if (l.length === 0)
+  if (a.length === 0)
     throw new Error("No _atom_site loop found in CIF");
-  const g = P(e, i, o, n, a, h), c = [], m = [], w = l.findIndex((_) => _.includes("fract_x")), y = l.findIndex((_) => _.includes("fract_y")), b = l.findIndex((_) => _.includes("fract_z")), I = l.findIndex((_) => _.includes("type_symbol"));
-  if (w < 0 || y < 0 || b < 0 || I < 0)
+  const y = k(e, t, m, o, n, u), c = [], p = [], N = a.findIndex((f) => f.includes("fract_x")), g = a.findIndex((f) => f.includes("fract_y")), _ = a.findIndex((f) => f.includes("fract_z")), v = a.findIndex((f) => f.includes("type_symbol"));
+  if (N < 0 || g < 0 || _ < 0 || v < 0)
     throw new Error("CIF missing required _atom_site columns");
-  for (const _ of p) {
+  for (const f of b) {
     const d = [
-      parseFloat(_[w]),
-      parseFloat(_[y]),
-      parseFloat(_[b])
-    ], $ = O(d, g);
-    let v = c.indexOf(_[I]);
-    v === -1 && (v = c.length, c.push(_[I])), m.push(new x(v, $));
-  }
-  return new S({ lattice: g, species: c, sites: m });
+      parseFloat(f[N]),
+      parseFloat(f[g]),
+      parseFloat(f[_])
+    ], w = U(d, y);
+    let x = c.indexOf(f[v]);
+    x === -1 && (x = c.length, c.push(f[v])), p.push(new S(x, w));
+  }
+  return new F({ lattice: y, species: c, sites: p });
 }
-function N(s) {
-  let t = [];
+function Y(i) {
+  let s = [];
   const e = [];
-  for (let l = 0; l < s.length; l++) {
-    const p = s[l].trim();
-    if (!(!p || p.startsWith("&")) && /^CELL_PARAMETERS/i.test(p)) {
-      let f = 0, r = l + 1;
-      for (; f < 3 && r < s.length; ) {
-        const u = s[r].trim();
-        u !== "" && (t.push(u.split(/\s+/).map(Number)), f++), r++;
+  for (let a = 0; a < i.length; a++) {
+    const b = i[a].trim();
+    if (!(!b || b.startsWith("&")) && /^CELL_PARAMETERS/i.test(b)) {
+      let h = 0, r = a + 1;
+      for (; h < 3 && r < i.length; ) {
+        const l = i[r].trim();
+        l !== "" && (s.push(l.split(/\s+/).map(Number)), h++), r++;
       }
-      if (f < 3) throw new Error("Incomplete CELL_PARAMETERS block");
+      if (h < 3) throw new Error("Incomplete CELL_PARAMETERS block");
       break;
     }
   }
-  if (t.length !== 3)
+  if (s.length !== 3)
     throw new Error("CELL_PARAMETERS block not found or incomplete");
-  let i = !1, o = "angstrom";
-  for (let l = 0; l < s.length; l++) {
-    const p = s[l].trim();
-    if (!(!p || p.startsWith("&"))) {
-      if (/^ATOMIC_POSITIONS/i.test(p)) {
-        i = !0;
-        const f = p.match(/^ATOMIC_POSITIONS\s+(\w+)/i);
-        o = f ? f[1].toLowerCase() : "angstrom";
+  let t = !1, m = "angstrom";
+  for (let a = 0; a < i.length; a++) {
+    const b = i[a].trim();
+    if (!(!b || b.startsWith("&"))) {
+      if (/^ATOMIC_POSITIONS/i.test(b)) {
+        t = !0;
+        const h = b.match(/^ATOMIC_POSITIONS\s+(\w+)/i);
+        m = h ? h[1].toLowerCase() : "angstrom";
         continue;
       }
-      if (i) {
-        const f = p.split(/\s+/);
-        if (f.length < 4 || !/^[A-Za-z]/.test(f[0]) || f.slice(1, 4).some((r) => Number.isNaN(Number(r))))
+      if (t) {
+        const h = b.split(/\s+/);
+        if (h.length < 4 || !/^[A-Za-z]/.test(h[0]) || h.slice(1, 4).some((r) => Number.isNaN(Number(r))))
           break;
-        e.push(p);
+        e.push(b);
       }
     }
   }
   if (e.length === 0)
     throw new Error("ATOMIC_POSITIONS block not found");
-  const n = o === "crystal", a = [];
-  for (const l of e) {
-    const p = l.split(/\s+/)[0];
-    a.includes(p) || a.push(p);
-  }
-  const h = [];
-  for (const l of e) {
-    const p = l.split(/\s+/), f = p[0], r = p.slice(1, 4).map(Number);
-    let u;
-    n ? u = [
-      r[0] * t[0][0] + r[1] * t[1][0] + r[2] * t[2][0],
-      r[0] * t[0][1] + r[1] * t[1][1] + r[2] * t[2][1],
-      r[0] * t[0][2] + r[1] * t[1][2] + r[2] * t[2][2]
-    ] : u = r, h.push(new x(a.indexOf(f), u));
+  const o = m === "crystal", n = [];
+  for (const a of e) {
+    const b = a.split(/\s+/)[0];
+    n.includes(b) || n.push(b);
+  }
+  const u = [];
+  for (const a of e) {
+    const b = a.split(/\s+/), h = b[0], r = b.slice(1, 4).map(Number);
+    let l;
+    o ? l = [
+      r[0] * s[0][0] + r[1] * s[1][0] + r[2] * s[2][0],
+      r[0] * s[0][1] + r[1] * s[1][1] + r[2] * s[2][1],
+      r[0] * s[0][2] + r[1] * s[1][2] + r[2] * s[2][2]
+    ] : l = r, u.push(new S(n.indexOf(h), l));
   }
   return {
-    structure: new S({ lattice: t, species: a, sites: h }),
-    linesConsumed: s.length
+    structure: new F({ lattice: s, species: n, sites: u }),
+    linesConsumed: i.length
   };
 }
-function Y(s) {
-  const t = E(s);
-  return N(t).structure;
+function as(i) {
+  const s = I(i);
+  return Y(s).structure;
+}
+const D = {
+  1: { atomicNumber: 1, symbol: "H", name: "Hydrogen", mass: 1.008 },
+  2: { atomicNumber: 2, symbol: "He", name: "Helium", mass: 4.0026 },
+  3: { atomicNumber: 3, symbol: "Li", name: "Lithium", mass: 6.94 },
+  4: { atomicNumber: 4, symbol: "Be", name: "Beryllium", mass: 9.0122 },
+  5: { atomicNumber: 5, symbol: "B", name: "Boron", mass: 10.81 },
+  6: { atomicNumber: 6, symbol: "C", name: "Carbon", mass: 12.011 },
+  7: { atomicNumber: 7, symbol: "N", name: "Nitrogen", mass: 14.007 },
+  8: { atomicNumber: 8, symbol: "O", name: "Oxygen", mass: 15.999 },
+  9: { atomicNumber: 9, symbol: "F", name: "Fluorine", mass: 18.998 },
+  10: { atomicNumber: 10, symbol: "Ne", name: "Neon", mass: 20.18 },
+  11: { atomicNumber: 11, symbol: "Na", name: "Sodium", mass: 22.99 },
+  12: { atomicNumber: 12, symbol: "Mg", name: "Magnesium", mass: 24.305 },
+  13: { atomicNumber: 13, symbol: "Al", name: "Aluminum", mass: 26.982 },
+  14: { atomicNumber: 14, symbol: "Si", name: "Silicon", mass: 28.085 },
+  15: { atomicNumber: 15, symbol: "P", name: "Phosphorus", mass: 30.974 },
+  16: { atomicNumber: 16, symbol: "S", name: "Sulfur", mass: 32.06 },
+  17: { atomicNumber: 17, symbol: "Cl", name: "Chlorine", mass: 35.45 },
+  18: { atomicNumber: 18, symbol: "Ar", name: "Argon", mass: 39.948 },
+  19: { atomicNumber: 19, symbol: "K", name: "Potassium", mass: 39.098 },
+  20: { atomicNumber: 20, symbol: "Ca", name: "Calcium", mass: 40.078 },
+  21: { atomicNumber: 21, symbol: "Sc", name: "Scandium", mass: 44.956 },
+  22: { atomicNumber: 22, symbol: "Ti", name: "Titanium", mass: 47.867 },
+  23: { atomicNumber: 23, symbol: "V", name: "Vanadium", mass: 50.942 },
+  24: { atomicNumber: 24, symbol: "Cr", name: "Chromium", mass: 51.996 },
+  25: { atomicNumber: 25, symbol: "Mn", name: "Manganese", mass: 54.938 },
+  26: { atomicNumber: 26, symbol: "Fe", name: "Iron", mass: 55.845 },
+  27: { atomicNumber: 27, symbol: "Co", name: "Cobalt", mass: 58.933 },
+  28: { atomicNumber: 28, symbol: "Ni", name: "Nickel", mass: 58.693 },
+  29: { atomicNumber: 29, symbol: "Cu", name: "Copper", mass: 63.546 },
+  30: { atomicNumber: 30, symbol: "Zn", name: "Zinc", mass: 65.38 },
+  31: { atomicNumber: 31, symbol: "Ga", name: "Gallium", mass: 69.723 },
+  32: { atomicNumber: 32, symbol: "Ge", name: "Germanium", mass: 72.63 },
+  33: { atomicNumber: 33, symbol: "As", name: "Arsenic", mass: 74.922 },
+  34: { atomicNumber: 34, symbol: "Se", name: "Selenium", mass: 78.971 },
+  35: { atomicNumber: 35, symbol: "Br", name: "Bromine", mass: 79.904 },
+  36: { atomicNumber: 36, symbol: "Kr", name: "Krypton", mass: 83.798 },
+  37: { atomicNumber: 37, symbol: "Rb", name: "Rubidium", mass: 85.468 },
+  38: { atomicNumber: 38, symbol: "Sr", name: "Strontium", mass: 87.62 },
+  39: { atomicNumber: 39, symbol: "Y", name: "Yttrium", mass: 88.906 },
+  40: { atomicNumber: 40, symbol: "Zr", name: "Zirconium", mass: 91.224 },
+  41: { atomicNumber: 41, symbol: "Nb", name: "Niobium", mass: 92.906 },
+  42: { atomicNumber: 42, symbol: "Mo", name: "Molybdenum", mass: 95.95 },
+  43: { atomicNumber: 43, symbol: "Tc", name: "Technetium", mass: 98 },
+  44: { atomicNumber: 44, symbol: "Ru", name: "Ruthenium", mass: 101.07 },
+  45: { atomicNumber: 45, symbol: "Rh", name: "Rhodium", mass: 102.91 },
+  46: { atomicNumber: 46, symbol: "Pd", name: "Palladium", mass: 106.42 },
+  47: { atomicNumber: 47, symbol: "Ag", name: "Silver", mass: 107.868 },
+  48: { atomicNumber: 48, symbol: "Cd", name: "Cadmium", mass: 112.414 },
+  49: { atomicNumber: 49, symbol: "In", name: "Indium", mass: 114.818 },
+  50: { atomicNumber: 50, symbol: "Sn", name: "Tin", mass: 118.71 },
+  51: { atomicNumber: 51, symbol: "Sb", name: "Antimony", mass: 121.76 },
+  52: { atomicNumber: 52, symbol: "Te", name: "Tellurium", mass: 127.6 },
+  53: { atomicNumber: 53, symbol: "I", name: "Iodine", mass: 126.904 },
+  54: { atomicNumber: 54, symbol: "Xe", name: "Xenon", mass: 131.293 },
+  55: { atomicNumber: 55, symbol: "Cs", name: "Cesium", mass: 132.905 },
+  56: { atomicNumber: 56, symbol: "Ba", name: "Barium", mass: 137.33 },
+  57: { atomicNumber: 57, symbol: "La", name: "Lanthanum", mass: 138.905 },
+  58: { atomicNumber: 58, symbol: "Ce", name: "Cerium", mass: 140.12 },
+  59: { atomicNumber: 59, symbol: "Pr", name: "Praseodymium", mass: 140.91 },
+  60: { atomicNumber: 60, symbol: "Nd", name: "Neodymium", mass: 144.24 },
+  61: { atomicNumber: 61, symbol: "Pm", name: "Promethium", mass: 145 },
+  62: { atomicNumber: 62, symbol: "Sm", name: "Samarium", mass: 150.36 },
+  63: { atomicNumber: 63, symbol: "Eu", name: "Europium", mass: 151.964 },
+  64: { atomicNumber: 64, symbol: "Gd", name: "Gadolinium", mass: 157.25 },
+  65: { atomicNumber: 65, symbol: "Tb", name: "Terbium", mass: 158.93 },
+  66: { atomicNumber: 66, symbol: "Dy", name: "Dysprosium", mass: 162.5 },
+  67: { atomicNumber: 67, symbol: "Ho", name: "Holmium", mass: 164.93 },
+  68: { atomicNumber: 68, symbol: "Er", name: "Erbium", mass: 167.26 },
+  69: { atomicNumber: 69, symbol: "Tm", name: "Thulium", mass: 168.93 },
+  70: { atomicNumber: 70, symbol: "Yb", name: "Ytterbium", mass: 173.05 },
+  71: { atomicNumber: 71, symbol: "Lu", name: "Lutetium", mass: 174.97 },
+  72: { atomicNumber: 72, symbol: "Hf", name: "Hafnium", mass: 178.49 },
+  73: { atomicNumber: 73, symbol: "Ta", name: "Tantalum", mass: 180.95 },
+  74: { atomicNumber: 74, symbol: "W", name: "Tungsten", mass: 183.84 },
+  75: { atomicNumber: 75, symbol: "Re", name: "Rhenium", mass: 186.207 },
+  76: { atomicNumber: 76, symbol: "Os", name: "Osmium", mass: 190.23 },
+  77: { atomicNumber: 77, symbol: "Ir", name: "Iridium", mass: 192.217 },
+  78: { atomicNumber: 78, symbol: "Pt", name: "Platinum", mass: 195.084 },
+  79: { atomicNumber: 79, symbol: "Au", name: "Gold", mass: 196.967 },
+  80: { atomicNumber: 80, symbol: "Hg", name: "Mercury", mass: 200.592 },
+  81: { atomicNumber: 81, symbol: "Tl", name: "Thallium", mass: 204.38 },
+  82: { atomicNumber: 82, symbol: "Pb", name: "Lead", mass: 207.2 },
+  83: { atomicNumber: 83, symbol: "Bi", name: "Bismuth", mass: 208.98 },
+  84: { atomicNumber: 84, symbol: "Po", name: "Polonium", mass: 209 },
+  85: { atomicNumber: 85, symbol: "At", name: "Astatine", mass: 210 },
+  86: { atomicNumber: 86, symbol: "Rn", name: "Radon", mass: 222 },
+  87: { atomicNumber: 87, symbol: "Fr", name: "Francium", mass: 223 },
+  88: { atomicNumber: 88, symbol: "Ra", name: "Radium", mass: 226 },
+  89: { atomicNumber: 89, symbol: "Ac", name: "Actinium", mass: 227 },
+  90: { atomicNumber: 90, symbol: "Th", name: "Thorium", mass: 232.04 },
+  91: { atomicNumber: 91, symbol: "Pa", name: "Protactinium", mass: 231.04 },
+  92: { atomicNumber: 92, symbol: "U", name: "Uranium", mass: 238.03 },
+  93: { atomicNumber: 93, symbol: "Np", name: "Neptunium", mass: 237 },
+  94: { atomicNumber: 94, symbol: "Pu", name: "Plutonium", mass: 244 },
+  95: { atomicNumber: 95, symbol: "Am", name: "Americium", mass: 243 },
+  96: { atomicNumber: 96, symbol: "Cm", name: "Curium", mass: 247 },
+  97: { atomicNumber: 97, symbol: "Bk", name: "Berkelium", mass: 247 },
+  98: { atomicNumber: 98, symbol: "Cf", name: "Californium", mass: 251 },
+  99: { atomicNumber: 99, symbol: "Es", name: "Einsteinium", mass: 252 },
+  100: { atomicNumber: 100, symbol: "Fm", name: "Fermium", mass: 257 },
+  101: { atomicNumber: 101, symbol: "Md", name: "Mendelevium", mass: 258 },
+  102: { atomicNumber: 102, symbol: "No", name: "Nobelium", mass: 259 },
+  103: { atomicNumber: 103, symbol: "Lr", name: "Lawrencium", mass: 262 },
+  104: { atomicNumber: 104, symbol: "Rf", name: "Rutherfordium", mass: 267 },
+  105: { atomicNumber: 105, symbol: "Db", name: "Dubnium", mass: 270 },
+  106: { atomicNumber: 106, symbol: "Sg", name: "Seaborgium", mass: 269 },
+  107: { atomicNumber: 107, symbol: "Bh", name: "Bohrium", mass: 270 },
+  108: { atomicNumber: 108, symbol: "Hs", name: "Hassium", mass: 277 },
+  109: { atomicNumber: 109, symbol: "Mt", name: "Meitnerium", mass: 278 },
+  110: { atomicNumber: 110, symbol: "Ds", name: "Darmstadtium", mass: 281 },
+  111: { atomicNumber: 111, symbol: "Rg", name: "Roentgenium", mass: 282 },
+  112: { atomicNumber: 112, symbol: "Cn", name: "Copernicium", mass: 285 },
+  113: { atomicNumber: 113, symbol: "Nh", name: "Nihonium", mass: 286 },
+  114: { atomicNumber: 114, symbol: "Fl", name: "Flerovium", mass: 289 },
+  115: { atomicNumber: 115, symbol: "Mc", name: "Moscovium", mass: 289 },
+  116: { atomicNumber: 116, symbol: "Lv", name: "Livermorium", mass: 293 },
+  117: { atomicNumber: 117, symbol: "Ts", name: "Tennessine", mass: 294 },
+  118: { atomicNumber: 118, symbol: "Og", name: "Oganesson", mass: 294 }
+}, q = {
+  angstrom: 1,
+  // canonical
+  bohr: 0.529177,
+  nm: 10,
+  pm: 0.01,
+  um: 1e4,
+  cm: 1e8,
+  m: 1e10,
+  fm: 1e-5
+}, K = {
+  Å: "angstrom",
+  μm: "um"
+}, $ = {
+  conversions: q,
+  aliases: K,
+  convert(i, s, e) {
+    const t = (n) => this.aliases[n] ?? n, m = t(s), o = t(e);
+    return m === o ? i : i * this.conversions[m] / this.conversions[o];
+  },
+  convertArray(i, s, e) {
+    return i.map((t) => this.convert(t, s, e));
+  }
+}, R = 1.8897268;
+function rs(i, s) {
+  const e = [];
+  e.push("Generated by matsci-parse"), e.push("Volumetric data export");
+  const m = [...s.origin].map((l) => l * R);
+  e.push(
+    `${i.numSites} ${m.map((l) => l.toFixed(6)).join(" ")}`
+  );
+  const o = s.shape, n = s.basis;
+  for (let l = 0; l < 3; l++) {
+    n[l];
+    const y = n[l].map((c) => c * R);
+    e.push(`${o[l]} ${y.map((c) => c.toFixed(6)).join(" ")}`);
+  }
+  for (const l of i.sites) {
+    const y = i.species[l.speciesIndex], c = Object.values(D).find(
+      (g) => g.symbol === y
+    )?.atomicNumber;
+    if (!c)
+      throw new Error(`Unknown element symbol: ${y}`);
+    [...l.cart];
+    const p = l.cart.map((g) => g * R), N = (l.getProp("charge") ?? 0).toFixed(6);
+    e.push(
+      `${c} ${N} ${p.map((g) => g.toFixed(6)).join(" ")}`
+    );
+  }
+  const u = s.values, [a, b, h] = o;
+  let r = [];
+  for (let l = 0; l < h; l++)
+    for (let y = 0; y < b; y++)
+      for (let c = 0; c < a; c++) {
+        const p = s.index(c, y, l);
+        r.push(u[p].toExponential(8)), r.length === 6 && (e.push(r.join(" ")), r = []);
+      }
+  return r.length > 0 && e.push(r.join(" ")), e.join(`
+`);
+}
+function H(i, s = "bohr", e = "bohr", t = "bohr") {
+  let m = 0;
+  m += 2;
+  const o = i[m].split(/\s+/), n = parseInt(o[0]);
+  let u = [
+    parseFloat(o[1]),
+    parseFloat(o[2]),
+    parseFloat(o[3])
+  ];
+  m++;
+  const a = i[m++].split(/\s+/), b = i[m++].split(/\s+/), h = i[m++].split(/\s+/);
+  let r = [
+    [parseFloat(a[1]), parseFloat(a[2]), parseFloat(a[3])],
+    [parseFloat(b[1]), parseFloat(b[2]), parseFloat(b[3])],
+    [
+      parseFloat(h[1]),
+      parseFloat(h[2]),
+      parseFloat(h[3])
+    ]
+  ];
+  const l = [
+    parseInt(a[0], 10),
+    parseInt(b[0], 10),
+    parseInt(h[0], 10)
+  ], y = [], c = /* @__PURE__ */ new Map(), p = [];
+  for (let w = 0; w < n; w++, m++) {
+    const x = i[m].trim().split(/\s+/);
+    if (x.length < 5) throw new Error(`Malformed atom line: "${i[m]}"`);
+    const A = parseInt(x[0], 10), V = parseFloat(x[1]), W = [
+      parseFloat(x[2]),
+      parseFloat(x[3]),
+      parseFloat(x[4])
+    ], j = D[A];
+    if (!j) throw new Error(`Unknown atomic number: ${A}`);
+    const E = j.symbol;
+    let T = c.get(E);
+    T === void 0 && (T = y.length, y.push(E), c.set(E, T)), p.push(new S(T, W, { charge: V }));
+  }
+  u = $.convertArray(
+    u,
+    s,
+    "angstrom"
+  ), r = r.map(
+    (w) => $.convertArray(
+      w,
+      t,
+      "angstrom"
+    )
+  ), p.forEach((w) => {
+    w.cart = $.convertArray(
+      w.cart,
+      e,
+      "angstrom"
+    );
+  });
+  const N = r.map(
+    (w, x) => w.map((A) => A * l[x])
+  ), g = new F({
+    lattice: N,
+    species: y,
+    sites: p
+  }), _ = l[0] * l[1] * l[2], v = new Float32Array(_);
+  let f = 0;
+  for (; m < i.length && f < _; ) {
+    const w = i[m++].trim().split(/\s+/);
+    for (const x of w)
+      x && f < _ && (v[f] = parseFloat(x), f++);
+  }
+  if (f !== _)
+    throw new Error(`Cube file truncated: expected ${_}, got ${f}`);
+  const d = new Z({
+    origin: u,
+    basis: r,
+    shape: l,
+    values: v,
+    units: "e/ų"
+  });
+  return { structure: g, volumetricData: d, linesConsumed: m };
+}
+function cs(i) {
+  const s = I(i);
+  return H(s).volumetricData;
+}
+function ls(i) {
+  const s = I(i);
+  return H(s).structure;
 }
 export {
-  S as CrystalStructure,
-  x as Site,
-  U as cifToStructure,
-  W as poscarToStructure,
-  Y as pwToStructure,
-  V as structureToCif,
-  D as structureToPoscar,
-  k as structureToXsf,
-  z as structureToXyz,
-  X as xsfToStructure,
-  Z as xyzToStructure
+  F as CrystalStructure,
+  S as Site,
+  Z as VolumetricData,
+  J as cartesianToFractional,
+  ns as cifToStructure,
+  ls as cubeToStructure,
+  cs as cubeToVolumetric,
+  U as fractionalToCartesian,
+  H as parseCube,
+  ss as poscarToStructure,
+  as as pwToStructure,
+  ms as structureToCif,
+  Q as structureToPoscar,
+  es as structureToXsf,
+  os as structureToXyz,
+  rs as volumetricToCube,
+  ts as xsfToStructure,
+  is as xyzToStructure
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matsci-parse",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "type": "module",
   "main": "dist/main.js",
   "module": "dist/main.js",