@mat3ra/made 2026.7.4-0 → 2026.7.13-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/primitive_cell.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPrimitiveLatticeVectorsFromConfig = getPrimitiveLatticeVectorsFromConfig;
-const math_1 = require("@mat3ra/code/dist/js/math");
+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],

package/dist/js/lattice/lattice.js

@@ -34,14 +34,14 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 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.
@@ -79,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,
@@ -104,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,
@@ -154,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";
@@ -189,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
@@ -234,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/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/parsers/poscar.js

@@ -4,14 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.atomsCount = atomsCount;
-const math_1 = require("@mat3ra/code/dist/js/math");
 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");
 /**

package/dist/js/parsers/xyz_combinatorial_basis.js

@@ -34,7 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CombinatorialBasis = exports.WrongBasisFormat = void 0;
-const math_1 = require("@mat3ra/code/dist/js/math");
+const utils_1 = require("@mat3ra/utils");
 const lodash_1 = require("lodash");
 const s = __importStar(require("underscore.string"));
 const cell_1 = require("../cell/cell");
@@ -209,7 +209,7 @@ class CombinatorialBasis {
             dimensions.push(itemsSet);
         });
         // @ts-ignore // We're multiplying objects with math, not numbers. No type casting will help.
-        const basisSet = math_1.math.cartesianProduct.apply(null, dimensions);
+        const basisSet = utils_1.Utils.math.cartesianProduct.apply(null, dimensions);
         return basisSet.map((basis) => basis.filter((entry) => entry.element !== VACANCY_CHARACTER));
     }
     /**

package/dist/js/tools/basis.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const math_1 = require("@mat3ra/code/dist/js/math");
+const utils_1 = require("@mat3ra/utils");
 const lodash_1 = require("lodash");
 const coordinates_1 = require("../basis/coordinates");
-const ADD = math_1.math.add;
-const MULT = math_1.math.multiply;
+const ADD = utils_1.Utils.math.add;
+const MULT = utils_1.Utils.math.multiply;
 /**
  * Returns a repeated basis of a crystal.
  * @param basis {Basis} Original basis.

package/dist/js/tools/cell.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const math_1 = require("@mat3ra/code/dist/js/math");
+const utils_1 = require("@mat3ra/utils");
 const cell_1 = require("../cell/cell");
 /**
  * Returns the list of points on the original lattice contained in the supercell in fractional coordinates.
@@ -19,8 +19,8 @@ function latticePointsInSupercell(supercellMatrix) {
         [1, 1, 1],
     ];
     const d_points = diagonals.map((point) => supercell.convertPointToCartesian(point));
-    const mins = [0, 1, 2].map((i) => math_1.math.min(...d_points.map((p) => p[i])));
-    const maxes = [0, 1, 2].map((i) => math_1.math.max(...d_points.map((p) => p[i])) + 1);
+    const mins = [0, 1, 2].map((i) => utils_1.Utils.math.min(...d_points.map((p) => p[i])));
+    const maxes = [0, 1, 2].map((i) => utils_1.Utils.math.max(...d_points.map((p) => p[i])) + 1);
     const points = [];
     for (let i = mins[0]; i <= maxes[0]; i++) {
         for (let j = mins[1]; j <= maxes[1]; j++) {

package/dist/js/tools/material.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const math_1 = require("@mat3ra/code/dist/js/math");
+const utils_1 = require("@mat3ra/utils");
 const constants_1 = require("../constants");
 const lattice_1 = require("../lattice/lattice");
 /**
@@ -38,8 +38,8 @@ function translateAtomsToCenter(material) {
     material.toCartesian();
     const updatedBasis = material.Basis;
     const centerOfCoordinates = updatedBasis.centerOfCoordinatesPoint;
-    const centerOfLattice = math_1.math.multiply(0.5, material.Lattice.vectorArrays.reduce((a, b) => math_1.math.add(a, b)));
-    const translationVector = math_1.math.subtract(centerOfLattice, centerOfCoordinates);
+    const centerOfLattice = utils_1.Utils.math.multiply(0.5, material.Lattice.vectorArrays.reduce((a, b) => utils_1.Utils.math.add(a, b)));
+    const translationVector = utils_1.Utils.math.subtract(centerOfLattice, centerOfCoordinates);
     updatedBasis.translateByVector(translationVector);
     material.setBasis(updatedBasis.toJSON());
     if (originalUnits !== constants_1.ATOMIC_COORD_UNITS.cartesian)

package/dist/js/tools/supercell.js

@@ -3,10 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const math_1 = require("@mat3ra/code/dist/js/math");
+const utils_1 = require("@mat3ra/utils");
 const lattice_1 = require("../lattice/lattice");
 const cell_1 = __importDefault(require("./cell"));
-const ADD = math_1.math.add;
+const ADD = utils_1.Utils.math.add;
 /**
  * @summary Generates new basis for a supercell. For each site from basis generates shifts that are within supercell.
  */
@@ -39,7 +39,7 @@ function generateNewBasisWithinSupercell(basis, cell, supercell, supercellMatrix
  * @param supercellMatrix {Number[][]}
  */
 function generateConfig(material, supercellMatrix) {
-    const det = math_1.math.det(supercellMatrix);
+    const det = utils_1.Utils.math.det(supercellMatrix);
     if (det === 0) {
         throw new Error("Scaling matrix is degenerate.");
     }

package/dist/js/tools/surface.js

@@ -3,14 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const math_1 = require("@mat3ra/code/dist/js/math");
+const utils_1 = require("@mat3ra/utils");
 const lattice_1 = require("../lattice/lattice");
 const supercell_1 = __importDefault(require("./supercell"));
-const MULT = math_1.math.multiply;
-const ADD = math_1.math.add;
-const DOT = math_1.math.product;
+const MULT = utils_1.Utils.math.multiply;
+const ADD = utils_1.Utils.math.add;
+const DOT = utils_1.Utils.math.product;
 const getMatrixInLeftHandedRepresentation = (matrix) => {
-    return math_1.math.det(matrix) < 0 ? MULT(matrix, -1) : matrix;
+    return utils_1.Utils.math.det(matrix) < 0 ? MULT(matrix, -1) : matrix;
 };
 /**
  * Helper function for extended GCD.
@@ -22,10 +22,10 @@ const getMatrixInLeftHandedRepresentation = (matrix) => {
 function extGCD(a, b) {
     if (b === 0)
         return [1, 0];
-    if (math_1.math.mod(a, b) === 0)
+    if (utils_1.Utils.math.mod(a, b) === 0)
         return [0, 1];
-    const [x, y] = extGCD(b, math_1.math.mod(a, b));
-    return [y, x - y * math_1.math.floor(a / b)];
+    const [x, y] = extGCD(b, utils_1.Utils.math.mod(a, b));
+    return [y, x - y * utils_1.Utils.math.floor(a / b)];
 }
 /**
  * Generates a slab scaling matrix for the specified cell based on miller indices.
@@ -36,7 +36,7 @@ function extGCD(a, b) {
  * @return {Number[][]}
  */
 function getMillerScalingMatrix(cell, millerIndices, tol = 1e-8) {
-    if (!millerIndices.reduce((a, b) => math_1.math.abs(a) + math_1.math.abs(b)))
+    if (!millerIndices.reduce((a, b) => utils_1.Utils.math.abs(a) + utils_1.Utils.math.abs(b)))
         throw new Error("Miller indices are zeros.");
     let scalingMatrix;
     const [h, k, l] = millerIndices;
@@ -78,19 +78,21 @@ function getMillerScalingMatrix(cell, millerIndices, tol = 1e-8) {
         const k1 = DOT(ADD(MULT(p, z1), MULT(q, z2)), z3);
         // @ts-ignore
         const k2 = DOT(ADD(MULT(l, z1), -MULT(k, z2)), z3);
-        if (math_1.math.abs(k2) > tol) {
+        // @ts-ignore
+        if (utils_1.Utils.math.abs(k2) > tol) {
             // For mathjs version 3.20: round(-0.5) = -0
             // For mathjs version 5.10: round(-0.5) = -1
             // Here we specify rounding method to Bankers
             // For Python 3.11: round(-0.5) = 0
+            // @ts-ignore - mathjs v12 dot return type
             const value = k1 / k2;
-            const roundedValue = math_1.math.roundCustom(value, 0, math_1.math.RoundingMethod.Bankers);
+            const roundedValue = utils_1.Utils.math.roundCustom(value, 0, utils_1.Utils.math.RoundingMethod.Bankers);
             const i = -roundedValue;
             [p, q] = [p + i * l, q - i * k];
         }
         const [a, b] = extGCD(p * k + q * l, h);
         const c1 = [p * k + q * l, -p * h, -q * h];
-        const c2 = [0, l, -k].map((c) => math_1.math.trunc(c / math_1.math.gcd(l, k))); // floor division
+        const c2 = [0, l, -k].map((c) => utils_1.Utils.math.trunc(c / utils_1.Utils.math.gcd(l, k))); // floor division
         const c3 = [b, a * p, a * q];
         scalingMatrix = [c1, c2, c3];
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mat3ra/made",
-    "version": "2026.7.4-0",
+    "version": "2026.7.13-0",
     "description": "MAterials DEsign library",
     "scripts": {
         "lint": "eslint --cache src/js tests/js && prettier --write src/js tests/js",
@@ -37,7 +37,8 @@
         "@mat3ra/code": "^2026.5.27-0",
         "@mat3ra/esse": "^2026.6.30-0",
         "@mat3ra/tsconfig": "^2024.6.3-0",
-        "@mat3ra/utils": "^2026.7.3-0",
+        "@mat3ra/utils": "^2026.7.8-0",
+        "@mat3ra/standata": "2026.6.30-0",
         "@types/crypto-js": "^4.2.2",
         "@typescript-eslint/eslint-plugin": "^5.62.0",
         "@typescript-eslint/parser": "^5.62.0",