@fbltd/math 1.0.2 → 1.0.4

package/dist/bin/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src"), exports);

package/dist/bin/src/angle.js

@@ -0,0 +1,80 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Angle = exports.AngleUnits = void 0;
+var 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; }
+        switch (unit) {
+            case AngleUnits.Rad:
+                return angle;
+            case AngleUnits.Deg:
+                return angle * Math.PI / 180;
+            case AngleUnits.Turn:
+                return Math.PI * 2 * angle;
+        }
+    };
+    Angle.toTurn = function (angle, unit) {
+        if (unit === void 0) { unit = AngleUnits.Deg; }
+        switch (unit) {
+            case AngleUnits.Turn:
+                return angle;
+            case AngleUnits.Deg:
+                return angle / 360;
+            case AngleUnits.Rad:
+                return angle / (Math.PI * 2);
+        }
+    };
+    Angle.toDeg = function (angle, unit) {
+        if (unit === void 0) { unit = AngleUnits.Rad; }
+        switch (unit) {
+            case AngleUnits.Deg:
+                return angle;
+            case AngleUnits.Turn:
+                return angle * 360;
+            case AngleUnits.Rad:
+                return angle * 180 / Math.PI;
+        }
+    };
+    Angle.toPositive = function (angle, unit) {
+        switch (unit) {
+            case AngleUnits.Deg:
+                return (0, utils_1.toPositive)(angle, 360);
+            case AngleUnits.Turn:
+                return (0, utils_1.toPositive)(angle, 1);
+            case AngleUnits.Rad:
+                return (0, utils_1.toPositive)(angle, Math.PI * 2);
+        }
+    };
+    Angle.normalize = function (angle, unit) {
+        switch (unit) {
+            case AngleUnits.Deg:
+                return Angle.toPositive(angle, unit) % 360;
+            case AngleUnits.Rad:
+                return Angle.toPositive(angle, unit) % (Math.PI * 2);
+            case AngleUnits.Turn:
+                return Angle.toPositive(angle, unit) % 1;
+        }
+    };
+    Angle.toCSS = function (angle, unit) {
+        if (!(0, utils_1.isCorrectNumber)(angle))
+            return '';
+        return "rotate(".concat(angle).concat(Angle.angleUnitCorrespondence[unit], ")");
+    };
+    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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color = void 0;
+var Color = (function () {
+    function Color(red, green, blue) {
+        this.red = red;
+        this.green = green;
+        this.blue = blue;
+        this.red = Math.max(Math.min(red, 255), 0);
+        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;
+}());
+exports.Color = Color;

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

@@ -0,0 +1,97 @@
+"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; });
+        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];
+            if (color.angle === angle)
+                return color.color;
+            if (color.angle < angle)
+                prev = color;
+            if (color.angle > angle) {
+                next = color;
+                break;
+            }
+        }
+        if (!prev || !next)
+            return undefined;
+        var 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];
+        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++) {
+            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;
+            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;
+            }
+        }
+        return undefined;
+    };
+    ConicGradient.prototype.isColorInRange = function (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];
+            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];
+            if (s)
+                s += ',';
+            s += "rgb(".concat(color.color.red, ",").concat(color.color.green, ",").concat(color.color.blue, ")");
+        }
+        s = "conic-gradient(in srgb from 0.25turn at 50% 50%, ".concat(s, ")");
+        return s;
+    };
+    return ConicGradient;
+}());
+exports.ConicGradient = ConicGradient;

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./color"), exports);
+__exportStar(require("./conic.gradient"), exports);

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./point"), exports);
+__exportStar(require("./circle"), exports);
+__exportStar(require("./straight-line"), exports);

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

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

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

@@ -0,0 +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) {
+        this.p1 = p1;
+        this.p2 = p2;
+    }
+    StraightLine.prototype.transform = function (matrix, transformThis) {
+        if (transformThis === void 0) { 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/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./angle"), exports);
+__exportStar(require("./matrix"), exports);
+__exportStar(require("./operator"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./colors"), exports);
+__exportStar(require("./figures"), exports);

package/dist/bin/src/matrix.js

@@ -0,0 +1,34 @@
+"use strict";
+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];
+            matrix = [
+                matrix[0] * m[0] + matrix[2] * m[1],
+                matrix[1] * m[0] + matrix[3] * m[1],
+                matrix[0] * m[2] + matrix[2] * m[3],
+                matrix[1] * m[2] + matrix[3] * m[3],
+                matrix[0] * m[4] + matrix[2] * m[5] + matrix[4],
+                matrix[1] * m[4] + matrix[3] * m[5] + matrix[5],
+            ];
+        }
+        return matrix;
+    };
+    Matrix2d.apply = function (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

@@ -0,0 +1,23 @@
+"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; }
+        angle = angle_1.Angle.toRad(angle, unit);
+        this.temp1 = Math.cos(angle);
+        this.temp2 = Math.sin(angle);
+        return [
+            this.temp1,
+            this.temp2,
+            -this.temp2,
+            this.temp1,
+            0, 0
+        ];
+    };
+    return Operator;
+}());
+exports.Operator = Operator;

package/dist/bin/src/utils.js

@@ -0,0 +1,22 @@
+"use strict";
+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; }
+    return Math.abs(theValue - is) <= withPrecision;
+}
+function toPositive(value, range) {
+    if (value >= 0)
+        return Math.abs(value);
+    return Math.abs((range + value % range) % range);
+}
+function isCorrectNumber(value) {
+    var v = +value;
+    if (!isNaN(value) && isFinite(value)) {
+        v = parseFloat(value);
+        return !isNaN(v) && isFinite(v);
+    }
+    return false;
+}

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/dist/types/src/angle.d.ts

@@ -0,0 +1,14 @@
+export declare enum AngleUnits {
+    Deg = 0,
+    Rad = 1,
+    Turn = 2
+}
+export declare class Angle {
+    static toRad(angle: number, unit?: AngleUnits): number;
+    static toTurn(angle: number, unit?: AngleUnits): number;
+    static toDeg(angle: number, unit?: AngleUnits): number;
+    static toPositive(angle: number, unit: AngleUnits): number;
+    static normalize(angle: number, unit: AngleUnits): number;
+    static toCSS(angle: number, unit: AngleUnits): string;
+    static angleUnitCorrespondence: Record<AngleUnits, string>;
+}

package/dist/types/src/colors/color.d.ts

@@ -0,0 +1,7 @@
+export declare class Color {
+    red: number;
+    green: number;
+    blue: number;
+    constructor(red: number, green: number, blue: number);
+    toCSS(): string;
+}

package/dist/types/src/colors/conic.gradient.d.ts

@@ -0,0 +1,17 @@
+import { Color } from "./color";
+import { IPoint2 } from "../figures";
+export declare class ConicGradient {
+    colors: {
+        angle: number;
+        color: Color;
+    }[];
+    constructor(...colors: {
+        angle: number;
+        color: Color;
+    }[]);
+    getColorAtAngle(angle: number): Color;
+    getAngleByColor(color: Color): number;
+    isColorInRange(color: Color): boolean;
+    toCanvas(ctx: CanvasRenderingContext2D, center: IPoint2): CanvasGradient;
+    toCSS(): string;
+}

package/dist/types/src/colors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './color';
+export * from './conic.gradient';

package/dist/types/src/figures/circle.d.ts

@@ -0,0 +1,8 @@
+import { IPoint2 } from "./point";
+import { IMatrix2d } from "../matrix";
+export declare class Circle {
+    center: IPoint2;
+    r: number;
+    constructor(center: IPoint2, r: number);
+    transform(matrix: IMatrix2d): void;
+}

package/dist/types/src/figures/index.d.ts

@@ -0,0 +1,3 @@
+export * from './point';
+export * from './circle';
+export * from './straight-line';

package/dist/types/src/figures/point.d.ts

@@ -0,0 +1,5 @@
+export type IPoint2 = [number, number];
+export declare class Point2 {
+    static sum(p1: IPoint2, p2: IPoint2): IPoint2;
+    static scale(v: IPoint2, factor: number): IPoint2;
+}

package/dist/types/src/figures/straight-line.d.ts

@@ -0,0 +1,8 @@
+import { IPoint2 } from "./point";
+import { IMatrix2d } from "../matrix";
+export declare class StraightLine {
+    p1: IPoint2;
+    p2: IPoint2;
+    constructor(p1: IPoint2, p2: IPoint2);
+    transform(matrix: IMatrix2d, transformThis?: boolean): StraightLine;
+}

package/dist/types/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './angle';
+export * from './matrix';
+export * from './operator';
+export * from './utils';
+export * from './colors';
+export * from './figures';

package/dist/types/src/matrix.d.ts

@@ -0,0 +1,14 @@
+import { IPoint2 } from "./figures";
+export type IMatrix2d = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export declare const identityMatrix: IMatrix2d;
+export declare class Matrix2d {
+    static multiply(matrix: IMatrix2d, ...matrices: IMatrix2d[]): IMatrix2d;
+    static apply(matrix: IMatrix2d, point: IPoint2): IPoint2;
+}

package/dist/types/src/operator.d.ts

@@ -0,0 +1,7 @@
+import { IMatrix2d } from "./matrix";
+import { AngleUnits } from "./angle";
+export declare class Operator {
+    private static temp1;
+    private static temp2;
+    static rotateIdentity(angle: number, unit?: AngleUnits): IMatrix2d;
+}

package/dist/types/src/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function approximately(theValue: number, is: number, withPrecision?: number): boolean;
+export declare function toPositive(value: number, range: number): number;
+export declare function isCorrectNumber(value: any): boolean;

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "@fbltd/math",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "",
-  "main": "index.ts",
+  "main": "dist/bin/index.js",
+  "types": "dist/types/index.d.ts",
+  "files": [
+    "dist",
+    "README.ms"
+  ],
   "scripts": {
-    "build": "node_modules/.bin/tsc",
+    "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": {

package/bundler.config.json

@@ -1,6 +0,0 @@
-{
-    "mode": "development",
-    "entry": "index.ts",
-    "output": "dist/bundled-file.js",
-    "library": "math"
-}

package/index.ts

@@ -1 +0,0 @@
-export * from './src'

package/src/angle.ts

@@ -1,87 +0,0 @@
-import {isCorrectNumber, toPositive} from "./utils";
-
-export enum AngleUnits {
-    Deg = 0,
-    Rad = 1,
-    Turn = 2,
-}
-
-
-export class Angle {
-
-    // region Converters
-    static toRad(angle: number, unit: AngleUnits = AngleUnits.Deg) {
-        switch (unit) {
-            case AngleUnits.Rad:
-                return angle
-            case AngleUnits.Deg:
-                return angle * Math.PI / 180
-            case AngleUnits.Turn:
-                return Math.PI * 2 * angle
-        }
-    }
-
-    static toTurn(angle: number, unit: AngleUnits = AngleUnits.Deg) {
-        switch (unit) {
-            case AngleUnits.Turn:
-                return angle
-            case AngleUnits.Deg:
-                return angle / 360
-            case AngleUnits.Rad:
-                return angle / (Math.PI * 2)
-        }
-    }
-
-    static toDeg(angle: number, unit: AngleUnits = AngleUnits.Rad) {
-        switch (unit) {
-            case AngleUnits.Deg:
-                return angle
-            case AngleUnits.Turn:
-                return angle * 360
-            case AngleUnits.Rad:
-                return angle * 180 / Math.PI
-        }
-    }
-
-    // endregion Converters
-
-    static toPositive(angle: number, unit: AngleUnits) {
-        switch (unit) {
-            case AngleUnits.Deg:
-                return toPositive(angle, 360)
-            case AngleUnits.Turn:
-                return toPositive(angle, 1)
-            case AngleUnits.Rad:
-                return toPositive(angle, Math.PI * 2)
-        }
-    }
-
-    static normalize(angle: number, unit: AngleUnits) {
-        switch (unit) {
-            // 0 - 359.9999
-            case AngleUnits.Deg:
-                return Angle.toPositive(angle, unit) % 360
-            // 0 - Math.PI * 2
-            case AngleUnits.Rad:
-                return Angle.toPositive(angle, unit) % (Math.PI * 2)
-            // 0 - 1
-            case AngleUnits.Turn:
-                return Angle.toPositive(angle, unit) % 1
-        }
-    }
-
-    // region representation
-    static toCSS(angle: number, unit: AngleUnits) {
-        if (!isCorrectNumber(angle)) return ''
-        return `rotate(${angle}${Angle.angleUnitCorrespondence[unit]})`
-    }
-
-    static angleUnitCorrespondence: Record<AngleUnits, string> = {
-        [AngleUnits.Rad]: 'rad',
-        [AngleUnits.Turn]: 'turn',
-        [AngleUnits.Deg]: 'deg',
-    }
-    // endregion representation
-
-}
-

package/src/colors/color.ts

@@ -1,11 +0,0 @@
-export class Color {
-    constructor(public red: number, public green: number, public blue: number) {
-        this.red = Math.max(Math.min(red, 255), 0)
-        this.green = Math.max(Math.min(green, 255), 0)
-        this.blue = Math.max(Math.min(blue, 255), 0)
-    }
-
-    toCSS() {
-        return `rgb(${this.red}, ${this.green}, ${this.blue})`
-    }
-}

package/src/colors/conic.gradient.ts

@@ -1,105 +0,0 @@
-import {Color} from "./color";
-import {IPoint2} from "../figures";
-
-export class ConicGradient {
-    colors: { angle: number, color: Color }[]
-
-    constructor(...colors: { angle: number, color: Color }[]) {
-        this.colors = [...colors].sort((a, b) => a.angle - b.angle)
-        this.colors.push({
-            angle: 1,
-            color: this.colors[0].color
-        })
-    }
-
-    /**
-     * Получить цвет по углу от оси X по часовой стрелке
-     * @param angle единица измерения угла должна быть той же самой, что и углы всех передаваемых в констурктор цветов
-     */
-    getColorAtAngle(angle: number) {
-        let prev = undefined
-        let next = undefined
-        for (let color of this.colors) {
-            if (color.angle === angle) return color.color
-            if (color.angle < angle) prev = color
-            if (color.angle > angle) {
-                next = color
-                break
-            }
-        }
-
-        if (!prev || !next) return undefined
-
-        const coef = (angle - prev.angle) / (next.angle - prev.angle)
-
-        return new 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),
-        )
-    }
-
-    getAngleByColor(color: Color) {
-        let prev: typeof this.colors[number]
-        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 (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
-
-            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))
-            ) {
-
-                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
-    }
-
-    isColorInRange(color: Color): boolean {
-        return Boolean(this.getAngleByColor(color))
-    }
-
-    /**
-     * Для использования метода, углы  должны быть в Turn единицах измерения
-     */
-    toCanvas(ctx: CanvasRenderingContext2D, center: IPoint2) {
-        const gradient = ctx.createConicGradient(0, ...center as [number, number])
-        for (let color of this.colors) {
-            gradient.addColorStop(color.angle, color.color.toCSS())
-        }
-
-        return gradient
-    }
-
-    /**
-     * Для использования метода, углы  должны быть в Turn единицах измерения
-     */
-    toCSS() {
-        let s = ''
-
-        for (let color of this.colors) {
-            if (s) s += ','
-            s += `rgb(${color.color.red},${color.color.green},${color.color.blue})`
-        }
-
-        s = `conic-gradient(in srgb from 0.25turn at 50% 50%, ${s})`
-        return s
-    }
-
-}

package/src/colors/index.ts

@@ -1,2 +0,0 @@
-export * from './color'
-export * from './conic.gradient'

package/src/figures/circle.ts

@@ -1,12 +0,0 @@
-import {IPoint2} from "./point";
-import {IMatrix2d, Matrix2d} from "../matrix";
-
-export class Circle {
-    constructor(public center: IPoint2, public r: number) {
-
-    }
-
-    transform(matrix: IMatrix2d) {
-        this.center = Matrix2d.apply(matrix, this.center)
-    }
-}

package/src/figures/index.ts

@@ -1,3 +0,0 @@
-export * from './point'
-export * from './circle'
-export * from './straight-line'

package/src/figures/point.ts

@@ -1,23 +0,0 @@
-/**
- * Точка/вектор
- */
-export type IPoint2 = [number, number]
-
-/**
- * Точка/вектор
- */
-export class Point2 {
-    static sum(p1: IPoint2, p2: IPoint2): IPoint2 {
-        return [
-            p1[0] + p2[0],
-            p1[1] + p2[1],
-        ]
-    }
-
-    static scale(v: IPoint2, factor: number): IPoint2 {
-        return [
-            v[0] * factor,
-            v[1] * factor,
-        ]
-    }
-}

package/src/figures/straight-line.ts

@@ -1,15 +0,0 @@
-import {IPoint2} from "./point";
-import {IMatrix2d, Matrix2d} from "../matrix";
-
-export class StraightLine {
-    constructor(public p1: IPoint2, public p2: IPoint2) {
-
-    }
-
-    transform(matrix: IMatrix2d, transformThis = false) {
-        if (transformThis) {
-            return this
-        }
-        return new StraightLine(Matrix2d.apply(matrix, this.p1), Matrix2d.apply(matrix, this.p2))
-    }
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-export * from './angle'
-export * from './matrix'
-export * from './operator'
-export * from './utils'
-export * from './colors'
-export * from './figures'

package/src/matrix.ts

@@ -1,32 +0,0 @@
-import {IPoint2} from "./figures";
-
-export type IMatrix2d = [
-    number, number, number,
-    number, number, number,
-]
-
-export const identityMatrix: IMatrix2d = [1, 0, 0, 1, 0, 0]
-
-export class Matrix2d {
-    static multiply(matrix: IMatrix2d, ...matrices: IMatrix2d[]) {
-        for (let m of matrices) {
-            matrix = [
-                matrix[0] * m[0] + matrix[2] * m[1],
-                matrix[1] * m[0] + matrix[3] * m[1],
-                matrix[0] * m[2] + matrix[2] * m[3],
-                matrix[1] * m[2] + matrix[3] * m[3],
-                matrix[0] * m[4] + matrix[2] * m[5] + matrix[4],
-                matrix[1] * m[4] + matrix[3] * m[5] + matrix[5],
-            ]
-        }
-
-        return matrix
-    }
-
-    static apply(matrix: IMatrix2d, point: IPoint2): IPoint2 {
-        return [
-            matrix[0] * point[0] + matrix[2] * point[1] + matrix[4],
-            matrix[1] * point[0] + matrix[3] * point[1] + matrix[5],
-        ]
-    }
-}

package/src/operator.ts

@@ -1,23 +0,0 @@
-import {IMatrix2d} from "./matrix";
-import {Angle, AngleUnits} from "./angle";
-
-export class Operator {
-    private static temp1: number
-    private static temp2: number
-
-    /**
-     * @param angle поворот в градусах
-     */
-    static rotateIdentity(angle: number, unit: AngleUnits = AngleUnits.Deg): IMatrix2d {
-        angle = Angle.toRad(angle, unit)
-        this.temp1 = Math.cos(angle)
-        this.temp2 = Math.sin(angle)
-        return [
-            this.temp1,
-            this.temp2,
-            -this.temp2,
-            this.temp1,
-            0, 0
-        ]
-    }
-}

package/src/utils.ts

@@ -1,17 +0,0 @@
-export function approximately(theValue: number, is: number, withPrecision: number = 1e-8) {
-    return Math.abs(theValue - is) <= withPrecision
-}
-
-export function toPositive(value: number, range: number) {
-    if (value >= 0) return Math.abs(value)
-    return Math.abs((range + value % range) % range)
-}
-
-export function isCorrectNumber(value: any) {
-    let v: number = +value
-    if (!isNaN(value) && isFinite(value)) {
-        v = parseFloat(value)
-        return !isNaN(v) && isFinite(v)
-    }
-    return false
-}

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-    "extends": "./node_modules/@fbltd/bundler/tsconfig.json",
-    "compilerOptions": {
-        "moduleResolution": "Node",
-        "outFile": "dist/math.js",
-        "module": "AMD",
-        "sourceMap": true,
-        "declaration": true
-    }
-}