@fbltd/math 1.0.6 → 1.0.7

package/dist/bin/__tests__/angle.test.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../src");
+describe('math.angle.toDeg', () => {
+    test('from Turn', () => {
+        expect(src_1.Angle.toDeg(1, src_1.AngleUnits.Turn)).toBe(360);
+        expect(src_1.Angle.toDeg(0, src_1.AngleUnits.Turn)).toBe(0);
+        expect(src_1.Angle.toDeg(0.5, src_1.AngleUnits.Turn)).toBe(180);
+        expect(src_1.Angle.toDeg(-0.5, src_1.AngleUnits.Turn)).toBe(-180);
+    });
+    test('from Rad', () => {
+        expect(src_1.Angle.toDeg(Math.PI * 2, src_1.AngleUnits.Rad)).toBe(360);
+        expect(src_1.Angle.toDeg(0, src_1.AngleUnits.Rad)).toBe(0);
+        expect(src_1.Angle.toDeg(Math.PI, src_1.AngleUnits.Rad)).toBe(180);
+        expect(src_1.Angle.toDeg(-Math.PI, src_1.AngleUnits.Rad)).toBe(-180);
+    });
+    test('from Deg', () => {
+        expect(src_1.Angle.toDeg(180, src_1.AngleUnits.Deg)).toBe(180);
+    });
+});
+describe('math.angle.toRad', () => {
+    test('from Rad', () => {
+        expect(src_1.Angle.toRad(1, src_1.AngleUnits.Rad)).toBe(1);
+    });
+    test('from Deg', () => {
+        expect(src_1.Angle.toRad(360, src_1.AngleUnits.Deg)).toBe(Math.PI * 2);
+        expect(src_1.Angle.toRad(0, src_1.AngleUnits.Deg)).toBe(0);
+        expect(src_1.Angle.toRad(180, src_1.AngleUnits.Deg)).toBe(Math.PI);
+        expect(src_1.Angle.toRad(-180, src_1.AngleUnits.Deg)).toBe(-Math.PI);
+    });
+    test('from Turn', () => {
+        expect(src_1.Angle.toRad(1, src_1.AngleUnits.Turn)).toBe(Math.PI * 2);
+        expect(src_1.Angle.toRad(0, src_1.AngleUnits.Turn)).toBe(0);
+        expect(src_1.Angle.toRad(0.5, src_1.AngleUnits.Turn)).toBe(Math.PI);
+        expect(src_1.Angle.toRad(-0.5, src_1.AngleUnits.Turn)).toBe(-Math.PI);
+    });
+});
+describe('math.angle.toTurn', () => {
+    test('from Turn', () => {
+        expect(src_1.Angle.toTurn(0.1, src_1.AngleUnits.Turn)).toBe(0.1);
+    });
+    test('from Deg', () => {
+        expect(src_1.Angle.toTurn(360, src_1.AngleUnits.Deg)).toBe(1);
+        expect(src_1.Angle.toTurn(0, src_1.AngleUnits.Deg)).toBe(0);
+        expect(src_1.Angle.toTurn(180, src_1.AngleUnits.Deg)).toBe(0.5);
+        expect(src_1.Angle.toTurn(-180, src_1.AngleUnits.Deg)).toBe(-0.5);
+    });
+    test('from Rad', () => {
+        expect(src_1.Angle.toTurn(Math.PI * 2, src_1.AngleUnits.Rad)).toBe(1);
+        expect(src_1.Angle.toTurn(0, src_1.AngleUnits.Rad)).toBe(0);
+        expect(src_1.Angle.toTurn(Math.PI, src_1.AngleUnits.Rad)).toBe(0.5);
+        expect(src_1.Angle.toTurn(-Math.PI, src_1.AngleUnits.Rad)).toBe(-0.5);
+    });
+});
+describe('math.angle.toPositive', () => {
+    test('deg', () => {
+        expect(src_1.Angle.toPositive(0, src_1.AngleUnits.Deg)).toBe(0);
+        expect(src_1.Angle.toPositive(-0, src_1.AngleUnits.Deg)).toBe(0);
+        expect(src_1.Angle.toPositive(-721, src_1.AngleUnits.Deg)).toBe(359);
+        expect(src_1.Angle.toPositive(361, src_1.AngleUnits.Deg)).toBe(361);
+    });
+    test('rad', () => {
+        expect(src_1.Angle.toPositive(0, src_1.AngleUnits.Rad)).toBe(0);
+        expect(src_1.Angle.toPositive(-0, src_1.AngleUnits.Rad)).toBe(0);
+        expect(src_1.Angle.toPositive(-Math.PI, src_1.AngleUnits.Rad)).toBe(Math.PI);
+        expect(src_1.Angle.toPositive(-(Math.PI * 3), src_1.AngleUnits.Rad)).toBe(Math.PI);
+    });
+    test('turn', () => {
+        expect(src_1.Angle.toPositive(0, src_1.AngleUnits.Turn)).toBe(0);
+        expect(src_1.Angle.toPositive(-0, src_1.AngleUnits.Turn)).toBe(0);
+        expect((0, src_1.approximately)(src_1.Angle.toPositive(-1.1, src_1.AngleUnits.Turn), 0.9)).toBe(true);
+        expect(src_1.Angle.toPositive(1.1, src_1.AngleUnits.Turn)).toBe(1.1);
+    });
+});
+describe('math.angle.normalize', () => {
+    test('deg', () => {
+        expect(src_1.Angle.normalize(0, src_1.AngleUnits.Deg)).toBe(0);
+        expect(src_1.Angle.normalize(-0, src_1.AngleUnits.Deg)).toBe(0);
+        expect(src_1.Angle.normalize(-721, src_1.AngleUnits.Deg)).toBe(359);
+        expect(src_1.Angle.normalize(721, src_1.AngleUnits.Deg)).toBe(1);
+        expect(src_1.Angle.normalize(361, src_1.AngleUnits.Deg)).toBe(1);
+        expect(src_1.Angle.normalize(360, src_1.AngleUnits.Deg)).toBe(0);
+        expect(src_1.Angle.normalize(-360, src_1.AngleUnits.Deg)).toBe(0);
+    });
+    test('rad', () => {
+        expect(src_1.Angle.normalize(0, src_1.AngleUnits.Rad)).toBe(0);
+        expect(src_1.Angle.normalize(-0, src_1.AngleUnits.Rad)).toBe(0);
+        expect(src_1.Angle.normalize(-(Math.PI * 3), src_1.AngleUnits.Rad)).toBe(Math.PI);
+        expect(src_1.Angle.normalize(Math.PI * 3, src_1.AngleUnits.Rad)).toBe(Math.PI);
+        expect((0, src_1.approximately)(src_1.Angle.normalize(Math.PI * 2 + 0.01, src_1.AngleUnits.Rad), 0.01)).toBe(true);
+        expect(src_1.Angle.normalize(Math.PI * 2, src_1.AngleUnits.Rad)).toBe(0);
+        expect(src_1.Angle.normalize(-Math.PI * 2, src_1.AngleUnits.Rad)).toBe(0);
+    });
+    test('turn', () => {
+    });
+});
+describe('math.angle.toCSS', () => {
+    expect(src_1.Angle.toCSS(1, src_1.AngleUnits.Deg)).toEqual('rotate(1deg)');
+    expect(src_1.Angle.toCSS(1, src_1.AngleUnits.Rad)).toEqual('rotate(1rad)');
+    expect(src_1.Angle.toCSS(1, src_1.AngleUnits.Turn)).toEqual('rotate(1turn)');
+    expect(src_1.Angle.toCSS(-1, src_1.AngleUnits.Deg)).toEqual('rotate(-1deg)');
+    expect(src_1.Angle.toCSS(-1, src_1.AngleUnits.Rad)).toEqual('rotate(-1rad)');
+    expect(src_1.Angle.toCSS(-1, src_1.AngleUnits.Turn)).toEqual('rotate(-1turn)');
+    expect(src_1.Angle.toCSS(NaN, src_1.AngleUnits.Deg)).toEqual('');
+    expect(src_1.Angle.toCSS(Infinity, src_1.AngleUnits.Rad)).toEqual('');
+    expect(src_1.Angle.toCSS(-Infinity, src_1.AngleUnits.Turn)).toEqual('');
+    expect(src_1.Angle.toCSS('1e -08', src_1.AngleUnits.Deg)).toEqual('');
+    expect(src_1.Angle.toCSS(undefined, src_1.AngleUnits.Deg)).toEqual('');
+    expect(src_1.Angle.toCSS(null, src_1.AngleUnits.Deg)).toEqual('');
+});

package/dist/bin/__tests__/utils.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../src");
+test('approximately', () => {
+    expect((0, src_1.approximately)(0, 0)).toBe(true);
+    expect((0, src_1.approximately)(1 + 1e-8, 1)).toBe(true);
+    expect((0, src_1.approximately)(-1 - 1e-8, -1)).toBe(true);
+    expect((0, src_1.approximately)(1 + 1e-8 + 1e-9, 1)).toBe(false);
+    expect((0, src_1.approximately)(-1 - 1e-8 - 1e-9, -1)).toBe(false);
+    expect((0, src_1.approximately)(0, 0.1)).toBe(false);
+    expect((0, src_1.approximately)(0, 0.1, 0.1)).toBe(true);
+});
+test('toPositive', () => {
+    expect((0, src_1.toPositive)(-1, 360)).toEqual(359);
+    expect((0, src_1.toPositive)(1, 360)).toEqual(1);
+    expect((0, src_1.toPositive)(0, 1)).toEqual(0);
+    expect((0, src_1.toPositive)(-720, 360)).toEqual(0);
+    expect((0, src_1.toPositive)(-721, 360)).toEqual(359);
+    expect((0, src_1.toPositive)(-0, 0)).toEqual(0);
+});
+test('isCorrectNumber', () => {
+    expect((0, src_1.isCorrectNumber)(0)).toBe(true);
+    expect((0, src_1.isCorrectNumber)('0')).toBe(true);
+    expect((0, src_1.isCorrectNumber)('0e-08')).toBe(true);
+    expect((0, src_1.isCorrectNumber)('0e -08')).toBe(false);
+    expect((0, src_1.isCorrectNumber)({ 1: 2 })).toBe(false);
+    expect((0, src_1.isCorrectNumber)(null)).toBe(false);
+    expect((0, src_1.isCorrectNumber)(undefined)).toBe(false);
+    expect((0, src_1.isCorrectNumber)(Infinity)).toBe(false);
+    expect((0, src_1.isCorrectNumber)(-Infinity)).toBe(false);
+    expect((0, src_1.isCorrectNumber)(NaN)).toBe(false);
+    expect((0, src_1.isCorrectNumber)('')).toBe(false);
+});

package/dist/bin/src/angle.js

@@ -1,19 +1,15 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Angle = exports.AngleUnits = void 0;
-var utils_1 = require("./utils");
+const utils_1 = require("./utils");
 var AngleUnits;
 (function (AngleUnits) {
     AngleUnits[AngleUnits["Deg"] = 0] = "Deg";
     AngleUnits[AngleUnits["Rad"] = 1] = "Rad";
     AngleUnits[AngleUnits["Turn"] = 2] = "Turn";
 })(AngleUnits || (exports.AngleUnits = AngleUnits = {}));
-var Angle = (function () {
-    function Angle() {
-    }
-    Angle.toRad = function (angle, unit) {
-        if (unit === void 0) { unit = AngleUnits.Deg; }
+class Angle {
+    static toRad(angle, unit = AngleUnits.Deg) {
         switch (unit) {
             case AngleUnits.Rad:
                 return angle;
@@ -22,9 +18,8 @@ var Angle = (function () {
             case AngleUnits.Turn:
                 return Math.PI * 2 * angle;
         }
-    };
-    Angle.toTurn = function (angle, unit) {
-        if (unit === void 0) { unit = AngleUnits.Deg; }
+    }
+    static toTurn(angle, unit = AngleUnits.Deg) {
         switch (unit) {
             case AngleUnits.Turn:
                 return angle;
@@ -33,9 +28,8 @@ var Angle = (function () {
             case AngleUnits.Rad:
                 return angle / (Math.PI * 2);
         }
-    };
-    Angle.toDeg = function (angle, unit) {
-        if (unit === void 0) { unit = AngleUnits.Rad; }
+    }
+    static toDeg(angle, unit = AngleUnits.Rad) {
         switch (unit) {
             case AngleUnits.Deg:
                 return angle;
@@ -44,8 +38,8 @@ var Angle = (function () {
             case AngleUnits.Rad:
                 return angle * 180 / Math.PI;
         }
-    };
-    Angle.toPositive = function (angle, unit) {
+    }
+    static toPositive(angle, unit) {
         switch (unit) {
             case AngleUnits.Deg:
                 return (0, utils_1.toPositive)(angle, 360);
@@ -54,8 +48,8 @@ var Angle = (function () {
             case AngleUnits.Rad:
                 return (0, utils_1.toPositive)(angle, Math.PI * 2);
         }
-    };
-    Angle.normalize = function (angle, unit) {
+    }
+    static normalize(angle, unit) {
         switch (unit) {
             case AngleUnits.Deg:
                 return Angle.toPositive(angle, unit) % 360;
@@ -64,17 +58,16 @@ var Angle = (function () {
             case AngleUnits.Turn:
                 return Angle.toPositive(angle, unit) % 1;
         }
-    };
-    Angle.toCSS = function (angle, unit) {
+    }
+    static toCSS(angle, unit) {
         if (!(0, utils_1.isCorrectNumber)(angle))
             return '';
-        return "rotate(".concat(angle).concat(Angle.angleUnitCorrespondence[unit], ")");
+        return `rotate(${angle}${Angle.angleUnitCorrespondence[unit]})`;
+    }
+    static angleUnitCorrespondence = {
+        [AngleUnits.Rad]: 'rad',
+        [AngleUnits.Turn]: 'turn',
+        [AngleUnits.Deg]: 'deg',
     };
-    Angle.angleUnitCorrespondence = (_a = {},
-        _a[AngleUnits.Rad] = 'rad',
-        _a[AngleUnits.Turn] = 'turn',
-        _a[AngleUnits.Deg] = 'deg',
-        _a);
-    return Angle;
-}());
+}
 exports.Angle = Angle;

package/dist/bin/src/colors/color.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Color = void 0;
-var Color = (function () {
-    function Color(red, green, blue) {
+class Color {
+    red;
+    green;
+    blue;
+    constructor(red, green, blue) {
         this.red = red;
         this.green = green;
         this.blue = blue;
@@ -10,9 +13,8 @@ var Color = (function () {
         this.green = Math.max(Math.min(green, 255), 0);
         this.blue = Math.max(Math.min(blue, 255), 0);
     }
-    Color.prototype.toCSS = function () {
-        return "rgb(".concat(this.red, ", ").concat(this.green, ", ").concat(this.blue, ")");
-    };
-    return Color;
-}());
+    toCSS() {
+        return `rgb(${this.red}, ${this.green}, ${this.blue})`;
+    }
+}
 exports.Color = Color;

package/dist/bin/src/colors/conic.gradient.js

@@ -1,33 +1,20 @@
 "use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConicGradient = void 0;
-var color_1 = require("./color");
-var ConicGradient = (function () {
-    function ConicGradient() {
-        var colors = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            colors[_i] = arguments[_i];
-        }
-        this.colors = __spreadArray([], colors, true).sort(function (a, b) { return a.angle - b.angle; });
+const color_1 = require("./color");
+class ConicGradient {
+    colors;
+    constructor(...colors) {
+        this.colors = [...colors].sort((a, b) => a.angle - b.angle);
         this.colors.push({
             angle: 1,
             color: this.colors[0].color
         });
     }
-    ConicGradient.prototype.getColorAtAngle = function (angle) {
-        var prev = undefined;
-        var next = undefined;
-        for (var _i = 0, _a = this.colors; _i < _a.length; _i++) {
-            var color = _a[_i];
+    getColorAtAngle(angle) {
+        let prev = undefined;
+        let next = undefined;
+        for (let color of this.colors) {
             if (color.angle === angle)
                 return color.color;
             if (color.angle < angle)
@@ -39,59 +26,56 @@ var ConicGradient = (function () {
         }
         if (!prev || !next)
             return undefined;
-        var coef = (angle - prev.angle) / (next.angle - prev.angle);
+        const coef = (angle - prev.angle) / (next.angle - prev.angle);
         return new color_1.Color(Math.floor((next.color.red - prev.color.red) * coef + prev.color.red), Math.floor((next.color.green - prev.color.green) * coef + prev.color.green), Math.floor((next.color.blue - prev.color.blue) * coef + prev.color.blue));
-    };
-    ConicGradient.prototype.getAngleByColor = function (color) {
-        var prev;
-        var next = this.colors[0];
+    }
+    getAngleByColor(color) {
+        let prev;
+        let next = this.colors[0];
         if (color.red === next.color.red && color.green === next.color.green && color.blue === next.color.blue)
             return next.angle;
-        for (var i = 1; i < this.colors.length; i++) {
+        for (let i = 1; i < this.colors.length; i++) {
             next = this.colors[i];
             prev = this.colors[i - 1];
             if (color.red === next.color.red && color.green === next.color.green && color.blue === next.color.blue)
                 return next.angle;
-            var redDif = next.color.red - prev.color.red;
-            var greenDif = next.color.green - prev.color.green;
-            var blueDif = next.color.blue - prev.color.blue;
-            var redDifColor = color.red - prev.color.red;
-            var greenDifColor = color.green - prev.color.green;
-            var blueDifColor = color.blue - prev.color.blue;
+            let redDif = next.color.red - prev.color.red;
+            let greenDif = next.color.green - prev.color.green;
+            let blueDif = next.color.blue - prev.color.blue;
+            let redDifColor = color.red - prev.color.red;
+            let greenDifColor = color.green - prev.color.green;
+            let blueDifColor = color.blue - prev.color.blue;
             if (((redDifColor >= 0 && redDifColor <= redDif) || (redDifColor <= 0 && redDifColor >= redDif)) &&
                 ((greenDifColor >= 0 && greenDifColor <= greenDif) || (greenDifColor <= 0 && greenDifColor >= greenDif)) &&
                 ((blueDifColor >= 0 && blueDifColor <= blueDif) || (blueDifColor <= 0 && blueDifColor >= blueDif))) {
-                var redCoef = ((color.red - prev.color.red) / (next.color.red - prev.color.red));
-                var greenCoef = ((color.green - prev.color.green) / (next.color.green - prev.color.green));
-                var blueCoef = ((color.blue - prev.color.blue) / (next.color.blue - prev.color.blue));
-                var coefs = [redCoef, greenCoef, blueCoef].filter(Boolean);
-                return (next.angle - prev.angle) * Math.min.apply(Math, coefs) + prev.angle;
+                const redCoef = ((color.red - prev.color.red) / (next.color.red - prev.color.red));
+                const greenCoef = ((color.green - prev.color.green) / (next.color.green - prev.color.green));
+                const blueCoef = ((color.blue - prev.color.blue) / (next.color.blue - prev.color.blue));
+                const coefs = [redCoef, greenCoef, blueCoef].filter(Boolean);
+                return (next.angle - prev.angle) * Math.min(...coefs) + prev.angle;
             }
         }
         return undefined;
-    };
-    ConicGradient.prototype.isColorInRange = function (color) {
+    }
+    isColorInRange(color) {
         return Boolean(this.getAngleByColor(color));
-    };
-    ConicGradient.prototype.toCanvas = function (ctx, center) {
-        var gradient = ctx.createConicGradient.apply(ctx, __spreadArray([0], center, false));
-        for (var _i = 0, _a = this.colors; _i < _a.length; _i++) {
-            var color = _a[_i];
+    }
+    toCanvas(ctx, center) {
+        const gradient = ctx.createConicGradient(0, ...center);
+        for (let color of this.colors) {
             gradient.addColorStop(color.angle, color.color.toCSS());
         }
         return gradient;
-    };
-    ConicGradient.prototype.toCSS = function () {
-        var s = '';
-        for (var _i = 0, _a = this.colors; _i < _a.length; _i++) {
-            var color = _a[_i];
+    }
+    toCSS() {
+        let s = '';
+        for (let color of this.colors) {
             if (s)
                 s += ',';
-            s += "rgb(".concat(color.color.red, ",").concat(color.color.green, ",").concat(color.color.blue, ")");
+            s += `rgb(${color.color.red},${color.color.green},${color.color.blue})`;
         }
-        s = "conic-gradient(in srgb from 0.25turn at 50% 50%, ".concat(s, ")");
+        s = `conic-gradient(in srgb from 0.25turn at 50% 50%, ${s})`;
         return s;
-    };
-    return ConicGradient;
-}());
+    }
+}
 exports.ConicGradient = ConicGradient;

package/dist/bin/src/figures/circle.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Circle = void 0;
-var matrix_1 = require("../matrix");
-var Circle = (function () {
-    function Circle(center, r) {
+const matrix_1 = require("../matrix");
+class Circle {
+    center;
+    r;
+    constructor(center, r) {
         this.center = center;
         this.r = r;
     }
-    Circle.prototype.transform = function (matrix) {
+    transform(matrix) {
         this.center = matrix_1.Matrix2d.apply(matrix, this.center);
-    };
-    return Circle;
-}());
+    }
+}
 exports.Circle = Circle;

package/dist/bin/src/figures/point.js

@@ -1,21 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Point2 = void 0;
-var Point2 = (function () {
-    function Point2() {
-    }
-    Point2.sum = function (p1, p2) {
+class Point2 {
+    static sum(p1, p2) {
         return [
             p1[0] + p2[0],
             p1[1] + p2[1],
         ];
-    };
-    Point2.scale = function (v, factor) {
+    }
+    static scale(v, factor) {
         return [
             v[0] * factor,
             v[1] * factor,
         ];
-    };
-    return Point2;
-}());
+    }
+}
 exports.Point2 = Point2;

package/dist/bin/src/figures/straight-line.js

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StraightLine = void 0;
-var matrix_1 = require("../matrix");
-var StraightLine = (function () {
-    function StraightLine(p1, p2) {
+const matrix_1 = require("../matrix");
+class StraightLine {
+    p1;
+    p2;
+    constructor(p1, p2) {
         this.p1 = p1;
         this.p2 = p2;
     }
-    StraightLine.prototype.transform = function (matrix, transformThis) {
-        if (transformThis === void 0) { transformThis = false; }
+    transform(matrix, transformThis = false) {
         if (transformThis) {
             return this;
         }
         return new StraightLine(matrix_1.Matrix2d.apply(matrix, this.p1), matrix_1.Matrix2d.apply(matrix, this.p2));
-    };
-    return StraightLine;
-}());
+    }
+}
 exports.StraightLine = StraightLine;

package/dist/bin/src/matrix.js

@@ -2,16 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Matrix2d = exports.identityMatrix = void 0;
 exports.identityMatrix = [1, 0, 0, 1, 0, 0];
-var Matrix2d = (function () {
-    function Matrix2d() {
-    }
-    Matrix2d.multiply = function (matrix) {
-        var matrices = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            matrices[_i - 1] = arguments[_i];
-        }
-        for (var _a = 0, matrices_1 = matrices; _a < matrices_1.length; _a++) {
-            var m = matrices_1[_a];
+class Matrix2d {
+    static multiply(matrix, ...matrices) {
+        for (let m of matrices) {
             matrix = [
                 matrix[0] * m[0] + matrix[2] * m[1],
                 matrix[1] * m[0] + matrix[3] * m[1],
@@ -22,13 +15,12 @@ var Matrix2d = (function () {
             ];
         }
         return matrix;
-    };
-    Matrix2d.apply = function (matrix, point) {
+    }
+    static apply(matrix, point) {
         return [
             matrix[0] * point[0] + matrix[2] * point[1] + matrix[4],
             matrix[1] * point[0] + matrix[3] * point[1] + matrix[5],
         ];
-    };
-    return Matrix2d;
-}());
+    }
+}
 exports.Matrix2d = Matrix2d;

package/dist/bin/src/operator.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Operator = void 0;
-var angle_1 = require("./angle");
-var Operator = (function () {
-    function Operator() {
-    }
-    Operator.rotateIdentity = function (angle, unit) {
-        if (unit === void 0) { unit = angle_1.AngleUnits.Deg; }
+const angle_1 = require("./angle");
+class Operator {
+    static temp1;
+    static temp2;
+    static rotateIdentity(angle, unit = angle_1.AngleUnits.Deg) {
         angle = angle_1.Angle.toRad(angle, unit);
         this.temp1 = Math.cos(angle);
         this.temp2 = Math.sin(angle);
@@ -17,7 +16,6 @@ var Operator = (function () {
             this.temp1,
             0, 0
         ];
-    };
-    return Operator;
-}());
+    }
+}
 exports.Operator = Operator;

package/dist/bin/src/utils.js

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.approximately = approximately;
 exports.toPositive = toPositive;
 exports.isCorrectNumber = isCorrectNumber;
-function approximately(theValue, is, withPrecision) {
-    if (withPrecision === void 0) { withPrecision = 1e-8; }
+function approximately(theValue, is, withPrecision = 1e-8) {
     return Math.abs(theValue - is) <= withPrecision;
 }
 function toPositive(value, range) {
@@ -13,7 +12,7 @@ function toPositive(value, range) {
     return Math.abs((range + value % range) % range);
 }
 function isCorrectNumber(value) {
-    var v = +value;
+    let v = +value;
     if (!isNaN(value) && isFinite(value)) {
         v = parseFloat(value);
         return !isNaN(v) && isFinite(v);

package/dist/types/__tests__/angle.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=angle.test.d.ts.map

package/dist/types/__tests__/angle.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angle.test.d.ts","sourceRoot":"","sources":["../../../__tests__/angle.test.ts"],"names":[],"mappings":""}

package/dist/types/__tests__/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/types/__tests__/utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../../__tests__/utils.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,39 +1,41 @@
 {
-  "name": "@fbltd/math",
-  "version": "1.0.6",
-  "description": "",
-  "main": "dist/bin/index.js",
-  "types": "dist/types/index.d.ts",
-  "exports": {
-    ".": {
-      "require": "./dist/bin/index.js",
-      "import": "./dist/bin/index.js",
-      "types": "./dist/types/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "README.ms"
-  ],
-  "scripts": {
-    "build": "rm -r dist || echo '' && node_modules/.bin/tsc",
-    "deploy": "npm run build && npm version patch && git push && npm publish",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/GlennMiller1991/math.git"
-  },
-  "author": "",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/GlennMiller1991/math/issues"
-  },
-  "homepage": "https://github.com/GlennMiller1991/math#readme",
-  "dependencies": {
-    "@fbltd/bundler": "^2.0.15"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
+	"name": "@fbltd/math",
+	"version": "1.0.7",
+	"description": "",
+	"main": "dist/bin/index.js",
+	"types": "dist/types/index.d.ts",
+	"type": "module",
+	"exports": {
+		".": {
+			"require": "./dist/bin/index.js",
+			"import": "./dist/bin/index.js",
+			"types": "./dist/types/index.d.ts"
+		}
+	},
+	"files": [
+		"dist",
+		"README.ms"
+	],
+	"scripts": {
+		"build": "rm -r dist || echo '' && node_modules/.bin/tsc",
+		"deploy": "npm run build && npm version patch && git push && npm publish",
+		"make": "node_modules/.bin/fbltd_make",
+		"test": "node_modules/.bin/fbltd_test"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/GlennMiller1991/math.git"
+	},
+	"author": "",
+	"license": "ISC",
+	"bugs": {
+		"url": "https://github.com/GlennMiller1991/math/issues"
+	},
+	"homepage": "https://github.com/GlennMiller1991/math#readme",
+	"publishConfig": {
+		"access": "public"
+	},
+	"devDependencies": {
+		"@fbltd/bundler": "^2.0.46"
+	}
 }