@mat3ra/made 2026.6.29-0 → 2026.7.8-0

package/dist/js/parsers/xyz_combinatorial_basis.js

@@ -15,16 +15,26 @@ 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.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");
@@ -199,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.6.29-0",
+    "version": "2026.7.8-0",
     "description": "MAterials DEsign library",
     "scripts": {
         "lint": "eslint --cache src/js tests/js && prettier --write src/js tests/js",
@@ -14,68 +14,69 @@
     },
     "repository": {
         "type": "git",
-        "url": "https://github.com/Exabyte-io/made.git"
+        "url": "https://github.com/mat3ra/made.git"
     },
     "main": "dist/js/made.js",
     "author": "Exabyte Inc.",
     "bugs": {
-        "url": "https://github.com/Exabyte-io/made/issues"
+        "url": "https://github.com/mat3ra/made/issues"
     },
     "license": "Apache-2.0",
-    "homepage": "https://github.com/Exabyte-io/made",
+    "homepage": "https://github.com/mat3ra/made",
     "engines": {
         "node": ">=0.14"
     },
     "devDependencies": {
-        "@babel/eslint-parser": "^7.16.3",
-        "@babel/plugin-proposal-class-properties": "^7.16.0",
-        "@babel/preset-env": "^7.16.4",
-        "@babel/preset-react": "^7.16.7",
-        "@babel/register": "^7.22.15",
-        "@babel/runtime-corejs3": "^7.16.8",
-        "@exabyte-io/eslint-config": "2025.5.13-0",
-        "@mat3ra/code": "2026.5.27-0",
-        "@mat3ra/esse": "2026.5.27-0",
-        "@mat3ra/tsconfig": "2024.6.3-0",
-        "@mat3ra/utils": "^2026.6.11-0",
+        "@babel/eslint-parser": "^7.29.7",
+        "@babel/plugin-proposal-class-properties": "^7.18.6",
+        "@babel/preset-env": "^7.29.7",
+        "@babel/preset-react": "^7.29.7",
+        "@babel/register": "^7.29.7",
+        "@babel/runtime-corejs3": "^7.29.7",
+        "@exabyte-io/eslint-config": "^2026.7.3-0",
+        "@mat3ra/code": "^2026.5.27-0",
+        "@mat3ra/esse": "^2026.6.30-0",
+        "@mat3ra/tsconfig": "^2024.6.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.9.1",
-        "@typescript-eslint/parser": "^5.9.1",
-        "chai": "^4.3.4",
+        "@typescript-eslint/eslint-plugin": "^5.62.0",
+        "@typescript-eslint/parser": "^5.62.0",
+        "chai": "^4.5.0",
         "chai-almost": "^1.0.1",
         "eslint": "^7.32.0",
-        "eslint-config-airbnb": "^19.0.2",
-        "eslint-config-prettier": "^8.5.0",
+        "eslint-config-airbnb": "^19.0.4",
+        "eslint-config-prettier": "^8.10.2",
         "eslint-import-resolver-exports": "^1.0.0-beta.5",
         "eslint-import-resolver-meteor": "^0.4.0",
-        "eslint-import-resolver-node": "^0.3.9",
-        "eslint-plugin-import": "^2.25.3",
-        "eslint-plugin-jsdoc": "^37.1.0",
-        "eslint-plugin-jsx-a11y": "^6.5.1",
+        "eslint-import-resolver-node": "^0.3.10",
+        "eslint-plugin-import": "^2.32.0",
+        "eslint-plugin-jsdoc": "^37.9.7",
+        "eslint-plugin-jsx-a11y": "^6.10.2",
         "eslint-plugin-mui-path-imports": "0.0.15",
-        "eslint-plugin-prettier": "^4.2.1",
-        "eslint-plugin-react": "^7.30.0",
+        "eslint-plugin-prettier": "^4.2.5",
+        "eslint-plugin-react": "^7.37.5",
         "eslint-plugin-simple-import-sort": "^7.0.0",
         "husky": "^7.0.4",
-        "lint-staged": "^12.1.2",
-        "mocha": "10.3.0",
-        "prettier": "^2.5.1",
+        "lint-staged": "^12.5.0",
+        "mocha": "10.8.2",
+        "prettier": "^2.8.8",
         "nyc": "^15.1.0"
     },
     "dependencies": {
-        "@babel/core": "7.24.1",
-        "@exabyte-io/periodic-table.js": "2022.5.28-0",
-        "@types/chai": "^4.3.5",
+        "@babel/core": "^7.29.7",
+        "@exabyte-io/periodic-table.js": "^2023.12.23-3",
+        "@types/chai": "^4.3.20",
         "@types/chai-almost": "^1.0.3",
-        "@types/mocha": "^10.0.1",
-        "@types/node": "^20.4.2",
-        "@types/underscore.string": "^0.0.40",
+        "@types/mocha": "^10.0.10",
+        "@types/node": "^20.19.43",
+        "@types/underscore.string": "^0.0.42",
         "array-almost-equal": "^1.0.0",
-        "crypto-js": "4.2.0",
-        "lodash": "^4.17.*",
-        "ts-node": "^10.9.1",
-        "typescript": "^4.5.5",
-        "underscore.string": "^3.3.4"
+        "crypto-js": "^4.2.0",
+        "lodash": "^4.18.*",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.9.3",
+        "underscore.string": "^3.3.6"
     },
     "peerDependencies": {
         "@mat3ra/code": "*",

package/pyproject.toml

@@ -3,7 +3,7 @@ name = "mat3ra-made"
 dynamic = ["version"]
 description = "MAterials DEfinitions and/or MAterials DEsign library."
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 license = {file = "LICENSE.md"}
 authors = [
     { name = "Exabyte Inc.", email = "info@mat3ra.com" }
@@ -15,12 +15,11 @@ classifiers = [
     "Topic :: Software Development",
 ]
 dependencies = [
-    # add requirements here
+    "mat3ra-code",
+    "mat3ra-esse>=2026.6.30.post0",
+    "mat3ra-utils>=2026.7.3.post0",
     # new verison of numpy==2.0.0 is not handled by pymatgen yet
     "numpy<=1.26.4",
-    "mat3ra-utils",
-    "mat3ra-esse",
-    "mat3ra-code"
 ]
 
 [project.optional-dependencies]
@@ -81,7 +80,7 @@ where = ["src/py"]
 
 [tool.black]
 line-length = 120
-target-version = ['py38']
+target-version = ['py310']
 # 'extend-exclude' excludes files or directories in addition to the defaults
 extend-exclude = '''
 (
@@ -99,7 +98,7 @@ extend-exclude = [
     "tests/py/unit/fixtures"
 ]
 line-length = 120
-target-version = "py38"
+target-version = "py310"
 
 [tool.ruff.per-file-ignores]
 "__init__.py" = ["F401"]

package/src/js/basis/basis.ts

@@ -1,12 +1,13 @@
 // @ts-ignore
 import { getElectronegativity, getElementAtomicRadius } from "@exabyte-io/periodic-table.js";
 import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
-import { math } from "@mat3ra/code/dist/js/math";
 import { BasisSchema, Coordinate3DSchema, Vector3DSchema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 import { chain, toPairs, uniq, values } from "lodash";
 
 import { Cell } from "../cell/cell";
 import { ATOMIC_COORD_UNITS, HASH_TOLERANCE } from "../constants";
+
 import {
     defaultNonPeriodicMinimumLatticeSize,
     diatomicLatticePaddingFactor,
@@ -247,7 +248,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
     toStandardRepresentation() {
         this.toCrystal();
         this._coordinates.mapArrayInPlace(
-            (point) => point.map((x) => math.mod(x)) as Coordinate3DSchema,
+            (point) => point.map((x) => Utils.math.mod(x)) as Coordinate3DSchema,
         );
     }
 
@@ -330,7 +331,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
     get formula(): string {
         const counts = this.uniqueElementCountsSortedByElectronegativity;
         const countsValues = values(counts);
-        const gcd = countsValues.length > 1 ? math.gcd(...countsValues) : countsValues[0];
+        const gcd = countsValues.length > 1 ? Utils.math.gcd(...countsValues) : countsValues[0];
 
         return toPairs(counts)
             .map(([element, count]) => element + (count / gcd === 1 ? "" : count / gcd))
@@ -392,7 +393,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
             const element = entry[0];
             const coordinate = entry[1];
             const atomicLabel = entry[2];
-            const toleratedCoordinate = coordinate.map((x) => math.round(x, HASH_TOLERANCE));
+            const toleratedCoordinate = coordinate.map((x) => Utils.math.roundCustom(x, HASH_TOLERANCE));
             return `${element}${atomicLabel} ${toleratedCoordinate.join()}`;
         });
         return `${standardRep.sort().join(";")};`;
@@ -471,7 +472,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
     hasEquivalentCellTo(anotherBasisClsInstance: Basis): boolean {
         return !this.cell.vectorArrays
             .map((vector, idx) => {
-                return math.vEqualWithTolerance(
+                return Utils.math.vEqualWithTolerance(
                     vector,
                     anotherBasisClsInstance.cell.vectorArrays[idx],
                 );
@@ -496,7 +497,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
         const maxDistance = this.maxPairwiseDistance;
         const minDistance = this.minPairwiseDistance;
         const widthRatio = maxDistance > 0 ? minDistance / maxDistance : 1;
-        const latticeScalingFactor = math.almostEqual(widthRatio, 1)
+        const latticeScalingFactor = Utils.math.almostEqual(widthRatio, 1)
             ? diatomicLatticePaddingFactor
             : molecularLatticePaddingFactor;
         const moleculeLatticeSize = maxDistance * latticeScalingFactor;
@@ -525,7 +526,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
                     (getElementAtomicRadius(el1) + getElementAtomicRadius(el2)); // in angstroms
 
                 // @ts-ignore
-                const distance = math.vDist(entry1.value, entry2.value) as number;
+                const distance = Utils.math.vDist(entry1.value, entry2.value) as number;
                 if (distance < tolerance) {
                     overlaps.push({
                         id1: i,
@@ -571,7 +572,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
         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.vDist(
+                    const distance = Utils.math.vDist(
                         this._coordinates.getElementValueByIndex(i) as Coordinate3DSchema,
                         this._coordinates.getElementValueByIndex(j) as Coordinate3DSchema,
                     );

package/src/js/basis/coordinates.ts

@@ -1,13 +1,14 @@
 import { RoundedArrayWithIds, RoundedValueWithId, RoundedVector3D, Vector3D } from "@mat3ra/code";
-import { math } from "@mat3ra/code/dist/js/math";
 import {
     AtomicCoordinateSchema,
     Coordinate3DSchema,
     Matrix3X3Schema,
     Vector3DSchema,
 } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 import { sprintf } from "underscore.string";
 
+
 export type AtomicCoordinateValue = AtomicCoordinateSchema["value"];
 
 type AxisType = "x" | "y" | "z";
@@ -78,7 +79,7 @@ export class Coordinates extends RoundedArrayWithIds<Coordinate3DSchema> {
     }
 
     getCenterPoint(): Vector3DSchema {
-        const transposed = math.transpose(this.values) as Matrix3X3Schema;
+        const transposed = Utils.math.transpose(this.values) as Matrix3X3Schema;
         const center: Vector3DSchema = [0, 0, 0];
 
         for (let i = 0; i < 3; i++) {

package/src/js/cell/cell.ts

@@ -1,17 +1,18 @@
 import { RoundedVector3D } from "@mat3ra/code";
-import { math } from "@mat3ra/code/dist/js/math";
 import {
     Coordinate3DSchema,
     LatticeVectorsSchema as CellSchema,
     Matrix3X3Schema,
     Vector3DSchema,
 } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 
 import constants from "../constants";
 
-const MATRIX = math.matrix;
-const MULT = math.multiply;
-const INV = math.inv;
+
+const MATRIX = Utils.math.matrix;
+const MULT = Utils.math.multiply;
+const INV = Utils.math.inv;
 // @ts-ignore
 const MATRIX_MULT = (...args) => MULT(...args.map((x) => MATRIX(x))).toArray();
 
@@ -74,11 +75,11 @@ export class Cell implements CellSchema {
     }
 
     get volume(): number {
-        return math.det(this.vectorArrays);
+        return Utils.math.det(this.vectorArrays);
     }
 
     get volumeRounded(): number {
-        return math.roundArrayOrNumber(this.volume, Cell.roundPrecision) as number;
+        return Utils.math.roundArrayOrNumber(this.volume, Cell.roundPrecision) as number;
     }
 
     clone(): Cell {
@@ -103,7 +104,7 @@ export class Cell implements CellSchema {
         const { tolerance } = this.constructor as typeof Cell;
         return (
             this.convertPointToCrystal(point)
-                .map((c: number) => math.isBetweenZeroInclusiveAndOne(c, tolerance))
+                .map((c: number) => Utils.math.isBetweenZeroInclusiveAndOne(c, tolerance))
                 // @ts-ignore
                 .reduce((a: boolean, b: boolean): boolean => a && b)
         );
@@ -114,7 +115,7 @@ export class Cell implements CellSchema {
         const { tolerance } = this.constructor as typeof Cell;
         return (
             point
-                .map((c: number) => math.isBetweenZeroInclusiveAndOne(c, tolerance))
+                .map((c: number) => Utils.math.isBetweenZeroInclusiveAndOne(c, tolerance))
                 // @ts-ignore
                 .reduce((a: boolean, b: boolean): boolean => a && b)
         );
@@ -128,11 +129,12 @@ export class Cell implements CellSchema {
     }
 
     getMostCollinearVectorIndex(testVector: Vector3DSchema): number {
-        const angles = this.vectorArrays.map((v) => math.angleUpTo90(v, testVector, "deg"));
-        return angles.findIndex((el: number) => el === math.min(angles));
+        const angles = this.vectorArrays.map((v) => Utils.math.angleUpTo90(v, testVector, "deg"));
+        return angles.findIndex((el: number) => el === Utils.math.min(angles));
     }
 
     scaleByMatrix(matrix: number[][]) {
+        // @ts-ignore - mathjs v12 multiply return type is broader than runtime
         [this.a, this.b, this.c] = MATRIX_MULT(matrix, this.vectorArrays);
     }
 

package/src/js/cell/primitive_cell.ts

@@ -1,5 +1,5 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import { LatticeSchema, Matrix3X3Schema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 
 /**
  * Routines for calculating primitive cell vectors from conventional cell Bravais parameters.
@@ -80,42 +80,45 @@ const PRIMITIVE_CELLS = {
 
     HEX: ({ a, c }: LatticeSchema): Matrix3X3Schema => {
         return [
-            [a / 2, (-a * math.sqrt(3)) / 2, 0],
-            [a / 2, (a * math.sqrt(3)) / 2, 0],
+            [a / 2, (-a * Number(Utils.math.sqrt(3))) / 2, 0],
+            [a / 2, (a * Number(Utils.math.sqrt(3))) / 2, 0],
             [0, 0, c],
         ];
     },
 
     RHL: ({ a, alpha }: LatticeSchema): Matrix3X3Schema => {
-        const cosAlpha = math.cos((alpha / 180) * math.PI);
-        const cosHalfAlpha = math.sqrt((1 / 2) * (1 + cosAlpha));
-        const sinHalfAlpha = math.sqrt((1 / 2) * (1 - cosAlpha));
+        const cosAlpha = Number(Utils.math.cos((alpha / 180) * Number(Utils.math.PI)));
+        const cosHalfAlpha = Number(Utils.math.sqrt((1 / 2) * (1 + cosAlpha)));
+        const sinHalfAlpha = Number(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.sqrt(1 - (cosAlpha * cosAlpha) / (cosHalfAlpha * cosHalfAlpha)),
+                a *
+                    Number(
+                        Utils.math.sqrt(1 - (cosAlpha * cosAlpha) / (cosHalfAlpha * cosHalfAlpha)),
+                    ),
             ],
         ];
     },
 
     MCL: ({ a, b, c, alpha }: LatticeSchema): Matrix3X3Schema => {
-        const cosAlpha = math.cos((alpha / 180) * math.PI);
+        const cosAlpha = Number(Utils.math.cos((alpha / 180) * Number(Utils.math.PI)));
         return [
             [a, 0, 0],
             [0, b, 0],
-            [0, c * cosAlpha, c * math.sqrt(1 - cosAlpha * cosAlpha)],
+            [0, c * cosAlpha, c * Number(Utils.math.sqrt(1 - cosAlpha * cosAlpha))],
         ];
     },
 
     MCLC: ({ a, b, c, alpha }: LatticeSchema): Matrix3X3Schema => {
-        const cosAlpha = math.cos((alpha / 180) * math.PI);
+        const cosAlpha = Number(Utils.math.cos((alpha / 180) * Number(Utils.math.PI)));
         return [
             [a / 2, b / 2, 0],
             [-a / 2, b / 2, 0],
-            [0, c * cosAlpha, c * math.sqrt(1 - cosAlpha * cosAlpha)],
+            [0, c * cosAlpha, c * Number(Utils.math.sqrt(1 - cosAlpha * cosAlpha))],
         ];
     },
 
@@ -123,22 +126,23 @@ const PRIMITIVE_CELLS = {
     TRI: ({ a, b, c, alpha, beta, gamma }: LatticeSchema): Matrix3X3Schema => {
         // convert angles to Radians
         // eslint-disable-next-line no-param-reassign
-        [alpha, beta, gamma] = [alpha, beta, gamma].map(
-            // @ts-ignore
-            (x) => math.unit(x, "degree").to("rad").value,
+        [alpha, beta, gamma] = [alpha, beta, gamma].map((x) =>
+            Number(Utils.math.unit(x, "degree").to("rad").value),
         );
 
-        const [cosAlpha, cosBeta, cosGamma] = [alpha, beta, gamma].map((x) => math.cos(x));
-        const [sinAlpha, sinBeta] = [alpha, beta].map((x) => math.sin(x));
+        const [cosAlpha, cosBeta, cosGamma] = [alpha, beta, gamma].map((x) =>
+            Number(Utils.math.cos(x)),
+        );
+        const [sinAlpha, sinBeta] = [alpha, beta].map((x) => Number(Utils.math.sin(x)));
         let acosArg = (cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta);
         if (acosArg < -1) {
             acosArg = -1;
         } else if (acosArg > 1) {
             acosArg = 1;
         }
-        const gammaStar = math.acos(acosArg);
-        const cosGammaStar = math.cos(gammaStar);
-        const sinGammaStar = math.sin(gammaStar);
+        const gammaStar = Number(Utils.math.acos(acosArg));
+        const cosGammaStar = Number(Utils.math.cos(gammaStar));
+        const sinGammaStar = Number(Utils.math.sin(gammaStar));
 
         return [
             [a * sinBeta, 0.0, a * cosBeta],