diff --git a/modules/math/commons.ts b/modules/math/commons.ts
index e8f721b8..5c95ab52 100644
--- a/modules/math/commons.ts
+++ b/modules/math/commons.ts
@@ -4,10 +4,8 @@ import * as vec from 'math/vec';
 import {perp2d} from 'math/vec';
 import {eqTol} from "../../web/app/brep/geom/tolerance";
 import {IDENTITY_BASIS3} from "math/basis";
-import {distance, distanceSquared3, distanceSquaredAB3, distanceSquaredANegB3} from "math/distance";
-
-export const TOLERANCE = 1E-6;
-export const TOLERANCE_SQ = TOLERANCE * TOLERANCE;
+import {distance} from "math/distance";
+import {TOLERANCE} from "math/equality";
 
 
 export function circleFromPoints(p1, p2, p3) {
@@ -34,38 +32,6 @@ export function norm2(vec) {
   return Math.sqrt(sq);  
 }
 
-export function areEqual(v1, v2, tolerance) {
-  return Math.abs(v1 - v2) < tolerance;
-}
-
-export function areVectorsEqual(v1, v2, toleranceSQ) {
-  return areEqual(distanceSquaredAB3(v1, v2), 0, toleranceSQ);
-}
-
-export function areNegVectorsEqual(v1, v2, toleranceSQ) {
-  return areEqual(distanceSquaredANegB3(v1, v2), 0, toleranceSQ);
-}
-
-export function areVectorsEqual3(v1, v2, toleranceSQ) {
-  return areEqual(distanceSquared3(v1[0], v1[1], v1[2], v2[0], v2[1], v2[2]), 0, toleranceSQ);
-}
-
-export function vectorsEqual(v1, v2) {
-  return areVectorsEqual(v1, v2, TOLERANCE_SQ);
-}
-
-export function equal(v1, v2) {
-  return areEqual(v1, v2, TOLERANCE);
-}
-
-export function strictEqual(a, b) {
-  return a.x == b.x && a.y == b.y && a.z == b.z;
-}
-
-export function strictEqual2D(a, b) {
-  return a.x == b.x && a.y == b.y;
-}
-
 export function rotate(px, py, angle) {
   return rotateInPlace(px, py, angle, new Vector());
 }
diff --git a/modules/math/equality.ts b/modules/math/equality.ts
index e69de29b..2e9c87c6 100644
--- a/modules/math/equality.ts
+++ b/modules/math/equality.ts
@@ -0,0 +1,36 @@
+import {distanceSquared3, distanceSquaredAB3, distanceSquaredANegB3} from "math/distance";
+
+export const TOLERANCE = 1E-6;
+export const TOLERANCE_SQ = TOLERANCE * TOLERANCE;
+
+export function areEqual(v1, v2, tolerance) {
+  return Math.abs(v1 - v2) < tolerance;
+}
+
+export function areVectorsEqual(v1, v2, toleranceSQ) {
+  return areEqual(distanceSquaredAB3(v1, v2), 0, toleranceSQ);
+}
+
+export function areNegVectorsEqual(v1, v2, toleranceSQ) {
+  return areEqual(distanceSquaredANegB3(v1, v2), 0, toleranceSQ);
+}
+
+export function areVectorsEqual3(v1, v2, toleranceSQ) {
+  return areEqual(distanceSquared3(v1[0], v1[1], v1[2], v2[0], v2[1], v2[2]), 0, toleranceSQ);
+}
+
+export function vectorsEqual(v1, v2) {
+  return areVectorsEqual(v1, v2, TOLERANCE_SQ);
+}
+
+export function equal(v1, v2) {
+  return areEqual(v1, v2, TOLERANCE);
+}
+
+export function strictEqual(a, b) {
+  return a.x == b.x && a.y == b.y && a.z == b.z;
+}
+
+export function strictEqual2D(a, b) {
+  return a.x == b.x && a.y == b.y;
+}
\ No newline at end of file
diff --git a/web/app/brep/geom/curves/brepCurve.ts b/web/app/brep/geom/curves/brepCurve.ts
index 9e7de511..df0b1a69 100644
--- a/web/app/brep/geom/curves/brepCurve.ts
+++ b/web/app/brep/geom/curves/brepCurve.ts
@@ -1,6 +1,5 @@
 import NurbsCurve from "./nurbsCurve";
 import {Vec3} from 'math/l3space'
-import {areEqual} from 'math/commons'
 
 import {eqSqTol, ueq, veq, veq3, veqNeg} from "../tolerance";
 import curveIntersect from "../impl/curve/curves-isec";
@@ -10,6 +9,7 @@ import Vector from 'math/vector';
 import cache from "../impl/cache";
 import {Tessellation1D} from "../../../cad/craft/engine/tessellation";
 import {Matrix3} from "math/matrix";
+import {areEqual} from "math/equality";
 
 export default class BrepCurve {
 
diff --git a/web/app/brep/geom/impl/curve/curves-isec.js b/web/app/brep/geom/impl/curve/curves-isec.js
index 53cef3bb..43c5eab7 100644
--- a/web/app/brep/geom/impl/curve/curves-isec.js
+++ b/web/app/brep/geom/impl/curve/curves-isec.js
@@ -1,7 +1,7 @@
 import * as vec from "math/vec";
 import {TOLERANCE, TOLERANCE_SQ} from '../../tolerance';
-import * as math from 'math/commons'
 import {fmin_bfgs} from 'math/optim/bfgs';
+import {areEqual} from "../../../../../../modules/math/equality";
 
 export default function curveIntersect(curve1, curve2, isecRange1, isecRange2, tesselator) {
   
@@ -34,10 +34,10 @@ export default function curveIntersect(curve1, curve2, isecRange1, isecRange2, t
           p0: point1,
           p1: point2
         });
-        if (math.areEqual(u1, l1, TOLERANCE )) {
+        if (areEqual(u1, l1, TOLERANCE )) {
           i ++;
         }
-        if (math.areEqual(u2, l2, TOLERANCE )) {
+        if (areEqual(u2, l2, TOLERANCE )) {
           j ++;
         }
       }
@@ -85,8 +85,8 @@ function intersectSegs(a1, b1, a2, b2) {
   let point1 = vec.add(a1, vec.mul(v1, u1));
   let point2 = vec.add(a2, vec.mul(v2, u2));
   let p2p = vec.lengthSq(vec.sub(point1, point2));
-  let eq = (a, b) => math.areEqual(a, b, TOLERANCE);
-  if (u1 !== Infinity && u2 !== Infinity && math.areEqual(p2p, 0, TOLERANCE_SQ) &&
+  let eq = (a, b) => areEqual(a, b, TOLERANCE);
+  if (u1 !== Infinity && u2 !== Infinity && areEqual(p2p, 0, TOLERANCE_SQ) &&
     ((u1 >0 && u1 < l1) || eq(u1, 0) || eq(u1, l1)) &&
     ((u2 >0 && u2 < l2) || eq(u2, 0) || eq(u2, l2))
   ) {
diff --git a/web/app/brep/geom/impl/nurbs-ext.ts b/web/app/brep/geom/impl/nurbs-ext.ts
index dbe86084..b5030214 100644
--- a/web/app/brep/geom/impl/nurbs-ext.ts
+++ b/web/app/brep/geom/impl/nurbs-ext.ts
@@ -1,8 +1,8 @@
 import * as vec from "math/vec";
-import * as math from 'math/commons'
 import {eqEps, TOLERANCE, TOLERANCE_01, TOLERANCE_SQ} from '../tolerance';
 import {Vec3} from "math/l3space";
 import {fmin_bfgs} from "math/optim/bfgs";
+import {areEqual} from "math/equality";
 
 export interface NurbsCurveData {
   degree: number,
@@ -219,10 +219,10 @@ export function curveIntersect(curve1, curve2) {
           p0: point1,
           p1: point2
         });
-        if (math.areEqual(u1, l1, TOLERANCE )) {
+        if (areEqual(u1, l1, TOLERANCE )) {
           i ++;
         }
-        if (math.areEqual(u2, l2, TOLERANCE )) {
+        if (areEqual(u2, l2, TOLERANCE )) {
           j ++;
         }
       }
@@ -270,8 +270,8 @@ function intersectSegs(a1, b1, a2, b2) {
   let point1 = vec.add(a1, vec.mul(v1, u1));
   let point2 = vec.add(a2, vec.mul(v2, u2));
   let p2p = vec.lengthSq(vec.sub(point1, point2));
-  let eq = (a, b) => math.areEqual(a, b, TOLERANCE);
-  if (u1 !== Infinity && u2 !== Infinity && math.areEqual(p2p, 0, TOLERANCE_SQ) &&
+  let eq = (a, b) => areEqual(a, b, TOLERANCE);
+  if (u1 !== Infinity && u2 !== Infinity && areEqual(p2p, 0, TOLERANCE_SQ) &&
     ((u1 >0 && u1 < l1) || eq(u1, 0) || eq(u1, l1)) &&
     ((u2 >0 && u2 < l2) || eq(u2, 0) || eq(u2, l2))
   ) {
diff --git a/web/app/brep/geom/tolerance.ts b/web/app/brep/geom/tolerance.ts
index 9139ced6..d64cf4dd 100644
--- a/web/app/brep/geom/tolerance.ts
+++ b/web/app/brep/geom/tolerance.ts
@@ -1,5 +1,5 @@
-import {areEqual, areNegVectorsEqual, areVectorsEqual, areVectorsEqual3} from 'math/commons';
 import {distanceSquared3} from "math/distance";
+import {areEqual, areNegVectorsEqual, areVectorsEqual, areVectorsEqual3} from "math/equality";
 
 export const TOLERANCE = 1e-3;
 export const TOLERANCE_SQ = TOLERANCE * TOLERANCE;
diff --git a/web/app/brep/null-face-merge.js b/web/app/brep/null-face-merge.js
index 8ff9e28c..9ebfb361 100644
--- a/web/app/brep/null-face-merge.js
+++ b/web/app/brep/null-face-merge.js
@@ -1,5 +1,5 @@
-import * as math from '../../../modules/math/commons'
 import {Edge} from './topo/edge'
+import {equal} from "math/equality";
 
 export default function({curve, start}) {
 
@@ -14,7 +14,7 @@ export default function({curve, start}) {
     const aTip = curve.closestParam(aE.vertexA.point.data());
     const bTip = curve.closestParam(bE.vertexB.point.data());
 
-    if (math.equal(aTip, bTip)) {
+    if (equal(aTip, bTip)) {
       //swap vertex everywhere
       updateVertex(bE, bE, aE.vertexA);
     } else if (aTip > bTip) {
diff --git a/web/app/brep/operations/boolean.js b/web/app/brep/operations/boolean.js
index 35cef7f4..61d67e2e 100644
--- a/web/app/brep/operations/boolean.js
+++ b/web/app/brep/operations/boolean.js
@@ -4,12 +4,12 @@ import {Loop} from '../topo/loop';
 import {Shell} from '../topo/shell';
 import {Vertex} from '../topo/vertex';
 import {evolveFace} from './evolve-face'
-import * as math from '../../../../modules/math/commons';
 import {eqTol, TOLERANCE, ueq, veq, veqNeg} from '../geom/tolerance';
 import CadError from "../../utils/errors";
 import {createBoundingSurface} from "../brep-builder";
 import BREP_DEBUG from '../debug/brep-debug';
 import {Face} from "../topo/face";
+import {vectorsEqual} from "../../../../modules/math/equality";
 
 
 const A = 0, B = 1;
@@ -650,8 +650,8 @@ function fixCurveDirection(curve, surface1, surface2, operationType) {
 function newEdgeDirectionValidityTest(e, curve) {
   let point = e.halfEdge1.vertexA.point;
   let tangent = curve.tangentAtPoint(point);
-  assert('tangent of originated curve and first halfEdge should be the same', math.vectorsEqual(tangent, e.halfEdge1.tangent(point)));
-  assert('tangent of originated curve and second halfEdge should be the opposite', math.vectorsEqual(tangent._negate(), e.halfEdge2.tangent(point)));
+  assert('tangent of originated curve and first halfEdge should be the same', vectorsEqual(tangent, e.halfEdge1.tangent(point)));
+  assert('tangent of originated curve and second halfEdge should be the opposite', vectorsEqual(tangent._negate(), e.halfEdge2.tangent(point)));
 }
 
 function intersectFaces(shellA, shellB, operationType) {
diff --git a/web/app/cad/assembly/dof/EEDOF.ts b/web/app/cad/assembly/dof/EEDOF.ts
index 74e6a352..b90719e1 100644
--- a/web/app/cad/assembly/dof/EEDOF.ts
+++ b/web/app/cad/assembly/dof/EEDOF.ts
@@ -1,12 +1,13 @@
 import Vector from "math/vector";
 import {FaceTouchAlignConstraint} from "../constraints/faceTouchAlign";
 import {AssemblyDOF, ModificationResponse} from "./assemblyDOF";
-import {areEqual, clamp, DEG_RAD, lineLineIntersection} from "math/commons";
+import {clamp, DEG_RAD, lineLineIntersection} from "math/commons";
 import {ConflictDOF} from "./conflictDOF";
 import {EdgeAlignConstraint} from "../constraints/edgeAlign";
 import {PPEEDOF} from "./PPEEDOF";
 import {EEEEDOF} from "./EEEEDOF";
 import {Matrix3} from "math/matrix";
+import {areEqual} from "math/equality";
 
 const ANGULAR_ALLOWANCE = 10 * DEG_RAD;
 
diff --git a/web/app/cad/assembly/dof/PPDOF.ts b/web/app/cad/assembly/dof/PPDOF.ts
index 84f28273..69fff766 100644
--- a/web/app/cad/assembly/dof/PPDOF.ts
+++ b/web/app/cad/assembly/dof/PPDOF.ts
@@ -3,11 +3,12 @@ import {eqTol} from "../../../brep/geom/tolerance";
 import {FaceTouchAlignConstraint} from "../constraints/faceTouchAlign";
 import {Plane} from './../../../brep/geom/impl/plane';
 import {ANGULAR_ALLOWANCE, AssemblyDOF, ModificationResponse} from "./assemblyDOF";
-import {areEqual, clamp, DEG_RAD} from "math/commons";
+import {clamp, DEG_RAD} from "math/commons";
 import {ConflictDOF} from "./conflictDOF";
 import {PPPPDOF} from "./PPPPDOF";
 import {EdgeAlignConstraint} from "../constraints/edgeAlign";
 import {Matrix3} from "math/matrix";
+import {areEqual} from "math/equality";
 
 export class PPDOF implements AssemblyDOF {
 
diff --git a/web/app/cad/cad-utils.js b/web/app/cad/cad-utils.js
index 5ec934a3..c95d2f64 100644
--- a/web/app/cad/cad-utils.js
+++ b/web/app/cad/cad-utils.js
@@ -3,6 +3,7 @@ import BBox from '../math/bbox'
 import * as math from '../../../modules/math/commons'
 import {MeshSceneSolid} from './scene/wrappers/meshSceneObject'
 import {Matrix3} from 'math/matrix';
+import {equal} from 'math/equality';
 
 export const FACE_COLOR =  0xB0C4DE;
 
@@ -243,7 +244,7 @@ export function normalOfCCWSeq(ccwSequence) {
   for (let i = 2; i < ccwSequence.length; ++i) {
     let c = ccwSequence[i];
     let normal = b.minus(a).cross(c.minus(a)).normalize(); 
-    if (!math.equal(normal.length(), 0)) {
+    if (!equal(normal.length(), 0)) {
       return normal;        
     }
   }
diff --git a/web/app/cad/craft/cutExtrude/cutExtrude.js b/web/app/cad/craft/cutExtrude/cutExtrude.js
index 3854c598..194f1959 100644
--- a/web/app/cad/craft/cutExtrude/cutExtrude.js
+++ b/web/app/cad/craft/cutExtrude/cutExtrude.js
@@ -1,7 +1,7 @@
-import * as math from '../../../../../modules/math/commons'
 import {enclose} from '../../../brep/brep-enclose'
 import {BooleanOperation, combineShells} from '../booleanOperation'
 import {Matrix3} from 'math/matrix';
+import {equal} from 'math/equality';
 
 
 export function Extrude(params, ctx) {
@@ -85,7 +85,7 @@ export function getEncloseDetails(params, contours, target, csys, sketchSurface,
     if (invert) contour.reverse();
 
     const lidPath = [];
-    let applyPrism = !math.equal(params.prism, 1);
+    let applyPrism = !equal(params.prism, 1);
     let prismTr = null;
     if (applyPrism) {
       prismTr = new Matrix3();
diff --git a/web/app/cad/legacy/mesh/revolve.js b/web/app/cad/legacy/mesh/revolve.js
index 75aafdc8..ddb209cb 100644
--- a/web/app/cad/legacy/mesh/revolve.js
+++ b/web/app/cad/legacy/mesh/revolve.js
@@ -1,9 +1,9 @@
 import Vector from 'math/vector';
-import * as math from '../../../../../modules/math/commons'
 import {createShared} from '../../cad-utils'
 import {TriangulatePolygons} from '../../tess/triangulation';
-import {Matrix3} from "../../../../../modules/math/matrix";
-import {distanceAB3} from "../../../../../modules/math/distance";
+import {Matrix3} from "math/matrix";
+import {distanceAB3} from "math/distance";
+import {equal} from "math/equality";
 
 function Group(derivedFrom) {
   this.polygons = [];
@@ -17,10 +17,10 @@ export default function revolve(polygons, axisSegment, angle, resolution) {
     const polygon = [pOrig[p], pOrig[q]];
     
     //skip point if they are on the axis of revolving
-    if (!math.equal(0, distanceAB3(pOrig[q], pRot[q]))) {
+    if (!equal(0, distanceAB3(pOrig[q], pRot[q]))) {
       polygon.push(pRot[q]);
     }
-    if (!math.equal(0, distanceAB3(pOrig[p], pRot[p]))) {
+    if (!equal(0, distanceAB3(pOrig[p], pRot[p]))) {
       polygon.push(pRot[p]);
     }
     if (polygon.length < 3) {
@@ -46,7 +46,7 @@ export default function revolve(polygons, axisSegment, angle, resolution) {
     const face = csgPolygon(polygon, shared);
     out.push(face);
   });
-  if (!math.equal(_360, angle)) {
+  if (!equal(_360, angle)) {
     if (angle < 0) {
       let t = lids;
       lids = polygons;
@@ -76,10 +76,10 @@ export function revolveToTriangles(polygons, axisSegment, angle, resolution, tri
   //add initial polygon
   let lids = revolveIterator(polygons, axisSegment, angle, resolution, (pOrig, pRot, p, q, r, id, i, length) => {
     //skip point if they are on the axis of revolving
-    if (!math.equal(0, distanceAB3(pOrig[q], pRot[q]))) {
+    if (!equal(0, distanceAB3(pOrig[q], pRot[q]))) {
       out.push( [pOrig[p], pOrig[q], pRot[q]] );
     }
-    if (!math.equal(0, distanceAB3(pOrig[p], pRot[p]))) {
+    if (!equal(0, distanceAB3(pOrig[p], pRot[p]))) {
       out.push( [ pRot[q],  pRot[p], pOrig[p]] );
     }
     let last = i === length - 1
@@ -137,7 +137,7 @@ export function revolveIterator(polygons, axisSegment, angle, resolution, callba
 
 
 function addIfNonZero(out, seg) {
-  if (!math.equal(0, distanceAB3(seg[0], seg[1]))) {
+  if (!equal(0, distanceAB3(seg[0], seg[1]))) {
     out.push(seg);
   }
 }
diff --git a/web/app/cad/legacy/mesh/workbench.js b/web/app/cad/legacy/mesh/workbench.js
index 395f3507..61a610dc 100644
--- a/web/app/cad/legacy/mesh/workbench.js
+++ b/web/app/cad/legacy/mesh/workbench.js
@@ -6,6 +6,7 @@ import {Mesh} from '../mesh'
 import revolve from './revolve'
 import {Triangulate} from '../../tess/triangulation'
 import {distanceAB3} from "../../../../../modules/math/distance";
+import {areEqual, equal, strictEqual} from "../../../../../modules/math/equality";
 
 export function sortPolygons(polygons) {
   function Loop(polygon) {
@@ -139,7 +140,7 @@ function _pointOnLine(p, a, b) {
   var abLength = ab.length();
   var apLength = ap.length();
 
-  return apLength > 0 && apLength < abLength && math.areEqual(abLength * apLength, dp, 1E-6);
+  return apLength > 0 && apLength < abLength && areEqual(abLength * apLength, dp, 1E-6);
 }
 
 export function polygonsToSegments(polygons) {
@@ -179,8 +180,8 @@ export function reconstructSketchBounds(csg, face, strict) {
   var planePolygons = [];
   for (var pi = 0; pi < polygons.length; pi++) {
     var poly = polygons[pi];
-    if (math.equal(poly.plane.normal.dot(plane.normal), 1)) {
-      if (math.equal(plane.w, poly.plane.w) && (!strict || !!poly.shared.__tcad && poly.shared.__tcad.faceId  === face.id)) {
+    if (equal(poly.plane.normal.dot(plane.normal), 1)) {
+      if (equal(plane.w, poly.plane.w) && (!strict || !!poly.shared.__tcad && poly.shared.__tcad.faceId  === face.id)) {
         planePolygons.push(poly);
       }
       continue;
@@ -189,9 +190,9 @@ export function reconstructSketchBounds(csg, face, strict) {
     for(p = n - 1, q = 0; q < n; p = q ++) {
       var a = poly.vertices[p];
       var b = poly.vertices[q];
-      var pointAOnPlane = math.equal(plane.signedDistanceToPoint(a.pos), 0);
+      var pointAOnPlane = equal(plane.signedDistanceToPoint(a.pos), 0);
       if (!pointAOnPlane) continue;
-      var pointBOnPlane = math.equal(plane.signedDistanceToPoint(b.pos), 0);
+      var pointBOnPlane = equal(plane.signedDistanceToPoint(b.pos), 0);
       if (pointBOnPlane) {
         outerEdges.push([a.pos, b.pos, poly]);
       }
@@ -206,12 +207,12 @@ export function reconstructSketchBounds(csg, face, strict) {
 }
 
 function pickUpCraftInfo(outline, outerEdges) {
-  var eq = math.strictEqual;
+  var eq = strictEqual;
   for (var psi1 = 0; psi1 < outline.length; psi1++) {
     var s1 = outline[psi1];
     for (var psi2 = 0; psi2 < outerEdges.length; psi2++) {
       var s2 = outerEdges[psi2];
-      if (math.equal(Math.abs(s1[0].minus(s1[1]).unit().dot(s2[0].minus(s2[1]).unit())), 1) &&
+      if (equal(Math.abs(s1[0].minus(s1[1]).unit().dot(s2[0].minus(s2[1]).unit())), 1) &&
           (eq(s1[0], s2[0]) || eq(s1[1], s2[1]) || eq(s1[0], s2[1]) || eq(s1[1], s2[0]) ||
           _pointOnLine(s1[0], s2[0], s2[1]) || _pointOnLine(s1[1], s2[0], s2[1]))) {
           s1[2] = s2[2];
@@ -221,13 +222,13 @@ function pickUpCraftInfo(outline, outerEdges) {
 }
 
 function getOutlineByCollision(segments, outerEdges) {
-  var eq = math.strictEqual;
+  var eq = strictEqual;
   var outline = [];
   for (var psi1 = 0; psi1 < segments.length; psi1++) {
     var s1 = segments[psi1];
     for (var psi2 = 0; psi2 < outerEdges.length; psi2++) {
       var s2 = outerEdges[psi2];
-      if (math.equal(Math.abs(s1[0].minus(s1[1]).unit().dot(s2[0].minus(s2[1]).unit())), 1) &&
+      if (equal(Math.abs(s1[0].minus(s1[1]).unit().dot(s2[0].minus(s2[1]).unit())), 1) &&
         (eq(s1[0], s2[0]) || eq(s1[1], s2[1]) || eq(s1[0], s2[1]) || eq(s1[1], s2[0]) ||
         _pointOnLine(s1[0], s2[0], s2[1]) || _pointOnLine(s1[1], s2[0], s2[1]))) {
         outline.push(s1);
@@ -249,7 +250,7 @@ export function findOutline (planePolygons) {
 
 function removeSharedEdges(segments) {
   segments = segments.slice();
-  var eq = math.strictEqual;
+  var eq = strictEqual;
   for (var psi1 = 0; psi1 < segments.length; psi1++) {
     var s1 = segments[psi1];
     if (s1 == null) continue;
@@ -311,7 +312,7 @@ function removeTJoints(segments) {
   }
   
   var points = pointIndex.getKeys();
-  var eq = math.strictEqual;
+  var eq = strictEqual;
   for (var pi1 = 0; pi1 < points.length; ++pi1) {
     var point = points[pi1];
     var best = null, bestFactor;
@@ -341,7 +342,7 @@ function deleteRedundantPoints(path) {
     var a = path[pi];
     var b = path[bIdx];
     var c = path[(pi + 2) % pathLength];
-    var eq = math.areEqual;
+    var eq = areEqual;
     if (!skipMode) cleanedPath.push(a);
     skipMode = eq(a.minus(b).unit().dot(b.minus(c).unit()), 1, 1E-9);
   }
@@ -350,7 +351,7 @@ function deleteRedundantPoints(path) {
 
 export function segmentsToPaths(segments) {
 
-  var veq = math.strictEqual;
+  var veq = strictEqual;
   var paths = [];
   var index = HashTable.forVector3d();
   var csgIndex = HashTable.forEdge();
@@ -469,7 +470,7 @@ function splitTwoSegments(a, b) {
     // lines are not coplanar
     return null;
   }
-  var veq = math.strictEqual;
+  var veq = strictEqual;
   if (veq(a[0], b[0]) || veq(a[0], b[1]) || veq(a[1], b[0]) || veq(a[1], b[1])) {
     return null;
   }
@@ -494,7 +495,7 @@ function splitTwoSegments(a, b) {
 }
 
 function attract(vectors, precision) {
-  var eq = math.areEqual();
+  var eq = areEqual();
   var dist = distanceAB3;
   vectors = vectors.slice();
   for (var i = 0; i < vectors.length; i++) {
diff --git a/web/app/cad/sketch/sketchBoundaries.js b/web/app/cad/sketch/sketchBoundaries.js
index b49c6d64..96fc3886 100644
--- a/web/app/cad/sketch/sketchBoundaries.js
+++ b/web/app/cad/sketch/sketchBoundaries.js
@@ -1,10 +1,11 @@
-import {areEqual, circleFromPoints, radiusOfCurvature, TOLERANCE} from '../../../../modules/math/commons';
+import {circleFromPoints, radiusOfCurvature} from '../../../../modules/math/commons';
 import * as vec from 'math/vec';
 import {iteratePath} from '../cad-utils';
 import NurbsCurve from '../../brep/geom/curves/nurbsCurve';
 import {veqXYZ} from '../../brep/geom/tolerance';
 import curveTess, {curveTessParams} from '../../brep/geom/impl/curve/curve-tess';
-import {distanceAB} from "../../../../modules/math/distance";
+import {distanceAB} from "math/distance";
+import {areEqual, TOLERANCE} from "math/equality";
 
 export function getSketchBoundaries(sceneFace) {
   const boundary = {lines: [], arcs: [], circles: [], nurbses: []};
diff --git a/web/app/cad/sketch/sketchReader.js b/web/app/cad/sketch/sketchReader.js
index c24ae084..e216026f 100644
--- a/web/app/cad/sketch/sketchReader.js
+++ b/web/app/cad/sketch/sketchReader.js
@@ -1,10 +1,10 @@
 import * as sm from './sketchModel'
 import {Graph} from '../../math/graph'
-import * as math from '../../../../modules/math/commons'
 import {HashTable} from '../../utils/hashmap'
 import Joints from '../../../../modules/gems/joints';
 import sketchObjectGlobalId from './sketchObjectGlobalId';
 import VectorFactory from '../../../../modules/math/vectorFactory';
+import {strictEqual2D} from "../../../../modules/math/equality";
 
 class SketchGeom {
 
@@ -145,10 +145,10 @@ function findClosedContoursFromPairedCurves(segments, result) {
       const s2 = segments[j];
       if (s1.isCurve || s2.isCurve) {
         let paired = false;
-        if (math.strictEqual2D(s1.a, s2.a) && math.strictEqual2D(s1.b, s2.b)) {
+        if (strictEqual2D(s1.a, s2.a) && strictEqual2D(s1.b, s2.b)) {
           paired = true;
           s2.invert();
-        } else if (math.strictEqual2D(s1.a, s2.b) && math.strictEqual2D(s1.b, s2.a)) {
+        } else if (strictEqual2D(s1.a, s2.b) && strictEqual2D(s1.b, s2.a)) {
           paired = true;
         }
         if (paired) {
diff --git a/web/app/cad/tess/pip.js b/web/app/cad/tess/pip.js
index 85a38154..347eba8d 100644
--- a/web/app/cad/tess/pip.js
+++ b/web/app/cad/tess/pip.js
@@ -1,4 +1,4 @@
-import {areEqual} from "../../../../modules/math/commons";
+import {areEqual} from "math/equality";
 
 export default function(outerLoop, innerLoops, tol) {
 
diff --git a/web/app/sketcher/shapes/arc.ts b/web/app/sketcher/shapes/arc.ts
index 12dfa36c..8ceccfe2 100644
--- a/web/app/sketcher/shapes/arc.ts
+++ b/web/app/sketcher/shapes/arc.ts
@@ -1,4 +1,3 @@
-import * as math from 'math/commons';
 import {makeAngle0_360} from 'math/commons';
 import Vector from 'math/vector';
 import {SketchObject, SketchObjectSerializationData} from './sketch-object';
@@ -6,6 +5,7 @@ import {Param} from "./param";
 import {AlgNumConstraint, ConstraintDefinitions} from "../constr/ANConstraints";
 import {EndPoint, SketchPointSerializationData} from "./point";
 import {distance} from "math/distance";
+import {areEqual, TOLERANCE} from "math/equality";
 
 export class Arc extends SketchObject {
 
@@ -95,8 +95,8 @@ export class Arc extends SketchObject {
     let r = this.radiusForDrawing();
     let startAngle = makeAngle0_360(this.getStartAngle());
     let endAngle;
-    if (math.areEqual(this.a.x, this.b.x, math.TOLERANCE) &&
-        math.areEqual(this.a.y, this.b.y, math.TOLERANCE)) {
+    if (areEqual(this.a.x, this.b.x, TOLERANCE) &&
+        areEqual(this.a.y, this.b.y, TOLERANCE)) {
       endAngle = startAngle + 2 * Math.PI;
     } else {
       endAngle = makeAngle0_360(this.getEndAngle());
diff --git a/web/app/sketcher/shapes/elliptical-arc.js b/web/app/sketcher/shapes/elliptical-arc.js
index 536deda5..e3ac7a39 100644
--- a/web/app/sketcher/shapes/elliptical-arc.js
+++ b/web/app/sketcher/shapes/elliptical-arc.js
@@ -1,10 +1,9 @@
 import {Ellipse} from './ellipse'
-
-import * as math from '../../../../modules/math/commons';
 import {swap} from '../../utils/utils'
 import {EndPoint} from "./point";
 import {AlgNumConstraint, ConstraintDefinitions} from "../constr/ANConstraints";
-import {distance} from "../../../../modules/math/distance";
+import {distance} from "math/distance";
+import {areEqual, TOLERANCE} from "math/equality";
 
 export class EllipticalArc extends Ellipse {
 
@@ -37,8 +36,8 @@ export class EllipticalArc extends Ellipse {
     const radiusY = Math.max(this.radiusY, 1e-8);
     let aAngle = this.drawAngle(this.a);
     let bAngle;
-    if (math.areEqual(this.a.x, this.b.x, math.TOLERANCE) &&
-      math.areEqual(this.a.y, this.b.y, math.TOLERANCE)) {
+    if (areEqual(this.a.x, this.b.x, TOLERANCE) &&
+      areEqual(this.a.y, this.b.y, TOLERANCE)) {
       bAngle = aAngle + 2 * Math.PI;
     } else {
       bAngle = this.drawAngle(this.b)
diff --git a/web/app/sketcher/shapes/segment.ts b/web/app/sketcher/shapes/segment.ts
index f25bce10..b1491072 100644
--- a/web/app/sketcher/shapes/segment.ts
+++ b/web/app/sketcher/shapes/segment.ts
@@ -1,11 +1,11 @@
 import {SketchObject, SketchObjectSerializationData} from './sketch-object'
 import Vector from 'math/vector';
-import * as math from 'math/commons'
 import {DEG_RAD, makeAngle0_360} from 'math/commons'
 import {Param} from "./param";
 import {AlgNumConstraint, ConstraintDefinitions} from "../constr/ANConstraints";
 import {EndPoint, SketchPointSerializationData} from "./point";
 import {distanceAB} from "math/distance";
+import {TOLERANCE} from "math/equality";
 
 export class Segment extends SketchObject {
 
@@ -80,7 +80,7 @@ export class Segment extends SketchObject {
   }
 
   recoverIfNecessary() {
-    if (distanceAB(this.a, this.b) > math.TOLERANCE) {
+    if (distanceAB(this.a, this.b) > TOLERANCE) {
       return false;
     } else {
       const recoverLength = 100;