@js-draw/math 1.10.0 → 1.16.0

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;

package/src/rounding/constants.ts

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

package/src/rounding/getLenAfterDecimal.ts

@@ -0,0 +1,29 @@
+import { numberRegex } from './constants';
+
+
+/**
+ * Returns the length of `numberAsString` after a decimal point.
+ *
+ * For example,
+ * ```ts
+ * getLenAfterDecimal('1.001') // -> 3
+ * ```
+ */
+export const getLenAfterDecimal = (numberAsString: string) => {
+	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/src/rounding/lib.ts

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

package/src/rounding/toRoundedString.test.ts

@@ -0,0 +1,32 @@
+import { toRoundedString } from './toRoundedString';
+
+describe('toRoundedString', () => {
+	it('should round up numbers endings similar to .999999999999999', () => {
+		expect(toRoundedString(0.999999999)).toBe('1');
+		expect(toRoundedString(0.899999999)).toBe('.9');
+		expect(toRoundedString(9.999999999)).toBe('10');
+		expect(toRoundedString(-10.999999999)).toBe('-11');
+	});
+
+	it('should round up numbers similar to 10.999999998', () => {
+		expect(toRoundedString(10.999999998)).toBe('11');
+	});
+
+	it('should round strings with multiple digits after the ending decimal points', () => {
+		expect(toRoundedString(292.2 - 292.8)).toBe('-.6');
+		expect(toRoundedString(4.06425600000023)).toBe('4.064256');
+	});
+
+	it('should round down strings ending endings similar to .00000001', () => {
+		expect(toRoundedString(10.00000001)).toBe('10');
+		expect(toRoundedString(-30.00000001)).toBe('-30');
+		expect(toRoundedString(-14.20000000000002)).toBe('-14.2');
+	});
+
+	it('should not round numbers insufficiently close to the next', () => {
+		expect(toRoundedString(-10.9999)).toBe('-10.9999');
+		expect(toRoundedString(-10.0001)).toBe('-10.0001');
+		expect(toRoundedString(-10.123499)).toBe('-10.123499');
+		expect(toRoundedString(0.00123499)).toBe('.00123499');
+	});
+});

package/src/rounding/toRoundedString.ts

@@ -0,0 +1,57 @@
+import cleanUpNumber from './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));
+ * ```
+ */
+export const toRoundedString = (num: number): string => {
+	// 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/src/rounding/toStringOfSamePrecision.test.ts

@@ -0,0 +1,21 @@
+import { toStringOfSamePrecision } from './toStringOfSamePrecision';
+
+
+it('toStringOfSamePrecision', () => {
+	expect(toStringOfSamePrecision(1.23456, '1.12')).toBe('1.23');
+	expect(toStringOfSamePrecision(1.23456, '1.120')).toBe('1.235');
+	expect(toStringOfSamePrecision(1.23456, '1.1')).toBe('1.2');
+	expect(toStringOfSamePrecision(1.23456, '1.1', '5.32')).toBe('1.23');
+	expect(toStringOfSamePrecision(-1.23456, '1.1', '5.32')).toBe('-1.23');
+	expect(toStringOfSamePrecision(-1.99999, '1.1', '5.32')).toBe('-2');
+	expect(toStringOfSamePrecision(1.99999, '1.1', '5.32')).toBe('2');
+	expect(toStringOfSamePrecision(1.89999, '1.1', '5.32')).toBe('1.9');
+	expect(toStringOfSamePrecision(9.99999999, '-1.1234')).toBe('10');
+	expect(toStringOfSamePrecision(9.999999998999996, '100')).toBe('10');
+	expect(toStringOfSamePrecision(0.000012345, '0.000012')).toBe('.000012');
+	expect(toStringOfSamePrecision(0.000012645, '.000012')).toBe('.000013');
+	expect(toStringOfSamePrecision(-0.09999999999999432, '291.3')).toBe('-.1');
+	expect(toStringOfSamePrecision(-0.9999999999999432, '291.3')).toBe('-1');
+	expect(toStringOfSamePrecision(9998.9, '.1', '-11')).toBe('9998.9');
+	expect(toStringOfSamePrecision(-14.20000000000002, '.000001', '-11')).toBe('-14.2');
+});

package/src/rounding/toStringOfSamePrecision.ts

@@ -0,0 +1,63 @@
+import cleanUpNumber from './cleanUpNumber';
+import { numberRegex } from './constants';
+import getLenAfterDecimal from './getLenAfterDecimal';
+import toRoundedString from './toRoundedString';
+
+// [reference] should be a string representation of a base-10 number (no exponential (e.g. 10e10))
+export const toStringOfSamePrecision = (num: number, ...references: string[]): string => {
+	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/src/shapes/Path.ts

@@ -1,4 +1,3 @@
-import { toRoundedString, toStringOfSamePrecision } from '../rounding';
 import LineSegment2 from './LineSegment2';
 import Mat33 from '../Mat33';
 import Rect2 from './Rect2';
@@ -7,6 +6,8 @@ import Abstract2DShape from './Abstract2DShape';
 import CubicBezier from './CubicBezier';
 import QuadraticBezier from './QuadraticBezier';
 import PointShape2D from './PointShape2D';
+import toRoundedString from '../rounding/toRoundedString';
+import toStringOfSamePrecision from '../rounding/toStringOfSamePrecision';
 
 export enum PathCommandType {
 	LineTo,

package/src/shapes/Triangle.ts

@@ -41,13 +41,13 @@ export default class Triangle extends Abstract2DShape {
 
 	// Transform, treating this as composed of 2D points.
 	public transformed2DBy(affineTransform: Mat33) {
-		return this.map(affineTransform.transformVec2);
+		return this.map(vertex => affineTransform.transformVec2(vertex));
 	}
 
 	// Transforms this by a linear transform --- verticies are treated as
 	// 3D points.
 	public transformedBy(linearTransform: Mat33) {
-		return this.map(linearTransform.transformVec3);
+		return this.map(vertex => linearTransform.transformVec3(vertex));
 	}
 
 	#sides: TriangleBoundary|undefined = undefined;

package/dist/cjs/rounding.js

@@ -1,146 +0,0 @@
-"use strict";
-// @packageDocumentation @internal
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toStringOfSamePrecision = exports.getLenAfterDecimal = exports.toRoundedString = exports.cleanUpNumber = void 0;
-// Clean 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;
-/**
- * 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, exports.cleanUpNumber)(text);
-};
-exports.toRoundedString = toRoundedString;
-const numberExp = /^([-]?)(\d*)[.](\d+)$/;
-const getLenAfterDecimal = (numberAsString) => {
-    const numberMatch = numberExp.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;
-// [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 = numberExp.exec(text);
-    if (!textMatch) {
-        return text;
-    }
-    let decimalPlaces = -1;
-    for (const reference of references) {
-        decimalPlaces = Math.max((0, exports.getLenAfterDecimal)(reference), decimalPlaces);
-    }
-    if (decimalPlaces === -1) {
-        return (0, exports.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 (0, exports.cleanUpNumber)(`${negativeSign}${preDecimal}.${postDecimal}`);
-};
-exports.toStringOfSamePrecision = toStringOfSamePrecision;

package/dist/mjs/rounding.mjs

@@ -1,139 +0,0 @@
-// @packageDocumentation @internal
-// Clean 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;
-};
-/**
- * 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);
-};
-const numberExp = /^([-]?)(\d*)[.](\d+)$/;
-export const getLenAfterDecimal = (numberAsString) => {
-    const numberMatch = numberExp.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;
-};
-// [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 = numberExp.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}`);
-};

package/src/rounding.test.ts

@@ -1,65 +0,0 @@
-import { cleanUpNumber, toRoundedString, toStringOfSamePrecision } from './rounding';
-
-describe('toRoundedString', () => {
-	it('should round up numbers endings similar to .999999999999999', () => {
-		expect(toRoundedString(0.999999999)).toBe('1');
-		expect(toRoundedString(0.899999999)).toBe('.9');
-		expect(toRoundedString(9.999999999)).toBe('10');
-		expect(toRoundedString(-10.999999999)).toBe('-11');
-	});
-
-	it('should round up numbers similar to 10.999999998', () => {
-		expect(toRoundedString(10.999999998)).toBe('11');
-	});
-
-	it('should round strings with multiple digits after the ending decimal points', () => {
-		expect(toRoundedString(292.2 - 292.8)).toBe('-.6');
-		expect(toRoundedString(4.06425600000023)).toBe('4.064256');
-	});
-
-	it('should round down strings ending endings similar to .00000001', () => {
-		expect(toRoundedString(10.00000001)).toBe('10');
-		expect(toRoundedString(-30.00000001)).toBe('-30');
-		expect(toRoundedString(-14.20000000000002)).toBe('-14.2');
-	});
-
-	it('should not round numbers insufficiently close to the next', () => {
-		expect(toRoundedString(-10.9999)).toBe('-10.9999');
-		expect(toRoundedString(-10.0001)).toBe('-10.0001');
-		expect(toRoundedString(-10.123499)).toBe('-10.123499');
-		expect(toRoundedString(0.00123499)).toBe('.00123499');
-	});
-});
-
-it('toStringOfSamePrecision', () => {
-	expect(toStringOfSamePrecision(1.23456, '1.12')).toBe('1.23');
-	expect(toStringOfSamePrecision(1.23456, '1.120')).toBe('1.235');
-	expect(toStringOfSamePrecision(1.23456, '1.1')).toBe('1.2');
-	expect(toStringOfSamePrecision(1.23456, '1.1', '5.32')).toBe('1.23');
-	expect(toStringOfSamePrecision(-1.23456, '1.1', '5.32')).toBe('-1.23');
-	expect(toStringOfSamePrecision(-1.99999, '1.1', '5.32')).toBe('-2');
-	expect(toStringOfSamePrecision(1.99999, '1.1', '5.32')).toBe('2');
-	expect(toStringOfSamePrecision(1.89999, '1.1', '5.32')).toBe('1.9');
-	expect(toStringOfSamePrecision(9.99999999, '-1.1234')).toBe('10');
-	expect(toStringOfSamePrecision(9.999999998999996, '100')).toBe('10');
-	expect(toStringOfSamePrecision(0.000012345, '0.000012')).toBe('.000012');
-	expect(toStringOfSamePrecision(0.000012645, '.000012')).toBe('.000013');
-	expect(toStringOfSamePrecision(-0.09999999999999432, '291.3')).toBe('-.1');
-	expect(toStringOfSamePrecision(-0.9999999999999432, '291.3')).toBe('-1');
-	expect(toStringOfSamePrecision(9998.9, '.1', '-11')).toBe('9998.9');
-	expect(toStringOfSamePrecision(-14.20000000000002, '.000001', '-11')).toBe('-14.2');
-});
-
-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');
-});