@js-draw/math 1.11.1 → 1.16.0

package/dist/cjs/lib.d.ts

@@ -25,4 +25,4 @@ export { Mat33, Mat33Array } from './Mat33';
 export { Point2, Vec2 } from './Vec2';
 export { Vec3 } from './Vec3';
 export { Color4 } from './Color4';
-export { toRoundedString } from './rounding';
+export * from './rounding/lib';

package/dist/cjs/lib.js

@@ -17,8 +17,22 @@
  *
  * @packageDocumentation
  */
+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 });
-exports.toRoundedString = exports.Color4 = exports.Vec3 = exports.Vec2 = exports.Mat33 = exports.Abstract2DShape = exports.QuadraticBezier = exports.Rect2 = exports.PathCommandType = exports.Path = exports.LineSegment2 = void 0;
+exports.Color4 = exports.Vec3 = exports.Vec2 = exports.Mat33 = exports.Abstract2DShape = exports.QuadraticBezier = exports.Rect2 = exports.PathCommandType = exports.Path = exports.LineSegment2 = void 0;
 var LineSegment2_1 = require("./shapes/LineSegment2");
 Object.defineProperty(exports, "LineSegment2", { enumerable: true, get: function () { return LineSegment2_1.LineSegment2; } });
 var Path_1 = require("./shapes/Path");
@@ -38,7 +52,6 @@ var Vec3_1 = require("./Vec3");
 Object.defineProperty(exports, "Vec3", { enumerable: true, get: function () { return Vec3_1.Vec3; } });
 var Color4_1 = require("./Color4");
 Object.defineProperty(exports, "Color4", { enumerable: true, get: function () { return Color4_1.Color4; } });
-var rounding_1 = require("./rounding");
-Object.defineProperty(exports, "toRoundedString", { enumerable: true, get: function () { return rounding_1.toRoundedString; } });
+__exportStar(require("./rounding/lib"), exports);
 // Note: All above exports cannot use `export { default as ... } from "..."` because this
 // breaks TypeDoc -- TypeDoc otherwise labels any imports of these classes as `default`.

package/dist/cjs/rounding/cleanUpNumber.d.ts

@@ -0,0 +1,3 @@
+/** Cleans up stringified numbers */
+export declare const cleanUpNumber: (text: string) => string;
+export default cleanUpNumber;

package/dist/cjs/rounding/cleanUpNumber.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanUpNumber = void 0;
+/** Cleans up stringified numbers */
+const cleanUpNumber = (text) => {
+    // Regular expression substitions can be somewhat expensive. Only do them
+    // if necessary.
+    if (text.indexOf('e') > 0) {
+        // Round to zero.
+        if (text.match(/[eE][-]\d{2,}$/)) {
+            return '0';
+        }
+    }
+    const lastChar = text.charAt(text.length - 1);
+    if (lastChar === '0' || lastChar === '.') {
+        // Remove trailing zeroes
+        text = text.replace(/([.]\d*[^0]+)0+$/, '$1');
+        text = text.replace(/[.]0+$/, '.');
+        // Remove trailing period
+        text = text.replace(/[.]$/, '');
+    }
+    const firstChar = text.charAt(0);
+    if (firstChar === '0' || firstChar === '-') {
+        // Remove unnecessary leading zeroes.
+        text = text.replace(/^(0+)[.]/, '.');
+        text = text.replace(/^-(0+)[.]/, '-.');
+        text = text.replace(/^(-?)0+$/, '$10');
+    }
+    if (text === '-0') {
+        return '0';
+    }
+    return text;
+};
+exports.cleanUpNumber = cleanUpNumber;
+exports.default = exports.cleanUpNumber;

package/dist/cjs/rounding/constants.d.ts

@@ -0,0 +1 @@
+export declare const numberRegex: RegExp;

package/dist/cjs/rounding/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberRegex = void 0;
+exports.numberRegex = /^([-]?)(\d*)[.](\d+)$/;

package/dist/cjs/rounding/getLenAfterDecimal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns the length of `numberAsString` after a decimal point.
+ *
+ * For example,
+ * ```ts
+ * getLenAfterDecimal('1.001') // -> 3
+ * ```
+ */
+export declare const getLenAfterDecimal: (numberAsString: string) => number;
+export default getLenAfterDecimal;

package/dist/cjs/rounding/getLenAfterDecimal.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLenAfterDecimal = void 0;
+const constants_1 = require("./constants");
+/**
+ * Returns the length of `numberAsString` after a decimal point.
+ *
+ * For example,
+ * ```ts
+ * getLenAfterDecimal('1.001') // -> 3
+ * ```
+ */
+const getLenAfterDecimal = (numberAsString) => {
+    const numberMatch = constants_1.numberRegex.exec(numberAsString);
+    if (!numberMatch) {
+        // If not a match, either the number is exponential notation (or is something
+        // like NaN or Infinity)
+        if (numberAsString.search(/[eE]/) !== -1 || /^[a-zA-Z]+$/.exec(numberAsString)) {
+            return -1;
+            // Or it has no decimal point
+        }
+        else {
+            return 0;
+        }
+    }
+    const afterDecimalLen = numberMatch[3].length;
+    return afterDecimalLen;
+};
+exports.getLenAfterDecimal = getLenAfterDecimal;
+exports.default = exports.getLenAfterDecimal;

package/dist/cjs/rounding/lib.d.ts

@@ -0,0 +1 @@
+export { toRoundedString } from './toRoundedString';

package/dist/cjs/rounding/lib.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRoundedString = void 0;
+var toRoundedString_1 = require("./toRoundedString");
+Object.defineProperty(exports, "toRoundedString", { enumerable: true, get: function () { return toRoundedString_1.toRoundedString; } });

package/dist/cjs/{rounding.d.ts → rounding/toRoundedString.d.ts}

@@ -1,4 +1,3 @@
-export declare const cleanUpNumber: (text: string) => string;
 /**
  * Converts `num` to a string, removing trailing digits that were likely caused by
  * precision errors.
@@ -11,5 +10,4 @@ export declare const cleanUpNumber: (text: string) => string;
  * ```
  */
 export declare const toRoundedString: (num: number) => string;
-export declare const getLenAfterDecimal: (numberAsString: string) => number;
-export declare const toStringOfSamePrecision: (num: number, ...references: string[]) => string;
+export default toRoundedString;

package/dist/cjs/rounding/toRoundedString.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRoundedString = void 0;
+const cleanUpNumber_1 = __importDefault(require("./cleanUpNumber"));
+/**
+ * Converts `num` to a string, removing trailing digits that were likely caused by
+ * precision errors.
+ *
+ * @example
+ * ```ts,runnable,console
+ * import { toRoundedString } from '@js-draw/math';
+ *
+ * console.log('Rounded: ', toRoundedString(1.000000011));
+ * ```
+ */
+const toRoundedString = (num) => {
+    // Try to remove rounding errors. If the number ends in at least three/four zeroes
+    // (or nines) just one or two digits, it's probably a rounding error.
+    const fixRoundingUpExp = /^([-]?\d*\.\d{3,})0{4,}\d{1,4}$/;
+    const hasRoundingDownExp = /^([-]?)(\d*)\.(\d{3,}9{4,})\d{1,4}$/;
+    let text = num.toString(10);
+    if (text.indexOf('.') === -1) {
+        return text;
+    }
+    const roundingDownMatch = hasRoundingDownExp.exec(text);
+    if (roundingDownMatch) {
+        const negativeSign = roundingDownMatch[1];
+        const postDecimalString = roundingDownMatch[3];
+        const lastDigit = parseInt(postDecimalString.charAt(postDecimalString.length - 1), 10);
+        const postDecimal = parseInt(postDecimalString, 10);
+        const preDecimal = parseInt(roundingDownMatch[2], 10);
+        const origPostDecimalString = roundingDownMatch[3];
+        let newPostDecimal = (postDecimal + 10 - lastDigit).toString();
+        let carry = 0;
+        if (newPostDecimal.length > postDecimal.toString().length) {
+            // Left-shift
+            newPostDecimal = newPostDecimal.substring(1);
+            carry = 1;
+        }
+        // parseInt(...).toString() removes leading zeroes. Add them back.
+        while (newPostDecimal.length < origPostDecimalString.length) {
+            newPostDecimal = carry.toString(10) + newPostDecimal;
+            carry = 0;
+        }
+        text = `${negativeSign + (preDecimal + carry).toString()}.${newPostDecimal}`;
+    }
+    text = text.replace(fixRoundingUpExp, '$1');
+    return (0, cleanUpNumber_1.default)(text);
+};
+exports.toRoundedString = toRoundedString;
+exports.default = exports.toRoundedString;

package/dist/cjs/rounding/toStringOfSamePrecision.d.ts

@@ -0,0 +1,2 @@
+export declare const toStringOfSamePrecision: (num: number, ...references: string[]) => string;
+export default toStringOfSamePrecision;

package/dist/cjs/rounding/toStringOfSamePrecision.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStringOfSamePrecision = void 0;
+const cleanUpNumber_1 = __importDefault(require("./cleanUpNumber"));
+const constants_1 = require("./constants");
+const getLenAfterDecimal_1 = __importDefault(require("./getLenAfterDecimal"));
+const toRoundedString_1 = __importDefault(require("./toRoundedString"));
+// [reference] should be a string representation of a base-10 number (no exponential (e.g. 10e10))
+const toStringOfSamePrecision = (num, ...references) => {
+    const text = num.toString(10);
+    const textMatch = constants_1.numberRegex.exec(text);
+    if (!textMatch) {
+        return text;
+    }
+    let decimalPlaces = -1;
+    for (const reference of references) {
+        decimalPlaces = Math.max((0, getLenAfterDecimal_1.default)(reference), decimalPlaces);
+    }
+    if (decimalPlaces === -1) {
+        return (0, toRoundedString_1.default)(num);
+    }
+    // Make text's after decimal length match [afterDecimalLen].
+    let postDecimal = textMatch[3].substring(0, decimalPlaces);
+    let preDecimal = textMatch[2];
+    const nextDigit = textMatch[3].charAt(decimalPlaces);
+    if (nextDigit !== '') {
+        const asNumber = parseInt(nextDigit, 10);
+        if (asNumber >= 5) {
+            // Don't attempt to parseInt() an empty string.
+            if (postDecimal.length > 0) {
+                const leadingZeroMatch = /^(0+)(\d*)$/.exec(postDecimal);
+                let leadingZeroes = '';
+                let postLeading = postDecimal;
+                if (leadingZeroMatch) {
+                    leadingZeroes = leadingZeroMatch[1];
+                    postLeading = leadingZeroMatch[2];
+                }
+                postDecimal = (parseInt(postDecimal) + 1).toString();
+                // If postDecimal got longer, remove leading zeroes if possible
+                if (postDecimal.length > postLeading.length && leadingZeroes.length > 0) {
+                    leadingZeroes = leadingZeroes.substring(1);
+                }
+                postDecimal = leadingZeroes + postDecimal;
+            }
+            if (postDecimal.length === 0 || postDecimal.length > decimalPlaces) {
+                preDecimal = (parseInt(preDecimal) + 1).toString();
+                postDecimal = postDecimal.substring(1);
+            }
+        }
+    }
+    const negativeSign = textMatch[1];
+    return (0, cleanUpNumber_1.default)(`${negativeSign}${preDecimal}.${postDecimal}`);
+};
+exports.toStringOfSamePrecision = toStringOfSamePrecision;
+exports.default = exports.toStringOfSamePrecision;

package/dist/cjs/rounding/toStringOfSamePrecision.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/shapes/Path.js

@@ -4,13 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Path = exports.PathCommandType = void 0;
-const rounding_1 = require("../rounding");
 const LineSegment2_1 = __importDefault(require("./LineSegment2"));
 const Rect2_1 = __importDefault(require("./Rect2"));
 const Vec2_1 = require("../Vec2");
 const CubicBezier_1 = __importDefault(require("./CubicBezier"));
 const QuadraticBezier_1 = __importDefault(require("./QuadraticBezier"));
 const PointShape2D_1 = __importDefault(require("./PointShape2D"));
+const toRoundedString_1 = __importDefault(require("../rounding/toRoundedString"));
+const toStringOfSamePrecision_1 = __importDefault(require("../rounding/toStringOfSamePrecision"));
 var PathCommandType;
 (function (PathCommandType) {
     PathCommandType[PathCommandType["LineTo"] = 0] = "LineTo";
@@ -591,15 +592,15 @@ class Path {
             const absoluteCommandParts = [];
             const relativeCommandParts = [];
             const makeAbsCommand = !prevPoint || onlyAbsCommands;
-            const roundedPrevX = prevPoint ? (0, rounding_1.toRoundedString)(prevPoint.x) : '';
-            const roundedPrevY = prevPoint ? (0, rounding_1.toRoundedString)(prevPoint.y) : '';
+            const roundedPrevX = prevPoint ? (0, toRoundedString_1.default)(prevPoint.x) : '';
+            const roundedPrevY = prevPoint ? (0, toRoundedString_1.default)(prevPoint.y) : '';
             for (const point of points) {
-                const xComponent = (0, rounding_1.toRoundedString)(point.x);
-                const yComponent = (0, rounding_1.toRoundedString)(point.y);
+                const xComponent = (0, toRoundedString_1.default)(point.x);
+                const yComponent = (0, toRoundedString_1.default)(point.y);
                 // Relative commands are often shorter as strings than absolute commands.
                 if (!makeAbsCommand) {
-                    const xComponentRelative = (0, rounding_1.toStringOfSamePrecision)(point.x - prevPoint.x, xComponent, roundedPrevX, roundedPrevY);
-                    const yComponentRelative = (0, rounding_1.toStringOfSamePrecision)(point.y - prevPoint.y, yComponent, roundedPrevX, roundedPrevY);
+                    const xComponentRelative = (0, toStringOfSamePrecision_1.default)(point.x - prevPoint.x, xComponent, roundedPrevX, roundedPrevY);
+                    const yComponentRelative = (0, toStringOfSamePrecision_1.default)(point.y - prevPoint.y, yComponent, roundedPrevX, roundedPrevY);
                     // No need for an additional separator if it starts with a '-'
                     if (yComponentRelative.charAt(0) === '-') {
                         relativeCommandParts.push(`${xComponentRelative}${yComponentRelative}`);

package/dist/mjs/lib.d.ts

@@ -25,4 +25,4 @@ export { Mat33, Mat33Array } from './Mat33';
 export { Point2, Vec2 } from './Vec2';
 export { Vec3 } from './Vec3';
 export { Color4 } from './Color4';
-export { toRoundedString } from './rounding';
+export * from './rounding/lib';

package/dist/mjs/lib.mjs

@@ -25,6 +25,6 @@ export  { Mat33 }  from './Mat33.mjs';
 export  { Vec2 }  from './Vec2.mjs';
 export  { Vec3 }  from './Vec3.mjs';
 export  { Color4 }  from './Color4.mjs';
-export  { toRoundedString }  from './rounding.mjs';
+export  *  from './rounding/lib.mjs';
 // Note: All above exports cannot use `export { default as ... } from "..."` because this
 // breaks TypeDoc -- TypeDoc otherwise labels any imports of these classes as `default`.

package/dist/mjs/rounding/cleanUpNumber.d.ts

@@ -0,0 +1,3 @@
+/** Cleans up stringified numbers */
+export declare const cleanUpNumber: (text: string) => string;
+export default cleanUpNumber;

package/dist/mjs/rounding/cleanUpNumber.mjs

@@ -0,0 +1,31 @@
+/** Cleans up stringified numbers */
+export const cleanUpNumber = (text) => {
+    // Regular expression substitions can be somewhat expensive. Only do them
+    // if necessary.
+    if (text.indexOf('e') > 0) {
+        // Round to zero.
+        if (text.match(/[eE][-]\d{2,}$/)) {
+            return '0';
+        }
+    }
+    const lastChar = text.charAt(text.length - 1);
+    if (lastChar === '0' || lastChar === '.') {
+        // Remove trailing zeroes
+        text = text.replace(/([.]\d*[^0]+)0+$/, '$1');
+        text = text.replace(/[.]0+$/, '.');
+        // Remove trailing period
+        text = text.replace(/[.]$/, '');
+    }
+    const firstChar = text.charAt(0);
+    if (firstChar === '0' || firstChar === '-') {
+        // Remove unnecessary leading zeroes.
+        text = text.replace(/^(0+)[.]/, '.');
+        text = text.replace(/^-(0+)[.]/, '-.');
+        text = text.replace(/^(-?)0+$/, '$10');
+    }
+    if (text === '-0') {
+        return '0';
+    }
+    return text;
+};
+export default cleanUpNumber;

package/dist/mjs/rounding/cleanUpNumber.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/rounding/constants.d.ts

@@ -0,0 +1 @@
+export declare const numberRegex: RegExp;

package/dist/mjs/rounding/constants.mjs

@@ -0,0 +1 @@
+export const numberRegex = /^([-]?)(\d*)[.](\d+)$/;

package/dist/mjs/rounding/getLenAfterDecimal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns the length of `numberAsString` after a decimal point.
+ *
+ * For example,
+ * ```ts
+ * getLenAfterDecimal('1.001') // -> 3
+ * ```
+ */
+export declare const getLenAfterDecimal: (numberAsString: string) => number;
+export default getLenAfterDecimal;

package/dist/mjs/rounding/getLenAfterDecimal.mjs

@@ -0,0 +1,26 @@
+import  { numberRegex }  from './constants.mjs';
+/**
+ * Returns the length of `numberAsString` after a decimal point.
+ *
+ * For example,
+ * ```ts
+ * getLenAfterDecimal('1.001') // -> 3
+ * ```
+ */
+export const getLenAfterDecimal = (numberAsString) => {
+    const numberMatch = numberRegex.exec(numberAsString);
+    if (!numberMatch) {
+        // If not a match, either the number is exponential notation (or is something
+        // like NaN or Infinity)
+        if (numberAsString.search(/[eE]/) !== -1 || /^[a-zA-Z]+$/.exec(numberAsString)) {
+            return -1;
+            // Or it has no decimal point
+        }
+        else {
+            return 0;
+        }
+    }
+    const afterDecimalLen = numberMatch[3].length;
+    return afterDecimalLen;
+};
+export default getLenAfterDecimal;

package/dist/mjs/rounding/lib.d.ts

@@ -0,0 +1 @@
+export { toRoundedString } from './toRoundedString';

package/dist/mjs/rounding/lib.mjs

@@ -0,0 +1 @@
+export  { toRoundedString }  from './toRoundedString.mjs';

package/dist/mjs/{rounding.d.ts → rounding/toRoundedString.d.ts}

@@ -1,4 +1,3 @@
-export declare const cleanUpNumber: (text: string) => string;
 /**
  * Converts `num` to a string, removing trailing digits that were likely caused by
  * precision errors.
@@ -11,5 +10,4 @@ export declare const cleanUpNumber: (text: string) => string;
  * ```
  */
 export declare const toRoundedString: (num: number) => string;
-export declare const getLenAfterDecimal: (numberAsString: string) => number;
-export declare const toStringOfSamePrecision: (num: number, ...references: string[]) => string;
+export default toRoundedString;

package/dist/mjs/rounding/toRoundedString.mjs

@@ -0,0 +1,47 @@
+import  cleanUpNumber  from './cleanUpNumber.mjs';
+/**
+ * Converts `num` to a string, removing trailing digits that were likely caused by
+ * precision errors.
+ *
+ * @example
+ * ```ts,runnable,console
+ * import { toRoundedString } from '@js-draw/math';
+ *
+ * console.log('Rounded: ', toRoundedString(1.000000011));
+ * ```
+ */
+export const toRoundedString = (num) => {
+    // Try to remove rounding errors. If the number ends in at least three/four zeroes
+    // (or nines) just one or two digits, it's probably a rounding error.
+    const fixRoundingUpExp = /^([-]?\d*\.\d{3,})0{4,}\d{1,4}$/;
+    const hasRoundingDownExp = /^([-]?)(\d*)\.(\d{3,}9{4,})\d{1,4}$/;
+    let text = num.toString(10);
+    if (text.indexOf('.') === -1) {
+        return text;
+    }
+    const roundingDownMatch = hasRoundingDownExp.exec(text);
+    if (roundingDownMatch) {
+        const negativeSign = roundingDownMatch[1];
+        const postDecimalString = roundingDownMatch[3];
+        const lastDigit = parseInt(postDecimalString.charAt(postDecimalString.length - 1), 10);
+        const postDecimal = parseInt(postDecimalString, 10);
+        const preDecimal = parseInt(roundingDownMatch[2], 10);
+        const origPostDecimalString = roundingDownMatch[3];
+        let newPostDecimal = (postDecimal + 10 - lastDigit).toString();
+        let carry = 0;
+        if (newPostDecimal.length > postDecimal.toString().length) {
+            // Left-shift
+            newPostDecimal = newPostDecimal.substring(1);
+            carry = 1;
+        }
+        // parseInt(...).toString() removes leading zeroes. Add them back.
+        while (newPostDecimal.length < origPostDecimalString.length) {
+            newPostDecimal = carry.toString(10) + newPostDecimal;
+            carry = 0;
+        }
+        text = `${negativeSign + (preDecimal + carry).toString()}.${newPostDecimal}`;
+    }
+    text = text.replace(fixRoundingUpExp, '$1');
+    return cleanUpNumber(text);
+};
+export default toRoundedString;

package/dist/mjs/rounding/toRoundedString.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/rounding/toStringOfSamePrecision.d.ts

@@ -0,0 +1,2 @@
+export declare const toStringOfSamePrecision: (num: number, ...references: string[]) => string;
+export default toStringOfSamePrecision;

package/dist/mjs/rounding/toStringOfSamePrecision.mjs

@@ -0,0 +1,51 @@
+import  cleanUpNumber  from './cleanUpNumber.mjs';
+import  { numberRegex }  from './constants.mjs';
+import  getLenAfterDecimal  from './getLenAfterDecimal.mjs';
+import  toRoundedString  from './toRoundedString.mjs';
+// [reference] should be a string representation of a base-10 number (no exponential (e.g. 10e10))
+export const toStringOfSamePrecision = (num, ...references) => {
+    const text = num.toString(10);
+    const textMatch = numberRegex.exec(text);
+    if (!textMatch) {
+        return text;
+    }
+    let decimalPlaces = -1;
+    for (const reference of references) {
+        decimalPlaces = Math.max(getLenAfterDecimal(reference), decimalPlaces);
+    }
+    if (decimalPlaces === -1) {
+        return toRoundedString(num);
+    }
+    // Make text's after decimal length match [afterDecimalLen].
+    let postDecimal = textMatch[3].substring(0, decimalPlaces);
+    let preDecimal = textMatch[2];
+    const nextDigit = textMatch[3].charAt(decimalPlaces);
+    if (nextDigit !== '') {
+        const asNumber = parseInt(nextDigit, 10);
+        if (asNumber >= 5) {
+            // Don't attempt to parseInt() an empty string.
+            if (postDecimal.length > 0) {
+                const leadingZeroMatch = /^(0+)(\d*)$/.exec(postDecimal);
+                let leadingZeroes = '';
+                let postLeading = postDecimal;
+                if (leadingZeroMatch) {
+                    leadingZeroes = leadingZeroMatch[1];
+                    postLeading = leadingZeroMatch[2];
+                }
+                postDecimal = (parseInt(postDecimal) + 1).toString();
+                // If postDecimal got longer, remove leading zeroes if possible
+                if (postDecimal.length > postLeading.length && leadingZeroes.length > 0) {
+                    leadingZeroes = leadingZeroes.substring(1);
+                }
+                postDecimal = leadingZeroes + postDecimal;
+            }
+            if (postDecimal.length === 0 || postDecimal.length > decimalPlaces) {
+                preDecimal = (parseInt(preDecimal) + 1).toString();
+                postDecimal = postDecimal.substring(1);
+            }
+        }
+    }
+    const negativeSign = textMatch[1];
+    return cleanUpNumber(`${negativeSign}${preDecimal}.${postDecimal}`);
+};
+export default toStringOfSamePrecision;

package/dist/mjs/rounding/toStringOfSamePrecision.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/shapes/Path.mjs

@@ -1,10 +1,11 @@
-import  { toRoundedString, toStringOfSamePrecision }  from '../rounding.mjs';
 import  LineSegment2  from './LineSegment2.mjs';
 import  Rect2  from './Rect2.mjs';
 import  { Vec2 }  from '../Vec2.mjs';
 import  CubicBezier  from './CubicBezier.mjs';
 import  QuadraticBezier  from './QuadraticBezier.mjs';
 import  PointShape2D  from './PointShape2D.mjs';
+import  toRoundedString  from '../rounding/toRoundedString.mjs';
+import  toStringOfSamePrecision  from '../rounding/toStringOfSamePrecision.mjs';
 export var PathCommandType;
 (function (PathCommandType) {
     PathCommandType[PathCommandType["LineTo"] = 0] = "LineTo";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@js-draw/math",
-	"version": "1.11.1",
+	"version": "1.16.0",
 	"description": "A math library for js-draw. ",
 	"types": "./dist/mjs/lib.d.ts",
 	"main": "./dist/cjs/lib.js",
@@ -45,5 +45,5 @@
 		"svg",
 		"math"
 	],
-	"gitHead": "695cfe01116839842668233a14fa858ad4ae0bac"
+	"gitHead": "b0b6d7165d76582e1c197d0f56a10bfe6b46e2bc"
 }

package/src/lib.ts

@@ -36,7 +36,7 @@ export { Mat33, Mat33Array } from './Mat33';
 export { Point2, Vec2 } from './Vec2';
 export { Vec3 } from './Vec3';
 export { Color4 } from './Color4';
-export { toRoundedString } from './rounding';
+export * from './rounding/lib';
 
 
 // Note: All above exports cannot use `export { default as ... } from "..."` because this

package/src/rounding/cleanUpNumber.test.ts

@@ -0,0 +1,15 @@
+import cleanUpNumber from './cleanUpNumber';
+
+it('cleanUpNumber', () => {
+	expect(cleanUpNumber('000.0000')).toBe('0');
+	expect(cleanUpNumber('-000.0000')).toBe('0');
+	expect(cleanUpNumber('0.0000')).toBe('0');
+	expect(cleanUpNumber('0.001')).toBe('.001');
+	expect(cleanUpNumber('-0.001')).toBe('-.001');
+	expect(cleanUpNumber('-0.000000001')).toBe('-.000000001');
+	expect(cleanUpNumber('-0.00000000100')).toBe('-.000000001');
+	expect(cleanUpNumber('1234')).toBe('1234');
+	expect(cleanUpNumber('1234.5')).toBe('1234.5');
+	expect(cleanUpNumber('1234.500')).toBe('1234.5');
+	expect(cleanUpNumber('1.1368683772161603e-13')).toBe('0');
+});

package/src/rounding/cleanUpNumber.ts

@@ -0,0 +1,38 @@
+/** Cleans up stringified numbers */
+export const cleanUpNumber = (text: string) => {
+	// Regular expression substitions can be somewhat expensive. Only do them
+	// if necessary.
+
+	if (text.indexOf('e') > 0) {
+		// Round to zero.
+		if (text.match(/[eE][-]\d{2,}$/)) {
+			return '0';
+		}
+	}
+
+	const lastChar = text.charAt(text.length - 1);
+	if (lastChar === '0' || lastChar === '.') {
+		// Remove trailing zeroes
+		text = text.replace(/([.]\d*[^0]+)0+$/, '$1');
+		text = text.replace(/[.]0+$/, '.');
+
+		// Remove trailing period
+		text = text.replace(/[.]$/, '');
+	}
+
+	const firstChar = text.charAt(0);
+	if (firstChar === '0' || firstChar === '-') {
+		// Remove unnecessary leading zeroes.
+		text = text.replace(/^(0+)[.]/, '.');
+		text = text.replace(/^-(0+)[.]/, '-.');
+		text = text.replace(/^(-?)0+$/, '$10');
+	}
+
+	if (text === '-0') {
+		return '0';
+	}
+
+	return text;
+};
+
+export default cleanUpNumber;