matsci-parse 0.1.2 → 0.3.0

package/dist/main.js

@@ -1,42 +1,42 @@
-class x {
-  constructor(e, t, n = {}) {
-    this.speciesIndex = e, this.cart = t, this.props = n;
+class v {
+  constructor(s, e, t = {}) {
+    this.speciesIndex = s, this.cart = e, this.props = t;
   }
-  getProp(e) {
-    return this.props[e];
+  getProp(s) {
+    return this.props[s];
   }
-  setProp(e, t) {
-    this.props[e] = t;
+  setProp(s, e) {
+    this.props[s] = e;
   }
 }
-function C(s) {
-  return s.sites.some((e) => Array.isArray(e.props.selectiveDynamics));
+function B(m) {
+  return m.sites.some((s) => Array.isArray(s.props.selectiveDynamics));
 }
-function E(s) {
-  return s * Math.PI / 180;
+function M(m) {
+  return m * Math.PI / 180;
 }
-function $(s, e) {
-  return s.map(
-    (t) => t[0] * e[0] + t[1] * e[1] + t[2] * e[2]
+function j(m, s) {
+  return m.map(
+    (e) => e[0] * s[0] + e[1] * s[1] + e[2] * s[2]
   );
 }
-function T(s, e, t, n, o, i) {
-  const a = E(n), c = E(o), h = E(i), m = [s, 0, 0], p = [
-    e * Math.cos(h),
-    e * Math.sin(h),
+function k(m, s, e, t, i, o) {
+  const a = M(t), b = M(i), n = M(o), u = [m, 0, 0], h = [
+    s * Math.cos(n),
+    s * Math.sin(n),
     0
-  ], u = t * Math.cos(c), l = t * (Math.cos(a) - Math.cos(c) * Math.cos(h)) / Math.sin(h), d = Math.sqrt(t * t - u * u - l * l);
-  return [m, p, [u, l, d]];
+  ], c = e * Math.cos(b), l = e * (Math.cos(a) - Math.cos(b) * Math.cos(n)) / Math.sin(n), f = Math.sqrt(e * e - c * c - l * l);
+  return [u, h, [c, l, f]];
 }
-function L(s, e) {
-  const [t, n, o] = e;
+function U(m, s) {
+  const [e, t, i] = s;
   return [
-    s[0] * t[0] + s[1] * n[0] + s[2] * o[0],
-    s[0] * t[1] + s[1] * n[1] + s[2] * o[1],
-    s[0] * t[2] + s[1] * n[2] + s[2] * o[2]
+    m[0] * e[0] + m[1] * t[0] + m[2] * i[0],
+    m[0] * e[1] + m[1] * t[1] + m[2] * i[1],
+    m[0] * e[2] + m[1] * t[2] + m[2] * i[2]
   ];
 }
-class w {
+class I {
   /**
    * Creates a new CrystalStructure.
    *
@@ -48,11 +48,11 @@ class w {
    * @throws Will throw an error if lattice is not 3x3, species is not an array of strings, or sites are invalid
    */
   constructor({
-    lattice: e,
-    species: t,
-    sites: n
+    lattice: s,
+    species: e,
+    sites: t
   }) {
-    this.lattice = this._validateLattice(e), this.species = this._validateSpecies(t), this.sites = this._validateSites(n);
+    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 +63,22 @@ class w {
    * Returns the site at the specified index.
    * @param i - Site index
    */
-  site(e) {
-    return this.sites[e];
+  site(s) {
+    return this.sites[s];
   }
   /**
    * Returns the Cartesian coordinates of a site.
    * @param i - Site index
    */
-  cartCoords(e) {
-    return this.sites[e].cart;
+  cartCoords(s) {
+    return this.sites[s].cart;
   }
   /**
    * Returns the chemical species of a site.
    * @param i - Site index
    */
-  siteSpecies(e) {
-    return this.species[this.sites[e].speciesIndex];
+  siteSpecies(s) {
+    return this.species[this.sites[s].speciesIndex];
   }
   /** Returns the array of elements (species) in the structure */
   get elements() {
@@ -92,11 +92,11 @@ class w {
    * @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(e, t, n) {
-    let o = this.species.indexOf(e);
-    o === -1 && (this.species.push(e), o = this.species.length - 1);
-    const i = new x(o, t);
-    n === void 0 || n >= this.sites.length ? this.sites.push(i) : n < 0 ? this.sites.unshift(i) : this.sites.splice(n, 0, i);
+  addSite(s, e, t) {
+    let i = this.species.indexOf(s);
+    i === -1 && (this.species.push(s), i = this.species.length - 1);
+    const o = new v(i, 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 +107,14 @@ class w {
    *
    * @throws Will throw an error if index is out of bounds
    */
-  removeSite(e) {
-    if (e < 0 || e >= this.sites.length)
+  removeSite(s) {
+    if (s < 0 || s >= this.sites.length)
       throw new Error("siteIndex out of bounds");
-    const n = this.sites.splice(e, 1)[0].speciesIndex;
+    const t = this.sites.splice(s, 1)[0].speciesIndex;
     this.sites.some(
-      (i) => i.speciesIndex === n
-    ) || (this.species.splice(n, 1), this.sites.forEach((i) => {
-      i.speciesIndex > n && (i.speciesIndex -= 1);
+      (o) => o.speciesIndex === t
+    ) || (this.species.splice(t, 1), this.sites.forEach((o) => {
+      o.speciesIndex > t && (o.speciesIndex -= 1);
     }));
   }
   /**
@@ -127,11 +127,11 @@ class w {
    *
    * @throws Will throw an error if siteIndex is out of bounds
    */
-  replaceSite(e, t) {
-    if (e < 0 || e >= this.sites.length)
+  replaceSite(s, e) {
+    if (s < 0 || s >= this.sites.length)
       throw new Error("siteIndex out of bounds");
-    const n = [...this.sites[e].cart];
-    this.removeSite(e), this.addSite(t, n, e);
+    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 +146,39 @@ class w {
    *
    * @throws Will throw an error if scale is not a number, a 3-element array, or a 3x3 matrix
    */
-  applyLatticeTransformation(e) {
-    let t;
-    if (typeof e == "number")
-      t = [
-        [e, 0, 0],
-        [0, e, 0],
-        [0, 0, e]
+  applyLatticeTransformation(s) {
+    let e;
+    if (typeof s == "number")
+      e = [
+        [s, 0, 0],
+        [0, s, 0],
+        [0, 0, s]
       ];
-    else if (Array.isArray(e) && e.length === 3 && e.every((i) => typeof i == "number"))
-      t = [
-        [e[0], 0, 0],
-        [0, e[1], 0],
-        [0, 0, e[2]]
+    else if (Array.isArray(s) && s.length === 3 && s.every((o) => typeof o == "number"))
+      e = [
+        [s[0], 0, 0],
+        [0, s[1], 0],
+        [0, 0, s[2]]
       ];
-    else if (Array.isArray(e) && e.length === 3 && e.every((i) => Array.isArray(i) && i.length === 3))
-      t = e;
+    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 n = this.lattice.map(
-      (i) => $(t, i)
-    ), o = this.sites.map((i) => {
-      const a = $(
-        t,
-        i.cart
+    const t = this.lattice.map(
+      (o) => j(e, o)
+    ), i = this.sites.map((o) => {
+      const a = j(
+        e,
+        o.cart
       );
-      return new x(i.speciesIndex, a, i.props);
+      return new v(o.speciesIndex, a, o.props);
     });
-    return new w({
-      lattice: n,
+    return new I({
+      lattice: t,
       species: [...this.species],
-      sites: o
+      sites: i
     });
   }
   // ---------- Internal validation ----------
@@ -186,38 +186,38 @@ class w {
    * Validates that the lattice is a 3x3 array of Cartesian vectors.
    * @throws Will throw an error if lattice is invalid
    */
-  _validateLattice(e) {
-    if (!Array.isArray(e) || e.length !== 3)
+  _validateLattice(s) {
+    if (!Array.isArray(s) || s.length !== 3)
       throw new Error("Lattice must be a 3x3 matrix");
-    return e.forEach((t) => {
-      if (!Array.isArray(t) || t.length !== 3)
+    return s.forEach((e) => {
+      if (!Array.isArray(e) || e.length !== 3)
         throw new Error("Lattice vectors must be length 3");
-    }), e;
+    }), s;
   }
   /**
    * Validates that species is an array of strings.
    * @throws Will throw an error if species array is invalid
    */
-  _validateSpecies(e) {
-    if (!Array.isArray(e)) throw new Error("Species must be an array");
-    return e.forEach((t) => {
-      if (typeof t != "string")
+  _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");
-    }), e;
+    }), 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(e) {
-    if (!Array.isArray(e)) throw new Error("Sites must be an array");
-    return e.map((t) => {
-      if (t instanceof x) return t;
-      if (typeof t == "object" && typeof t.speciesIndex == "number" && Array.isArray(t.cart) && t.cart.length === 3)
-        return this._validateSpeciesIndex(t.speciesIndex), new x(
-          t.speciesIndex,
-          t.cart,
-          t.props ?? {}
+  _validateSites(s) {
+    if (!Array.isArray(s)) throw new Error("Sites must be an array");
+    return s.map((e) => {
+      if (e instanceof v) return e;
+      if (typeof e == "object" && typeof e.speciesIndex == "number" && Array.isArray(e.cart) && e.cart.length === 3)
+        return this._validateSpeciesIndex(e.speciesIndex), new v(
+          e.speciesIndex,
+          e.cart,
+          e.props ?? {}
         );
       throw new Error(
         "Each site must be a Site instance or a valid site object"
@@ -228,230 +228,305 @@ class w {
    * Validates that a species index is within bounds.
    * @throws Will throw an error if index is out of range
    */
-  _validateSpeciesIndex(e) {
-    if (e < 0 || e >= this.species.length)
+  _validateSpeciesIndex(s) {
+    if (s < 0 || s >= this.species.length)
       throw new Error("speciesIndex out of bounds");
   }
 }
-function F(s) {
-  return s.split(/\r?\n/).map((e) => e.trim()).filter(Boolean);
+class X {
+  constructor(s) {
+    this.spatialUnits = "angstrom", this._invalid = !0;
+    const { origin: e, basis: t, shape: i, values: o, components: a = 1, units: b } = s, [n, u, h] = i;
+    if (o.length !== n * u * h * a)
+      throw new Error(
+        `Invalid values length: expected ${n * u * h * a}, got ${o.length}`
+      );
+    this.origin = e, this.basis = t, this.shape = i, this.values = o, this.components = a, this.units = b;
+  }
+  invalidate() {
+    this._invalid = !0;
+  }
+  map(s) {
+    const [e, t, i] = this.shape;
+    for (let o = 0; o < i; o++)
+      for (let a = 0; a < t; a++)
+        for (let b = 0; b < e; b++)
+          for (let n = 0; n < this.components; n++) {
+            const u = this.index(b, a, o, n);
+            this.values[u] = s(this.values[u], b, a, o, n);
+          }
+    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, i = 0) {
+    const [o, a] = this.shape;
+    return (s + o * (e + a * t)) * this.components + i;
+  }
+  get(s, e, t, i = 0) {
+    return this.values[this.index(s, e, t, i)];
+  }
+  set(s, e, t, i, o) {
+    this.values[this.index(s, e, t, i)] = o, 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 [i, o, a] = this.basis;
+    return [
+      this.origin[0] + s * i[0] + e * o[0] + t * a[0],
+      this.origin[1] + s * i[1] + e * o[1] + t * a[1],
+      this.origin[2] + s * i[2] + e * o[2] + t * a[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, i = 0;
+    for (let o = 0; o < s; o++) {
+      const a = this.values[o];
+      a < e && (e = a), a > t && (t = a), i += a;
+    }
+    this._min = e, this._max = t, this._mean = i / s, this._invalid = !1;
+  }
+}
+function F(m) {
+  return m.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
 }
-function P(s, e = 6) {
-  const t = [], n = C(s);
-  t.push("Generated by matsci-parse"), t.push("1.0"), s.lattice.forEach((a) => {
-    t.push(a.map((c) => c.toFixed(e)).join(" "));
+function K(m, s = 6) {
+  const e = [], t = B(m);
+  e.push("Generated by matsci-parse"), e.push("1.0"), m.lattice.forEach((a) => {
+    e.push(a.map((b) => b.toFixed(s)).join(" "));
   });
-  const o = Array.from(
-    new Set(s.sites.map((a) => s.species[a.speciesIndex]))
-  ), i = o.map(
-    (a) => s.sites.filter((c) => s.species[c.speciesIndex] === a).length
+  const i = Array.from(
+    new Set(m.sites.map((a) => m.species[a.speciesIndex]))
+  ), o = i.map(
+    (a) => m.sites.filter((b) => m.species[b.speciesIndex] === a).length
   );
-  return t.push(o.join(" ")), t.push(i.join(" ")), n && t.push("Selective dynamics"), t.push("Cartesian"), o.forEach((a) => {
-    s.sites.filter((c) => s.species[c.speciesIndex] === a).forEach((c) => {
-      const h = c.cart.map((m) => m.toFixed(e)).join(" ");
-      if (n) {
-        const p = (Array.isArray(c.props?.selectiveDynamics) ? c.props.selectiveDynamics : [!0, !0, !0]).map((u) => u ? "T" : "F").join(" ");
-        t.push(`${h} ${p}`);
+  return e.push(i.join(" ")), e.push(o.join(" ")), t && e.push("Selective dynamics"), e.push("Cartesian"), i.forEach((a) => {
+    m.sites.filter((b) => m.species[b.speciesIndex] === a).forEach((b) => {
+      const n = b.cart.map((u) => u.toFixed(s)).join(" ");
+      if (t) {
+        const h = (Array.isArray(b.props?.selectiveDynamics) ? b.props.selectiveDynamics : [!0, !0, !0]).map((c) => c ? "T" : "F").join(" ");
+        e.push(`${n} ${h}`);
       } else
-        t.push(h);
+        e.push(n);
     });
-  }), t.join(`
+  }), e.join(`
 `);
 }
-function j(s) {
-  let e = 0;
-  e++;
-  const t = parseFloat(s[e++]), n = [];
-  for (let u = 0; u < 3; u++)
-    n.push(
-      s[e++].split(/\s+/).map((l) => parseFloat(l) * t)
+function Z(m) {
+  let s = 0;
+  s++;
+  const e = parseFloat(m[s++]), t = [];
+  for (let c = 0; c < 3; c++)
+    t.push(
+      m[s++].split(/\s+/).map((l) => parseFloat(l) * e)
     );
-  let o = s[e].trim(), i;
-  /^[A-Za-z]/.test(o) && (i = o.split(/\s+/), e++);
-  const a = s[e++].split(/\s+/).map(Number);
-  i || (i = a.map((u, l) => `X${l + 1}`));
-  let c = !1;
-  s[e]?.toLowerCase().startsWith("s") && (c = !0, e++);
-  const m = s[e++].toLowerCase().startsWith("d"), p = [];
-  return i.forEach((u, l) => {
-    for (let d = 0; d < a[l]; d++) {
-      const r = s[e++].split(/\s+/).map(Number);
-      let f;
-      m ? f = [
-        r[0] * n[0][0] + r[1] * n[1][0] + r[2] * n[2][0],
-        r[0] * n[0][1] + r[1] * n[1][1] + r[2] * n[2][1],
-        r[0] * n[0][2] + r[1] * n[1][2] + r[2] * n[2][2]
-      ] : f = r.slice(0, 3);
-      const g = {};
-      if (c) {
-        const y = r.slice(3, 6).map((_) => _ === 1);
-        y.length === 3 && (g.selectiveDynamics = y);
+  let i = m[s].trim(), o;
+  /^[A-Za-z]/.test(i) && (o = i.split(/\s+/), s++);
+  const a = m[s++].split(/\s+/).map(Number);
+  o || (o = a.map((c, l) => `X${l + 1}`));
+  let b = !1;
+  m[s]?.toLowerCase().startsWith("s") && (b = !0, s++);
+  const u = m[s++].toLowerCase().startsWith("d"), h = [];
+  return o.forEach((c, l) => {
+    for (let f = 0; f < a[l]; f++) {
+      const r = m[s++].split(/\s+/).map(Number);
+      let p;
+      u ? p = [
+        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]
+      ] : p = r.slice(0, 3);
+      const N = {};
+      if (b) {
+        const g = r.slice(3, 6).map((_) => _ === 1);
+        g.length === 3 && (N.selectiveDynamics = g);
       }
-      p.push(new x(l, f, g));
+      h.push(new v(l, p, N));
     }
   }), {
-    structure: new w({ lattice: n, species: i, sites: p }),
-    linesConsumed: e
+    structure: new I({ lattice: t, species: o, sites: h }),
+    linesConsumed: s
   };
 }
-function R(s) {
-  const e = F(s);
-  return j(e).structure;
+function J(m) {
+  const s = F(m);
+  return Z(s).structure;
 }
-function W(s, e = 6) {
-  const t = [];
-  return t.push("CRYSTAL"), t.push("PRIMVEC"), s.lattice.forEach((n) => {
-    t.push(n.map((o) => o.toFixed(e)).join(" "));
-  }), t.push("PRIMCOORD"), t.push(`${s.numSites} 1`), s.sites.forEach((n) => {
-    const o = s.species[n.speciesIndex];
-    t.push(
-      `${o} ${n.cart.map((i) => i.toFixed(e)).join(" ")}`
+function Q(m, s = 6) {
+  const e = [];
+  return e.push("CRYSTAL"), e.push("PRIMVEC"), m.lattice.forEach((t) => {
+    e.push(t.map((i) => i.toFixed(s)).join(" "));
+  }), e.push("PRIMCOORD"), e.push(`${m.numSites} 1`), m.sites.forEach((t) => {
+    const i = m.species[t.speciesIndex];
+    e.push(
+      `${i} ${t.cart.map((o) => o.toFixed(s)).join(" ")}`
     );
-  }), t.join(`
+  }), e.join(`
 `);
 }
-function O(s) {
-  const e = F(s), t = [], n = [], o = [];
-  let i = 0;
-  for (; i < e.length && e[i].toUpperCase() !== "PRIMVEC"; ) i++;
-  if (i === e.length) throw new Error("PRIMVEC block not found in XSF");
-  i++;
-  for (let c = 0; c < 3; c++)
-    t.push(e[i++].split(/\s+/).map(Number));
-  for (; i < e.length && e[i].toUpperCase() !== "PRIMCOORD"; ) i++;
-  if (i === e.length) throw new Error("PRIMCOORD block not found in XSF");
-  i++;
-  const [a] = e[i++].split(/\s+/).map(Number);
-  for (let c = 0; c < a; c++) {
-    const h = e[i++].split(/\s+/), m = h[0], p = h.slice(1, 4).map(Number);
-    let u = n.indexOf(m);
-    u === -1 && (n.push(m), u = n.length - 1), o.push(new x(u, p));
+function ss(m) {
+  const s = F(m), e = [], t = [], i = [];
+  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 b = 0; b < 3; b++)
+    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 [a] = s[o++].split(/\s+/).map(Number);
+  for (let b = 0; b < a; b++) {
+    const n = s[o++].split(/\s+/), u = n[0], h = n.slice(1, 4).map(Number);
+    let c = t.indexOf(u);
+    c === -1 && (t.push(u), c = t.length - 1), i.push(new v(c, h));
   }
-  return new w({ lattice: t, species: n, sites: o });
+  return new I({ lattice: e, species: t, sites: i });
 }
-function X(s, e = 6) {
-  const t = [], n = s.sites.length;
-  t.push(String(n));
-  const o = C(s), i = s.lattice, a = [
-    i[0][0],
-    i[1][0],
-    i[2][0],
-    i[0][1],
-    i[1][1],
-    i[2][1],
-    i[0][2],
-    i[1][2],
-    i[2][2]
-  ].join(" "), c = [
+function es(m, s = 6) {
+  const e = [], t = m.sites.length;
+  e.push(String(t));
+  const i = B(m), o = m.lattice, a = [
+    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(" "), b = [
     "species:S:1",
     "pos:R:3",
-    o ? "selectiveDynamics:L:3" : null
+    i ? "selectiveDynamics:L:3" : null
   ].filter(Boolean).join(":");
-  t.push(`Lattice="${a}" Properties=${c}`);
-  for (const h of s.sites) {
-    const m = s.species[h.speciesIndex], [p, u, l] = h.cart;
-    let d = `${m} ${p.toFixed(e)} ${u.toFixed(e)} ${l.toFixed(e)}`;
-    if (o) {
-      const r = Array.isArray(h.props?.selectiveDynamics) ? h.props.selectiveDynamics : [!0, !0, !0];
-      d += " " + r.map((f) => f ? "T" : "F").join(" ");
+  e.push(`Lattice="${a}" Properties=${b}`);
+  for (const n of m.sites) {
+    const u = m.species[n.speciesIndex], [h, c, l] = n.cart;
+    let f = `${u} ${h.toFixed(s)} ${c.toFixed(s)} ${l.toFixed(s)}`;
+    if (i) {
+      const r = Array.isArray(n.props?.selectiveDynamics) ? n.props.selectiveDynamics : [!0, !0, !0];
+      f += " " + r.map((p) => p ? "T" : "F").join(" ");
     }
-    t.push(d);
+    e.push(f);
   }
-  return t.join(`
+  return e.join(`
 `);
 }
-function N(s) {
-  const e = F(s);
-  let t = 0;
-  const n = parseInt(e[t++], 10);
-  if (!Number.isFinite(n))
+function ts(m) {
+  const s = F(m);
+  let e = 0;
+  const t = parseInt(s[e++], 10);
+  if (!Number.isFinite(t))
     throw new Error("Invalid XYZ: first line must be atom count");
-  const o = e[t++], i = {}, a = /(\w+)=(".*?"|\S+)/g;
-  for (const r of o.matchAll(a)) {
-    let f = r[2];
-    f.startsWith('"') && (f = f.slice(1, -1)), i[r[1]] = f;
-  }
-  let c;
-  if (i.Lattice) {
-    const r = i.Lattice.split(/\s+/).map(Number);
+  const i = s[e++], o = {}, a = /(\w+)=(".*?"|\S+)/g;
+  for (const r of i.matchAll(a)) {
+    let p = r[2];
+    p.startsWith('"') && (p = p.slice(1, -1)), o[r[1]] = p;
+  }
+  let b;
+  if (o.Lattice) {
+    const r = o.Lattice.split(/\s+/).map(Number);
     if (r.length !== 9) throw new Error("Invalid Lattice in extended XYZ");
-    c = [
+    b = [
       [r[0], r[3], r[6]],
       [r[1], r[4], r[7]],
       [r[2], r[5], r[8]]
     ];
   } else
     throw new Error("Lattice must be present in extended XYZ format");
-  let h = 0, m = 1, p = null;
-  if (i.Properties) {
-    const r = i.Properties.split(":");
-    let f = 0;
-    for (let g = 0; g < r.length; g += 3) {
-      const y = r[g], _ = parseInt(r[g + 2], 10);
-      y === "species" && (h = f), y === "pos" && (m = f), y === "selectiveDynamics" && (p = f), f += _;
+  let n = 0, u = 1, h = null;
+  if (o.Properties) {
+    const r = o.Properties.split(":");
+    let p = 0;
+    for (let N = 0; N < r.length; N += 3) {
+      const g = r[N], _ = parseInt(r[N + 2], 10);
+      g === "species" && (n = p), g === "pos" && (u = p), g === "selectiveDynamics" && (h = p), p += _;
     }
   }
-  const u = [], l = /* @__PURE__ */ new Map(), d = [];
-  for (let r = 0; r < n; r++) {
-    const f = e[t++].split(/\s+/), g = f[h];
-    l.has(g) || (l.set(g, u.length), u.push(g));
-    const y = l.get(g), _ = f.slice(m, m + 3).map(Number), S = {};
-    if (p !== null) {
-      const I = f.slice(p, p + 3).map((b) => b.toUpperCase() === "T");
-      I.length === 3 && (S.selectiveDynamics = I);
+  const c = [], l = /* @__PURE__ */ new Map(), f = [];
+  for (let r = 0; r < t; r++) {
+    const p = s[e++].split(/\s+/), N = p[n];
+    l.has(N) || (l.set(N, c.length), c.push(N));
+    const g = l.get(N), _ = p.slice(u, u + 3).map(Number), S = {};
+    if (h !== null) {
+      const y = p.slice(h, h + 3).map((d) => d.toUpperCase() === "T");
+      y.length === 3 && (S.selectiveDynamics = y);
     }
-    d.push(new x(y, _, S));
+    f.push(new v(g, _, S));
   }
-  return new w({ lattice: c, species: u, sites: d });
+  return new I({ lattice: b, species: c, sites: f });
 }
-function v(s, e) {
-  return s[0] * e[0] + s[1] * e[1] + s[2] * e[2];
+function C(m, s) {
+  return m[0] * s[0] + m[1] * s[1] + m[2] * s[2];
 }
-function A(s) {
-  return Math.sqrt(v(s, s));
+function L(m) {
+  return Math.sqrt(C(m, m));
 }
-function M(s) {
-  return s * 180 / Math.PI;
+function P(m) {
+  return m * 180 / Math.PI;
 }
-function D(s, e) {
-  const [t, n, o] = e, i = t[0] * (n[1] * o[2] - n[2] * o[1]) - t[1] * (n[0] * o[2] - n[2] * o[0]) + t[2] * (n[0] * o[1] - n[1] * o[0]);
-  if (Math.abs(i) < 1e-12)
+function z(m, s) {
+  const [e, t, i] = s, o = e[0] * (t[1] * i[2] - t[2] * i[1]) - e[1] * (t[0] * i[2] - t[2] * i[0]) + e[2] * (t[0] * i[1] - t[1] * i[0]);
+  if (Math.abs(o) < 1e-12)
     throw new Error("Singular lattice matrix");
   const a = [
     [
-      (n[1] * o[2] - n[2] * o[1]) / i,
-      (t[2] * o[1] - t[1] * o[2]) / i,
-      (t[1] * n[2] - t[2] * n[1]) / i
+      (t[1] * i[2] - t[2] * i[1]) / o,
+      (e[2] * i[1] - e[1] * i[2]) / o,
+      (e[1] * t[2] - e[2] * t[1]) / o
     ],
     [
-      (n[2] * o[0] - n[0] * o[2]) / i,
-      (t[0] * o[2] - t[2] * o[0]) / i,
-      (t[2] * n[0] - t[0] * n[2]) / i
+      (t[2] * i[0] - t[0] * i[2]) / o,
+      (e[0] * i[2] - e[2] * i[0]) / o,
+      (e[2] * t[0] - e[0] * t[2]) / o
     ],
     [
-      (n[0] * o[1] - n[1] * o[0]) / i,
-      (t[1] * o[0] - t[0] * o[1]) / i,
-      (t[0] * n[1] - t[1] * n[0]) / i
+      (t[0] * i[1] - t[1] * i[0]) / o,
+      (e[1] * i[0] - e[0] * i[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]
+    m[0] * a[0][0] + m[1] * a[1][0] + m[2] * a[2][0],
+    m[0] * a[0][1] + m[1] * a[1][1] + m[2] * a[2][1],
+    m[0] * a[0][2] + m[1] * a[1][2] + m[2] * a[2][2]
   ];
 }
-function z(s, e = 6) {
-  const [t, n, o] = s.lattice, i = A(t), a = A(n), c = A(o), h = M(Math.acos(v(n, o) / (a * c))), m = M(Math.acos(v(t, o) / (i * c))), p = M(Math.acos(v(t, n) / (i * a)));
-  let u = `data_made_with_matsci-parse
+function ms(m, s = 6) {
+  const [e, t, i] = m.lattice, o = L(e), a = L(t), b = L(i), n = P(Math.acos(C(t, i) / (a * b))), u = P(Math.acos(C(e, i) / (o * b))), h = P(Math.acos(C(e, t) / (o * a)));
+  let c = `data_made_with_matsci-parse
     _symmetry_space_group_name_H-M   'P 1'
     _symmetry_Int_Tables_number    1
 
-    _cell_length_a   ${i.toFixed(e)}
-    _cell_length_b   ${a.toFixed(e)}
-    _cell_length_c   ${c.toFixed(e)}
-    _cell_angle_alpha   ${h.toFixed(e)}
-    _cell_angle_beta    ${m.toFixed(e)}
-    _cell_angle_gamma   ${p.toFixed(e)}
+    _cell_length_a   ${o.toFixed(s)}
+    _cell_length_b   ${a.toFixed(s)}
+    _cell_length_c   ${b.toFixed(s)}
+    _cell_angle_alpha   ${n.toFixed(s)}
+    _cell_angle_beta    ${u.toFixed(s)}
+    _cell_angle_gamma   ${h.toFixed(s)}
 
     loop_
     _atom_site_label
@@ -460,70 +535,405 @@ function z(s, e = 6) {
     _atom_site_fract_y
     _atom_site_fract_z
 `;
-  return s.sites.forEach((l, d) => {
-    const r = s.species[l.speciesIndex], f = D(l.cart, s.lattice);
-    u += `${r}${d + 1} ${r} ${f[0].toFixed(e)} ${f[1].toFixed(
+  return m.sites.forEach((l, f) => {
+    const r = m.species[l.speciesIndex], p = z(l.cart, m.lattice);
+    c += `${r}${f + 1} ${r} ${p[0].toFixed(s)} ${p[1].toFixed(
       6
-    )} ${f[2].toFixed(e)}
+    )} ${p[2].toFixed(s)}
 `;
-  }), u;
+  }), c;
+}
+function os(m) {
+  const s = F(m);
+  let e = 0, t = 0, i = 0, o = 0, a = 0, b = 0, n = [];
+  const u = [];
+  let h = !1, c = [], l = !1;
+  for (const y of s) {
+    const d = y.trim();
+    if (d) {
+      if (d.startsWith("_cell_length_a")) e = parseFloat(d.split(/\s+/)[1]);
+      else if (d.startsWith("_cell_length_b"))
+        t = parseFloat(d.split(/\s+/)[1]);
+      else if (d.startsWith("_cell_length_c"))
+        i = parseFloat(d.split(/\s+/)[1]);
+      else if (d.startsWith("_cell_angle_alpha"))
+        o = parseFloat(d.split(/\s+/)[1]);
+      else if (d.startsWith("_cell_angle_beta"))
+        a = parseFloat(d.split(/\s+/)[1]);
+      else if (d.startsWith("_cell_angle_gamma"))
+        b = parseFloat(d.split(/\s+/)[1]);
+      else if (d.startsWith("loop_")) {
+        h = !0, c = [], l = !1;
+        continue;
+      }
+      if (h && d.startsWith("_")) {
+        c.push(d), d.includes("_atom_site_") && (l = !0);
+        continue;
+      }
+      if (h && !d.startsWith("_")) {
+        l && (n.length === 0 && (n = [...c]), u.push(d.split(/\s+/)));
+        continue;
+      }
+    }
+  }
+  if (n.length === 0)
+    throw new Error("No _atom_site loop found in CIF");
+  const f = k(e, t, i, o, a, b), r = [], p = [], N = n.findIndex((y) => y.includes("fract_x")), g = n.findIndex((y) => y.includes("fract_y")), _ = n.findIndex((y) => y.includes("fract_z")), S = n.findIndex((y) => y.includes("type_symbol"));
+  if (N < 0 || g < 0 || _ < 0 || S < 0)
+    throw new Error("CIF missing required _atom_site columns");
+  for (const y of u) {
+    const d = [
+      parseFloat(y[N]),
+      parseFloat(y[g]),
+      parseFloat(y[_])
+    ], w = U(d, f);
+    let x = r.indexOf(y[S]);
+    x === -1 && (x = r.length, r.push(y[S])), p.push(new v(x, w));
+  }
+  return new I({ lattice: f, species: r, sites: p });
 }
-function V(s) {
-  const e = F(s);
-  let t = 0, n = 0, o = 0, i = 0, a = 0, c = 0;
-  const h = [], m = [];
-  let p = 0;
-  for (; p < e.length; ) {
-    const l = e[p].trim();
-    if (l.startsWith("_cell_length_a")) t = parseFloat(l.split(/\s+/)[1]);
-    else if (l.startsWith("_cell_length_b"))
-      n = parseFloat(l.split(/\s+/)[1]);
-    else if (l.startsWith("_cell_length_c"))
-      o = parseFloat(l.split(/\s+/)[1]);
-    else if (l.startsWith("_cell_angle_alpha"))
-      i = parseFloat(l.split(/\s+/)[1]);
-    else if (l.startsWith("_cell_angle_beta"))
-      a = parseFloat(l.split(/\s+/)[1]);
-    else if (l.startsWith("_cell_angle_gamma"))
-      c = parseFloat(l.split(/\s+/)[1]);
-    else if (l.startsWith("loop_")) {
-      p++;
-      const d = [];
-      for (; p < e.length && e[p].trim().startsWith("_"); )
-        d.push(e[p].trim()), p++;
-      if (d.some((r) => r.includes("_atom_site_"))) {
-        const r = d.findIndex((_) => _.includes("fract_x")), f = d.findIndex((_) => _.includes("fract_y")), g = d.findIndex((_) => _.includes("fract_z")), y = d.findIndex((_) => _.includes("type_symbol"));
-        if (r < 0 || f < 0 || g < 0 || y < 0)
-          throw new Error("CIF missing required _atom_site columns");
-        for (; p < e.length && e[p].trim() && !e[p].trim().startsWith("_") && !e[p].trim().startsWith("loop_"); ) {
-          const _ = e[p].trim().split(/\s+/), S = [
-            parseFloat(_[r]),
-            parseFloat(_[f]),
-            parseFloat(_[g])
-          ], I = L(
-            S,
-            T(t, n, o, i, a, c)
-          );
-          let b = h.indexOf(_[y]);
-          b === -1 && (b = h.length, h.push(_[y])), m.push(new x(b, I)), p++;
-        }
+function G(m) {
+  let s = [];
+  const e = [];
+  for (let n = 0; n < m.length; n++) {
+    const u = m[n].trim();
+    if (!(!u || u.startsWith("&")) && /^CELL_PARAMETERS/i.test(u)) {
+      let h = 0, c = n + 1;
+      for (; h < 3 && c < m.length; ) {
+        const l = m[c].trim();
+        l !== "" && (s.push(l.split(/\s+/).map(Number)), h++), c++;
+      }
+      if (h < 3) throw new Error("Incomplete CELL_PARAMETERS block");
+      break;
+    }
+  }
+  if (s.length !== 3)
+    throw new Error("CELL_PARAMETERS block not found or incomplete");
+  let t = !1, i = "angstrom";
+  for (let n = 0; n < m.length; n++) {
+    const u = m[n].trim();
+    if (!(!u || u.startsWith("&"))) {
+      if (/^ATOMIC_POSITIONS/i.test(u)) {
+        t = !0;
+        const h = u.match(/^ATOMIC_POSITIONS\s+(\w+)/i);
+        i = h ? h[1].toLowerCase() : "angstrom";
         continue;
       }
+      if (t) {
+        const h = u.split(/\s+/);
+        if (h.length < 4 || !/^[A-Za-z]/.test(h[0]) || h.slice(1, 4).some((c) => Number.isNaN(Number(c))))
+          break;
+        e.push(u);
+      }
     }
-    p++;
   }
-  const u = T(t, n, o, i, a, c);
-  return new w({ lattice: u, species: h, sites: m });
+  if (e.length === 0)
+    throw new Error("ATOMIC_POSITIONS block not found");
+  const o = i === "crystal", a = [];
+  for (const n of e) {
+    const u = n.split(/\s+/)[0];
+    a.includes(u) || a.push(u);
+  }
+  const b = [];
+  for (const n of e) {
+    const u = n.split(/\s+/), h = u[0], c = u.slice(1, 4).map(Number);
+    let l;
+    o ? l = [
+      c[0] * s[0][0] + c[1] * s[1][0] + c[2] * s[2][0],
+      c[0] * s[0][1] + c[1] * s[1][1] + c[2] * s[2][1],
+      c[0] * s[0][2] + c[1] * s[1][2] + c[2] * s[2][2]
+    ] : l = c, b.push(new v(a.indexOf(h), l));
+  }
+  return {
+    structure: new I({ lattice: s, species: a, sites: b }),
+    linesConsumed: m.length
+  };
+}
+function is(m) {
+  const s = F(m);
+  return G(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 }
+}, Y = {
+  angstrom: 1,
+  // canonical
+  bohr: 0.529177,
+  nm: 10,
+  pm: 0.01,
+  um: 1e4,
+  cm: 1e8,
+  m: 1e10,
+  fm: 1e-5
+}, q = {
+  Å: "angstrom",
+  μm: "um"
+}, R = {
+  conversions: Y,
+  aliases: q,
+  convert(m, s, e) {
+    const t = (a) => this.aliases[a] ?? a, i = t(s), o = t(e);
+    return i === o ? m : m * this.conversions[i] / this.conversions[o];
+  },
+  convertArray(m, s, e) {
+    return m.map((t) => this.convert(t, s, e));
+  }
+}, $ = 1.8897268;
+function as(m, s) {
+  const e = [];
+  e.push("Generated by matsci-parse"), e.push("Volumetric data export");
+  const i = [...s.origin].map((l) => l * $);
+  e.push(
+    `${m.numSites} ${i.map((l) => l.toFixed(6)).join(" ")}`
+  );
+  const o = s.shape, a = s.basis;
+  for (let l = 0; l < 3; l++) {
+    a[l];
+    const f = a[l].map((r) => r * $);
+    e.push(`${o[l]} ${f.map((r) => r.toFixed(6)).join(" ")}`);
+  }
+  for (const l of m.sites) {
+    const f = m.species[l.speciesIndex], r = Object.values(D).find(
+      (g) => g.symbol === f
+    )?.atomicNumber;
+    if (!r)
+      throw new Error(`Unknown element symbol: ${f}`);
+    [...l.cart];
+    const p = l.cart.map((g) => g * $), N = (l.getProp("charge") ?? 0).toFixed(6);
+    e.push(
+      `${r} ${N} ${p.map((g) => g.toFixed(6)).join(" ")}`
+    );
+  }
+  const b = s.values, [n, u, h] = o;
+  let c = [];
+  for (let l = 0; l < h; l++)
+    for (let f = 0; f < u; f++)
+      for (let r = 0; r < n; r++) {
+        const p = s.index(r, f, l);
+        c.push(b[p].toExponential(8)), c.length === 6 && (e.push(c.join(" ")), c = []);
+      }
+  return c.length > 0 && e.push(c.join(" ")), e.join(`
+`);
+}
+function V(m, s = "bohr", e = "bohr", t = "bohr") {
+  let i = 0;
+  i += 2;
+  const o = m[i].split(/\s+/), a = parseInt(o[0]);
+  let b = [
+    parseFloat(o[1]),
+    parseFloat(o[2]),
+    parseFloat(o[3])
+  ];
+  i++;
+  const n = m[i++].split(/\s+/), u = m[i++].split(/\s+/), h = m[i++].split(/\s+/);
+  let c = [
+    [parseFloat(n[1]), parseFloat(n[2]), parseFloat(n[3])],
+    [parseFloat(u[1]), parseFloat(u[2]), parseFloat(u[3])],
+    [
+      parseFloat(h[1]),
+      parseFloat(h[2]),
+      parseFloat(h[3])
+    ]
+  ];
+  const l = [
+    parseInt(n[0], 10),
+    parseInt(u[0], 10),
+    parseInt(h[0], 10)
+  ], f = [], r = /* @__PURE__ */ new Map(), p = [];
+  for (let w = 0; w < a; w++, i++) {
+    const x = m[i].trim().split(/\s+/);
+    if (x.length < 5) throw new Error(`Malformed atom line: "${m[i]}"`);
+    const A = parseInt(x[0], 10), H = parseFloat(x[1]), W = [
+      parseFloat(x[2]),
+      parseFloat(x[3]),
+      parseFloat(x[4])
+    ], O = D[A];
+    if (!O) throw new Error(`Unknown atomic number: ${A}`);
+    const E = O.symbol;
+    let T = r.get(E);
+    T === void 0 && (T = f.length, f.push(E), r.set(E, T)), p.push(new v(T, W, { charge: H }));
+  }
+  b = R.convertArray(
+    b,
+    s,
+    "angstrom"
+  ), c = c.map(
+    (w) => R.convertArray(
+      w,
+      t,
+      "angstrom"
+    )
+  ), p.forEach((w) => {
+    w.cart = R.convertArray(
+      w.cart,
+      e,
+      "angstrom"
+    );
+  });
+  const N = c.map(
+    (w, x) => w.map((A) => A * l[x])
+  ), g = new I({
+    lattice: N,
+    species: f,
+    sites: p
+  }), _ = l[0] * l[1] * l[2], S = new Float32Array(_);
+  let y = 0;
+  for (; i < m.length && y < _; ) {
+    const w = m[i++].trim().split(/\s+/);
+    for (const x of w)
+      x && y < _ && (S[y] = parseFloat(x), y++);
+  }
+  if (console.log("numVals", _), y !== _)
+    throw new Error(`Cube file truncated: expected ${_}, got ${y}`);
+  const d = new X({
+    origin: b,
+    basis: c,
+    shape: l,
+    values: S,
+    units: "e/ų"
+  });
+  return { structure: g, volumetricData: d, linesConsumed: i };
+}
+function ns(m) {
+  const s = F(m);
+  return V(s).volumetricData;
+}
+function rs(m) {
+  const s = F(m);
+  return V(s).structure;
 }
 export {
-  w as CrystalStructure,
-  x as Site,
-  V as cifToStructure,
-  R as poscarToStructure,
-  z as structureToCif,
-  P as structureToPoscar,
-  W as structureToXsf,
-  X as structureToXyz,
-  O as xsfToStructure,
-  N as xyzToStructure
+  I as CrystalStructure,
+  v as Site,
+  X as VolumetricData,
+  os as cifToStructure,
+  rs as cubeToStructure,
+  ns as cubeToVolumetric,
+  V as parseCube,
+  J as poscarToStructure,
+  is as pwToStructure,
+  ms as structureToCif,
+  K as structureToPoscar,
+  Q as structureToXsf,
+  es as structureToXyz,
+  as as volumetricToCube,
+  ss as xsfToStructure,
+  ts as xyzToStructure
 };

package/package.json

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