@mat3ra/made 2026.6.29-0 → 2026.7.8-0

package/dist/js/basis/basis.js

@@ -4,7 +4,7 @@ exports.Basis = void 0;
 // @ts-ignore
 const periodic_table_js_1 = require("@exabyte-io/periodic-table.js");
 const entity_1 = require("@mat3ra/code/dist/js/entity");
-const math_1 = require("@mat3ra/code/dist/js/math");
+const utils_1 = require("@mat3ra/utils");
 const lodash_1 = require("lodash");
 const cell_1 = require("../cell/cell");
 const constants_1 = require("../constants");
@@ -163,7 +163,7 @@ class Basis extends entity_1.InMemoryEntity {
     }
     toStandardRepresentation() {
         this.toCrystal();
-        this._coordinates.mapArrayInPlace((point) => point.map((x) => math_1.math.mod(x)));
+        this._coordinates.mapArrayInPlace((point) => point.map((x) => utils_1.Utils.math.mod(x)));
     }
     /** A representation where all coordinates are within 0 and 1 in crystal units */
     get standardRepresentation() {
@@ -237,7 +237,7 @@ class Basis extends entity_1.InMemoryEntity {
     get formula() {
         const counts = this.uniqueElementCountsSortedByElectronegativity;
         const countsValues = (0, lodash_1.values)(counts);
-        const gcd = countsValues.length > 1 ? math_1.math.gcd(...countsValues) : countsValues[0];
+        const gcd = countsValues.length > 1 ? utils_1.Utils.math.gcd(...countsValues) : countsValues[0];
         return (0, lodash_1.toPairs)(counts)
             .map(([element, count]) => element + (count / gcd === 1 ? "" : count / gcd))
             .reduce((acc, part) => acc + part, "");
@@ -290,7 +290,7 @@ class Basis extends entity_1.InMemoryEntity {
             const element = entry[0];
             const coordinate = entry[1];
             const atomicLabel = entry[2];
-            const toleratedCoordinate = coordinate.map((x) => math_1.math.round(x, constants_1.HASH_TOLERANCE));
+            const toleratedCoordinate = coordinate.map((x) => utils_1.Utils.math.roundCustom(x, constants_1.HASH_TOLERANCE));
             return `${element}${atomicLabel} ${toleratedCoordinate.join()}`;
         });
         return `${standardRep.sort().join(";")};`;
@@ -361,7 +361,7 @@ class Basis extends entity_1.InMemoryEntity {
     hasEquivalentCellTo(anotherBasisClsInstance) {
         return !this.cell.vectorArrays
             .map((vector, idx) => {
-            return math_1.math.vEqualWithTolerance(vector, anotherBasisClsInstance.cell.vectorArrays[idx]);
+            return utils_1.Utils.math.vEqualWithTolerance(vector, anotherBasisClsInstance.cell.vectorArrays[idx]);
         })
             .some((x) => !x);
     }
@@ -380,7 +380,7 @@ class Basis extends entity_1.InMemoryEntity {
         const maxDistance = this.maxPairwiseDistance;
         const minDistance = this.minPairwiseDistance;
         const widthRatio = maxDistance > 0 ? minDistance / maxDistance : 1;
-        const latticeScalingFactor = math_1.math.almostEqual(widthRatio, 1)
+        const latticeScalingFactor = utils_1.Utils.math.almostEqual(widthRatio, 1)
             ? lattice_1.diatomicLatticePaddingFactor
             : lattice_1.molecularLatticePaddingFactor;
         const moleculeLatticeSize = maxDistance * latticeScalingFactor;
@@ -404,7 +404,7 @@ class Basis extends entity_1.InMemoryEntity {
                 const tolerance = overlapCoefficient *
                     ((0, periodic_table_js_1.getElementAtomicRadius)(el1) + (0, periodic_table_js_1.getElementAtomicRadius)(el2)); // in angstroms
                 // @ts-ignore
-                const distance = math_1.math.vDist(entry1.value, entry2.value);
+                const distance = utils_1.Utils.math.vDist(entry1.value, entry2.value);
                 if (distance < tolerance) {
                     overlaps.push({
                         id1: i,
@@ -446,7 +446,7 @@ class Basis extends entity_1.InMemoryEntity {
         if (this._elements.values.length >= 2) {
             for (let i = 0; i < this._elements.values.length; i++) {
                 for (let j = i + 1; j < this._elements.values.length; j++) {
-                    const distance = math_1.math.vDist(this._coordinates.getElementValueByIndex(i), this._coordinates.getElementValueByIndex(j));
+                    const distance = utils_1.Utils.math.vDist(this._coordinates.getElementValueByIndex(i), this._coordinates.getElementValueByIndex(j));
                     if (!distance)
                         continue;
                     if (extremum === "max" && distance > resultDistance) {

package/dist/js/basis/coordinates.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Coordinates = exports.Coordinate = void 0;
 const code_1 = require("@mat3ra/code");
-const math_1 = require("@mat3ra/code/dist/js/math");
+const utils_1 = require("@mat3ra/utils");
 const underscore_string_1 = require("underscore.string");
 class Coordinate extends code_1.RoundedValueWithId {
     constructor({ value, id }) {
@@ -58,7 +58,7 @@ class Coordinates extends code_1.RoundedArrayWithIds {
         });
     }
     getCenterPoint() {
-        const transposed = math_1.math.transpose(this.values);
+        const transposed = utils_1.Utils.math.transpose(this.values);
         const center = [0, 0, 0];
         for (let i = 0; i < 3; i++) {
             const axisCoords = transposed[i];

package/dist/js/cell/cell.js

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cell = void 0;
 const code_1 = require("@mat3ra/code");
-const math_1 = require("@mat3ra/code/dist/js/math");
+const utils_1 = require("@mat3ra/utils");
 const constants_1 = __importDefault(require("../constants"));
-const MATRIX = math_1.math.matrix;
-const MULT = math_1.math.multiply;
-const INV = math_1.math.inv;
+const MATRIX = utils_1.Utils.math.matrix;
+const MULT = utils_1.Utils.math.multiply;
+const INV = utils_1.Utils.math.inv;
 // @ts-ignore
 const MATRIX_MULT = (...args) => MULT(...args.map((x) => MATRIX(x))).toArray();
 class Cell {
@@ -44,10 +44,10 @@ class Cell {
         return [this._a.valueRounded, this._b.valueRounded, this._c.valueRounded];
     }
     get volume() {
-        return math_1.math.det(this.vectorArrays);
+        return utils_1.Utils.math.det(this.vectorArrays);
     }
     get volumeRounded() {
-        return math_1.math.roundArrayOrNumber(this.volume, Cell.roundPrecision);
+        return utils_1.Utils.math.roundArrayOrNumber(this.volume, Cell.roundPrecision);
     }
     clone() {
         return new Cell({ a: this.a, b: this.b, c: this.c });
@@ -66,7 +66,7 @@ class Cell {
     isPointInsideCellCartesian(point) {
         const { tolerance } = this.constructor;
         return (this.convertPointToCrystal(point)
-            .map((c) => math_1.math.isBetweenZeroInclusiveAndOne(c, tolerance))
+            .map((c) => utils_1.Utils.math.isBetweenZeroInclusiveAndOne(c, tolerance))
             // @ts-ignore
             .reduce((a, b) => a && b));
     }
@@ -74,7 +74,7 @@ class Cell {
     isPointInsideCellCrystal(point) {
         const { tolerance } = this.constructor;
         return (point
-            .map((c) => math_1.math.isBetweenZeroInclusiveAndOne(c, tolerance))
+            .map((c) => utils_1.Utils.math.isBetweenZeroInclusiveAndOne(c, tolerance))
             // @ts-ignore
             .reduce((a, b) => a && b));
     }
@@ -85,10 +85,11 @@ class Cell {
         return this.isPointInsideCellCartesian(point);
     }
     getMostCollinearVectorIndex(testVector) {
-        const angles = this.vectorArrays.map((v) => math_1.math.angleUpTo90(v, testVector, "deg"));
-        return angles.findIndex((el) => el === math_1.math.min(angles));
+        const angles = this.vectorArrays.map((v) => utils_1.Utils.math.angleUpTo90(v, testVector, "deg"));
+        return angles.findIndex((el) => el === utils_1.Utils.math.min(angles));
     }
     scaleByMatrix(matrix) {
+        // @ts-ignore - mathjs v12 multiply return type is broader than runtime
         [this.a, this.b, this.c] = MATRIX_MULT(matrix, this.vectorArrays);
     }
     toJSON() {

package/dist/js/cell/conventional_cell.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isConventionalCellSameAsPrimitiveForLatticeType = exports.PRIMITIVE_TO_CONVENTIONAL_CELL_LATTICE_TYPES = exports.PRIMITIVE_TO_CONVENTIONAL_CELL_MULTIPLIERS = void 0;
+exports.PRIMITIVE_TO_CONVENTIONAL_CELL_LATTICE_TYPES = exports.PRIMITIVE_TO_CONVENTIONAL_CELL_MULTIPLIERS = void 0;
+exports.isConventionalCellSameAsPrimitiveForLatticeType = isConventionalCellSameAsPrimitiveForLatticeType;
 /**
  * Routines for calculating conventional cell vectors from primitive cell Bravais parameters.
  * Following Setyawan, W., & Curtarolo, S. (2010). doi:10.1016/j.commatsci.2010.05.010
@@ -77,4 +78,3 @@ function isConventionalCellSameAsPrimitiveForLatticeType(latticeType) {
     const multiplier = exports.PRIMITIVE_TO_CONVENTIONAL_CELL_MULTIPLIERS[latticeType || "TRI"];
     return multiplier === unitMatrix;
 }
-exports.isConventionalCellSameAsPrimitiveForLatticeType = isConventionalCellSameAsPrimitiveForLatticeType;

package/dist/js/cell/primitive_cell.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPrimitiveLatticeVectorsFromConfig = void 0;
-const math_1 = require("@mat3ra/code/dist/js/math");
+exports.getPrimitiveLatticeVectorsFromConfig = getPrimitiveLatticeVectorsFromConfig;
+const utils_1 = require("@mat3ra/utils");
 /**
  * Routines for calculating primitive cell vectors from conventional cell Bravais parameters.
  * Following Setyawan, W., & Curtarolo, S. (2010). doi:10.1016/j.commatsci.2010.05.010
@@ -72,50 +72,49 @@ const PRIMITIVE_CELLS = {
     },
     HEX: ({ a, c }) => {
         return [
-            [a / 2, (-a * math_1.math.sqrt(3)) / 2, 0],
-            [a / 2, (a * math_1.math.sqrt(3)) / 2, 0],
+            [a / 2, (-a * Number(utils_1.Utils.math.sqrt(3))) / 2, 0],
+            [a / 2, (a * Number(utils_1.Utils.math.sqrt(3))) / 2, 0],
             [0, 0, c],
         ];
     },
     RHL: ({ a, alpha }) => {
-        const cosAlpha = math_1.math.cos((alpha / 180) * math_1.math.PI);
-        const cosHalfAlpha = math_1.math.sqrt((1 / 2) * (1 + cosAlpha));
-        const sinHalfAlpha = math_1.math.sqrt((1 / 2) * (1 - cosAlpha));
+        const cosAlpha = Number(utils_1.Utils.math.cos((alpha / 180) * Number(utils_1.Utils.math.PI)));
+        const cosHalfAlpha = Number(utils_1.Utils.math.sqrt((1 / 2) * (1 + cosAlpha)));
+        const sinHalfAlpha = Number(utils_1.Utils.math.sqrt((1 / 2) * (1 - cosAlpha)));
         return [
             [a * cosHalfAlpha, -a * sinHalfAlpha, 0.0],
             [a * cosHalfAlpha, a * sinHalfAlpha, 0.0],
             [
                 (a * cosAlpha) / cosHalfAlpha,
                 0.0,
-                a * math_1.math.sqrt(1 - (cosAlpha * cosAlpha) / (cosHalfAlpha * cosHalfAlpha)),
+                a *
+                    Number(utils_1.Utils.math.sqrt(1 - (cosAlpha * cosAlpha) / (cosHalfAlpha * cosHalfAlpha))),
             ],
         ];
     },
     MCL: ({ a, b, c, alpha }) => {
-        const cosAlpha = math_1.math.cos((alpha / 180) * math_1.math.PI);
+        const cosAlpha = Number(utils_1.Utils.math.cos((alpha / 180) * Number(utils_1.Utils.math.PI)));
         return [
             [a, 0, 0],
             [0, b, 0],
-            [0, c * cosAlpha, c * math_1.math.sqrt(1 - cosAlpha * cosAlpha)],
+            [0, c * cosAlpha, c * Number(utils_1.Utils.math.sqrt(1 - cosAlpha * cosAlpha))],
         ];
     },
     MCLC: ({ a, b, c, alpha }) => {
-        const cosAlpha = math_1.math.cos((alpha / 180) * math_1.math.PI);
+        const cosAlpha = Number(utils_1.Utils.math.cos((alpha / 180) * Number(utils_1.Utils.math.PI)));
         return [
             [a / 2, b / 2, 0],
             [-a / 2, b / 2, 0],
-            [0, c * cosAlpha, c * math_1.math.sqrt(1 - cosAlpha * cosAlpha)],
+            [0, c * cosAlpha, c * Number(utils_1.Utils.math.sqrt(1 - cosAlpha * cosAlpha))],
         ];
     },
     // Algorithm from http://pymatgen.org/_modules/pymatgen/core/lattice.html (from_params)
     TRI: ({ a, b, c, alpha, beta, gamma }) => {
         // convert angles to Radians
         // eslint-disable-next-line no-param-reassign
-        [alpha, beta, gamma] = [alpha, beta, gamma].map(
-        // @ts-ignore
-        (x) => math_1.math.unit(x, "degree").to("rad").value);
-        const [cosAlpha, cosBeta, cosGamma] = [alpha, beta, gamma].map((x) => math_1.math.cos(x));
-        const [sinAlpha, sinBeta] = [alpha, beta].map((x) => math_1.math.sin(x));
+        [alpha, beta, gamma] = [alpha, beta, gamma].map((x) => Number(utils_1.Utils.math.unit(x, "degree").to("rad").value));
+        const [cosAlpha, cosBeta, cosGamma] = [alpha, beta, gamma].map((x) => Number(utils_1.Utils.math.cos(x)));
+        const [sinAlpha, sinBeta] = [alpha, beta].map((x) => Number(utils_1.Utils.math.sin(x)));
         let acosArg = (cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta);
         if (acosArg < -1) {
             acosArg = -1;
@@ -123,9 +122,9 @@ const PRIMITIVE_CELLS = {
         else if (acosArg > 1) {
             acosArg = 1;
         }
-        const gammaStar = math_1.math.acos(acosArg);
-        const cosGammaStar = math_1.math.cos(gammaStar);
-        const sinGammaStar = math_1.math.sin(gammaStar);
+        const gammaStar = Number(utils_1.Utils.math.acos(acosArg));
+        const cosGammaStar = Number(utils_1.Utils.math.cos(gammaStar));
+        const sinGammaStar = Number(utils_1.Utils.math.sin(gammaStar));
         return [
             [a * sinBeta, 0.0, a * cosBeta],
             [-b * sinAlpha * cosGammaStar, b * sinAlpha * sinGammaStar, b * cosAlpha],
@@ -143,4 +142,3 @@ function getPrimitiveLatticeVectorsFromConfig(latticeConfig) {
     const [vectorA, vectorB, vectorC] = primitiveCellGenerator(latticeConfig);
     return [vectorA, vectorB, vectorC];
 }
-exports.getPrimitiveLatticeVectorsFromConfig = getPrimitiveLatticeVectorsFromConfig;

package/dist/js/lattice/lattice.js

@@ -15,23 +15,33 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Lattice = exports.LatticeVectors = exports.molecularLatticePaddingFactor = exports.diatomicLatticePaddingFactor = exports.defaultNonPeriodicMinimumLatticeSize = void 0;
-const constants_1 = require("@mat3ra/code/dist/js/constants");
 const entity_1 = require("@mat3ra/code/dist/js/entity");
-const math_1 = require("@mat3ra/code/dist/js/math");
+const utils_1 = require("@mat3ra/utils");
 const lodash = __importStar(require("lodash"));
 const cell_1 = require("../cell/cell");
 const primitive_cell_1 = require("../cell/primitive_cell");
 const lattice_types_1 = require("./lattice_types");
 const unit_cell_1 = require("./unit_cell");
+const { HASH_TOLERANCE } = utils_1.Utils.constants;
 /**
  * Scaling factor used to calculate the new lattice size for non-periodic systems.
  * The scaling factor ensures that a non-periodic structure will have have a lattice greater than the structures size.
@@ -69,17 +79,19 @@ class Lattice extends entity_1.InMemoryEntity {
         const { a } = this;
         const { b } = this;
         const { c } = this;
-        const alphaRad = math_1.math.unit(this.alpha, "deg").toNumber("rad");
-        const betaRad = math_1.math.unit(this.beta, "deg").toNumber("rad");
-        const gammaRad = math_1.math.unit(this.gamma, "deg").toNumber("rad");
-        const cosAlpha = math_1.math.cos(alphaRad);
-        const cosBeta = math_1.math.cos(betaRad);
-        const cosGamma = math_1.math.cos(gammaRad);
-        const sinAlpha = math_1.math.sin(alphaRad);
-        const sinBeta = math_1.math.sin(betaRad);
-        const gammaStar = math_1.math.acos((cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta));
-        const cosGammaStar = math_1.math.cos(gammaStar);
-        const sinGammaStar = math_1.math.sin(gammaStar);
+        const alphaRad = utils_1.Utils.math.unit(this.alpha, "deg").toNumber("rad");
+        const betaRad = utils_1.Utils.math.unit(this.beta, "deg").toNumber("rad");
+        const gammaRad = utils_1.Utils.math.unit(this.gamma, "deg").toNumber("rad");
+        const cosAlpha = utils_1.Utils.math.cos(alphaRad);
+        const cosBeta = utils_1.Utils.math.cos(betaRad);
+        const cosGamma = utils_1.Utils.math.cos(gammaRad);
+        const sinAlpha = utils_1.Utils.math.sin(alphaRad);
+        const sinBeta = utils_1.Utils.math.sin(betaRad);
+        const gammaStar = utils_1.Utils.math.acos((cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta));
+        // @ts-ignore - mathjs v12 acos return type includes Complex, but inputs are always real
+        const cosGammaStar = utils_1.Utils.math.cos(gammaStar);
+        // @ts-ignore
+        const sinGammaStar = utils_1.Utils.math.sin(gammaStar);
         const vectorA = [a * sinBeta, 0.0, a * cosBeta];
         const vectorB = [
             -b * sinAlpha * cosGammaStar,
@@ -94,12 +106,12 @@ class Lattice extends entity_1.InMemoryEntity {
     }
     static fromVectorsArray(vectors, units = Lattice.defaultConfig.units, type = "TRI") {
         const [aVec, bVec, cVec] = vectors;
-        const a = math_1.math.vlen(aVec);
-        const b = math_1.math.vlen(bVec);
-        const c = math_1.math.vlen(cVec);
-        const alpha = math_1.math.angle(bVec, cVec, "deg");
-        const beta = math_1.math.angle(aVec, cVec, "deg");
-        const gamma = math_1.math.angle(aVec, bVec, "deg");
+        const a = utils_1.Utils.math.vlen(aVec);
+        const b = utils_1.Utils.math.vlen(bVec);
+        const c = utils_1.Utils.math.vlen(cVec);
+        const alpha = utils_1.Utils.math.angle(bVec, cVec, "deg");
+        const beta = utils_1.Utils.math.angle(aVec, cVec, "deg");
+        const gamma = utils_1.Utils.math.angle(aVec, bVec, "deg");
         return new Lattice({
             a,
             b,
@@ -144,7 +156,7 @@ class Lattice extends entity_1.InMemoryEntity {
      */
     get typeExtended() {
         const { a, b, c, alpha, beta, gamma, type } = this;
-        const cosAlpha = math_1.math.cos((alpha / 180) * math_1.math.PI);
+        const cosAlpha = utils_1.Utils.math.cos((alpha / 180) * utils_1.Utils.math.PI);
         switch (type) {
             case "BCT":
                 return c < a ? "BCT-1" : "BCT-2";
@@ -179,14 +191,14 @@ class Lattice extends entity_1.InMemoryEntity {
      * Calculate the volume of the lattice cell.
      */
     get volume() {
-        return math_1.math.abs(math_1.math.det(this.vectorArrays));
+        return utils_1.Utils.math.abs(utils_1.Utils.math.det(this.vectorArrays));
     }
     /*
      * Returns a "default" primitive lattice by type, with lattice parameters scaled by the length of "a",
      * @param latticeConfig {Object} LatticeBravais config (see constructor)
      */
     static getDefaultPrimitiveLatticeConfigByType(latticeConfig) {
-        const f_ = math_1.math.roundArrayOrNumber;
+        const f_ = utils_1.Utils.math.roundArrayOrNumber;
         // construct new primitive cell using lattice parameters and skip rounding the vectors
         const vectors = (0, primitive_cell_1.getPrimitiveLatticeVectorsFromConfig)(latticeConfig);
         // create new lattice from primitive cell
@@ -224,7 +236,7 @@ class Lattice extends entity_1.InMemoryEntity {
             scaledLattice.beta,
             scaledLattice.gamma,
         ]
-            .map((x) => math_1.math.round(x, constants_1.HASH_TOLERANCE))
+            .map((x) => utils_1.Utils.math.roundCustom(x, HASH_TOLERANCE))
             .join(";")};`;
     }
     /**

package/dist/js/lattice/lattice_types.js

@@ -27,7 +27,7 @@ var LatticeTypeExtended;
     LatticeTypeExtended["TRI_1a"] = "TRI_1a";
     LatticeTypeExtended["TRI_2a"] = "TRI_2a";
     LatticeTypeExtended["TRI_1b"] = "TRI_1b";
-})(LatticeTypeExtended = exports.LatticeTypeExtended || (exports.LatticeTypeExtended = {}));
+})(LatticeTypeExtended || (exports.LatticeTypeExtended = LatticeTypeExtended = {}));
 exports.DEFAULT_LATTICE_UNITS = {
     // by default lattice vectors shall be measured in angstrom, angles - in degrees
     length: {

package/dist/js/lattice/reciprocal/lattice_reciprocal.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReciprocalLattice = void 0;
 const constants_1 = require("@mat3ra/code/dist/js/constants");
-const math_1 = require("@mat3ra/code/dist/js/math");
+const utils_1 = require("@mat3ra/utils");
 const lodash_1 = __importDefault(require("lodash"));
 const lattice_1 = require("../lattice");
 const paths_1 = require("./paths");
@@ -17,26 +17,26 @@ class ReciprocalLattice extends lattice_1.Lattice {
      */
     get reciprocalVectors() {
         const vectors_ = this.vectors.vectorArrays;
-        const a = math_1.math.vlen(vectors_[0]);
-        const divider = math_1.math.multiply(vectors_[0], math_1.math.cross(vectors_[1], vectors_[2])) / a;
+        const a = utils_1.Utils.math.vlen(vectors_[0]);
+        const divider = utils_1.Utils.math.multiply(vectors_[0], utils_1.Utils.math.cross(vectors_[1], vectors_[2])) / a;
         return [
-            math_1.math.multiply(math_1.math.cross(vectors_[1], vectors_[2]), 1 / divider),
-            math_1.math.multiply(math_1.math.cross(vectors_[2], vectors_[0]), 1 / divider),
-            math_1.math.multiply(math_1.math.cross(vectors_[0], vectors_[1]), 1 / divider),
+            utils_1.Utils.math.multiply(utils_1.Utils.math.cross(vectors_[1], vectors_[2]), 1 / divider),
+            utils_1.Utils.math.multiply(utils_1.Utils.math.cross(vectors_[2], vectors_[0]), 1 / divider),
+            utils_1.Utils.math.multiply(utils_1.Utils.math.cross(vectors_[0], vectors_[1]), 1 / divider),
         ];
     }
     /**
      * Norms of reciprocal vectors.
      */
     get reciprocalVectorNorms() {
-        return this.reciprocalVectors.map((vec) => math_1.math.norm(vec));
+        return this.reciprocalVectors.map((vec) => utils_1.Utils.math.norm(vec));
     }
     /**
      * Ratio of reciprocal vector norms scaled by the inverse of the largest component.
      */
     get reciprocalVectorRatios() {
         const norms = this.reciprocalVectorNorms;
-        const maxNorm = math_1.math.max(...norms);
+        const maxNorm = utils_1.Utils.math.max(...norms);
         return norms.map((n) => n / maxNorm);
     }
     /**
@@ -45,7 +45,7 @@ class ReciprocalLattice extends lattice_1.Lattice {
      * @return {KPointCoordinates}
      */
     getCartesianCoordinates(point) {
-        return math_1.math.multiply(point, this.reciprocalVectors);
+        return utils_1.Utils.math.multiply(point, this.reciprocalVectors);
     }
     /**
      * Get the list of high-symmetry points for the current lattice.
@@ -72,7 +72,7 @@ class ReciprocalLattice extends lattice_1.Lattice {
         const symmPoints = this.symmetryPoints;
         dataPoints.forEach((point, index) => {
             const symmPoint = symmPoints.find((x) => {
-                return math_1.math.vEqualWithTolerance(x.coordinates, point, 1e-4);
+                return utils_1.Utils.math.vEqualWithTolerance(x.coordinates, point, 1e-4);
             });
             if (symmPoint) {
                 kpointPath.push({
@@ -94,8 +94,8 @@ class ReciprocalLattice extends lattice_1.Lattice {
     calculateDimension(nPoints, index) {
         const norms = this.reciprocalVectorNorms;
         const [j, k] = [0, 1, 2].filter((i) => i !== index); // get indices of other two dimensions
-        const N = math_1.math.cbrt((nPoints * norms[index] ** 2) / (norms[j] * norms[k]));
-        return math_1.math.max(1, math_1.math.ceil(N));
+        const N = utils_1.Utils.math.cbrt((nPoints * norms[index] ** 2) / (norms[j] * norms[k]));
+        return utils_1.Utils.math.max(1, utils_1.Utils.math.ceil(N));
     }
     /**
      * Calculate grid dimensions from total number of k-points.
@@ -110,10 +110,10 @@ class ReciprocalLattice extends lattice_1.Lattice {
         const { a } = this;
         return {
             [constants_1.ATOMIC_COORD_UNITS.cartesian]: {
-                [constants_1.units.angstrom]: (2 * math_1.math.PI) / a,
+                [constants_1.units.angstrom]: (2 * utils_1.Utils.math.PI) / a,
             },
             [constants_1.units.angstrom]: {
-                [constants_1.ATOMIC_COORD_UNITS.cartesian]: a / (2 * math_1.math.PI),
+                [constants_1.ATOMIC_COORD_UNITS.cartesian]: a / (2 * utils_1.Utils.math.PI),
             },
         };
     }
@@ -127,7 +127,7 @@ class ReciprocalLattice extends lattice_1.Lattice {
     getDimensionsFromSpacing(spacing, units = constants_1.ATOMIC_COORD_UNITS.cartesian) {
         const factor = this.conversionTable[units][constants_1.ATOMIC_COORD_UNITS.cartesian] || 1;
         return this.reciprocalVectorNorms.map((norm) => {
-            return math_1.math.max(1, math_1.math.ceil(lodash_1.default.round(norm / (spacing * factor), 4)));
+            return utils_1.Utils.math.max(1, utils_1.Utils.math.ceil(lodash_1.default.round(norm / (spacing * factor), 4)));
         });
     }
     /**
@@ -140,7 +140,7 @@ class ReciprocalLattice extends lattice_1.Lattice {
         const factor = this.conversionTable[constants_1.ATOMIC_COORD_UNITS.cartesian][units] || 1;
         const norms = this.reciprocalVectorNorms;
         return (factor *
-            math_1.math.mean(dimensions.map((dim, i) => norms[i] / math_1.math.max(1, dim))));
+            utils_1.Utils.math.mean(dimensions.map((dim, i) => norms[i] / utils_1.Utils.math.max(1, dim))));
     }
 }
 exports.ReciprocalLattice = ReciprocalLattice;

package/dist/js/lattice/reciprocal/symmetry_points.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.symmetryPoints = void 0;
+exports.symmetryPoints = symmetryPoints;
 const POINTS = {
     CUB: () => {
         return [
@@ -863,4 +863,3 @@ function symmetryPoints(lattice) {
         },
     ].concat(POINTS[lattice.type](lattice) || []);
 }
-exports.symmetryPoints = symmetryPoints;

package/dist/js/material.d.ts

@@ -37,34 +37,34 @@ declare class Material extends InMemoryEntity implements Schema {
      * @summary Returns the specific derived property (as specified by name) for a material.
      */
     getDerivedPropertyByName(name: string): {
-        name?: "volume" | undefined;
-        units?: "angstrom^3" | undefined;
+        name?: "volume";
+        units?: "angstrom^3";
         value: number;
     } | {
-        name?: "density" | undefined;
-        units?: "g/cm^3" | undefined;
+        name?: "density";
+        units?: "g/cm^3";
         value: number;
     } | {
-        pointGroupSymbol?: string | undefined;
-        spaceGroupSymbol?: string | undefined;
+        pointGroupSymbol?: string;
+        spaceGroupSymbol?: string;
         tolerance?: {
-            units?: "angstrom" | undefined;
+            units?: "angstrom";
             value: number;
-        } | undefined;
-        name?: "symmetry" | undefined;
+        };
+        name?: "symmetry";
     } | {
-        name?: "elemental_ratio" | undefined;
+        name?: "elemental_ratio";
         value: number;
-        element?: string | undefined;
+        element?: string;
     } | {
-        name?: "p-norm" | undefined;
-        degree?: number | undefined;
+        name?: "p-norm";
+        degree?: number;
         value: number;
     } | {
-        name?: "inchi" | undefined;
+        name?: "inchi";
         value: string;
     } | {
-        name?: "inchi_key" | undefined;
+        name?: "inchi_key";
         value: string;
     } | undefined;
     /**

package/dist/js/parsers/poscar.js

@@ -3,15 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.atomsCount = void 0;
-const math_1 = require("@mat3ra/code/dist/js/math");
+exports.atomsCount = atomsCount;
 const utils_1 = require("@mat3ra/utils");
 const underscore_string_1 = __importDefault(require("underscore.string"));
 const constrained_basis_1 = require("../basis/constrained_basis");
 const cell_1 = require("../cell/cell");
 const constants_1 = require("../constants");
 const lattice_1 = require("../lattice/lattice");
-const _print = (x, printFormat = "%14.9f") => underscore_string_1.default.sprintf(printFormat, math_1.math.precise(x));
+const _print = (x, printFormat = "%14.9f") => underscore_string_1.default.sprintf(printFormat, utils_1.Utils.math.precise(x));
 const _latticeVectorsToString = (vectors) => vectors.map((v) => v.map((c) => _print(c)).join("\t")).join("\n");
 const atomicConstraintsCharFromBool = (bool) => (bool ? "T" : "F");
 /**
@@ -63,7 +62,6 @@ function atomsCount(poscarFileContent) {
     const atomsLine = lines[6].split(/\s+/);
     return atomsLine.map((x) => parseInt(x, 10)).reduce((a, b) => a + b);
 }
-exports.atomsCount = atomsCount;
 /**
  * Parses POSCAR file into a Material config object.
  * @param fileContent - POSCAR file content.

package/dist/js/parsers/xyz.js

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate = exports.XYZ_COORDINATE_PRECISION = void 0;
+exports.XYZ_COORDINATE_PRECISION = void 0;
+exports.validate = validate;
 const lodash_1 = require("lodash");
 const underscore_string_1 = __importDefault(require("underscore.string"));
 const constrained_basis_1 = require("../basis/constrained_basis");
@@ -43,7 +44,6 @@ function validate(xyzTxt) {
         .filter((x) => x.trim() !== "")
         .forEach(validateLine);
 }
-exports.validate = validate;
 /**
  * Parses XYZ line and returns an object.
  * @param line - line of text

package/dist/js/parsers/xyz_combinatorial_basis.d.ts

@@ -1,3 +1,4 @@
+import { BasisSchema } from "@mat3ra/esse/dist/js/types";
 import { ElementsAndCoordinatesConfig } from "../basis/basis";
 import { AtomicCoordinateValue } from "../basis/coordinates";
 import { AtomicElementValue } from "../basis/elements";
@@ -37,7 +38,7 @@ export declare class CombinatorialBasis {
      * @return {String[]}
      */
     get uniqueElements(): any[];
-    static toBasisConfigForElementsAndCoordinates(array: ElementWithCoordinate[], units?: "crystal" | "cartesian" | undefined, cell?: Cell): ElementsAndCoordinatesConfig;
+    static toBasisConfigForElementsAndCoordinates(array: ElementWithCoordinate[], units?: BasisSchema["units"], cell?: Cell): ElementsAndCoordinatesConfig;
     /**
      * Returns array of regular bases extracted from current combinatorial basis.
      * @return {Basis[]|Object[]}