js-draw 0.17.3 → 0.18.0

package/dist/cjs/src/math/Rect2.js

@@ -0,0 +1,234 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const LineSegment2_1 = __importDefault(require("./LineSegment2"));
+const Vec2_1 = require("./Vec2");
+// invariant: w ≥ 0, h ≥ 0.
+class Rect2 {
+    constructor(x, y, w, h) {
+        this.x = x;
+        this.y = y;
+        this.w = w;
+        this.h = h;
+        if (w < 0) {
+            this.x += w;
+            this.w = Math.abs(w);
+        }
+        if (h < 0) {
+            this.y += h;
+            this.h = Math.abs(h);
+        }
+        // Precompute/store vector forms.
+        this.topLeft = Vec2_1.Vec2.of(this.x, this.y);
+        this.size = Vec2_1.Vec2.of(this.w, this.h);
+        this.bottomRight = this.topLeft.plus(this.size);
+        this.center = this.topLeft.plus(this.size.times(0.5));
+        this.area = this.w * this.h;
+    }
+    translatedBy(vec) {
+        return new Rect2(vec.x + this.x, vec.y + this.y, this.w, this.h);
+    }
+    // Returns a copy of this with the given size (but same top-left).
+    resizedTo(size) {
+        return new Rect2(this.x, this.y, size.x, size.y);
+    }
+    containsPoint(other) {
+        return this.x <= other.x && this.y <= other.y
+            && this.x + this.w >= other.x && this.y + this.h >= other.y;
+    }
+    containsRect(other) {
+        return this.x <= other.x && this.y <= other.y
+            && this.bottomRight.x >= other.bottomRight.x
+            && this.bottomRight.y >= other.bottomRight.y;
+    }
+    intersects(other) {
+        // Project along x/y axes.
+        const thisMinX = this.x;
+        const thisMaxX = thisMinX + this.w;
+        const otherMinX = other.x;
+        const otherMaxX = other.x + other.w;
+        if (thisMaxX < otherMinX || thisMinX > otherMaxX) {
+            return false;
+        }
+        const thisMinY = this.y;
+        const thisMaxY = thisMinY + this.h;
+        const otherMinY = other.y;
+        const otherMaxY = other.y + other.h;
+        if (thisMaxY < otherMinY || thisMinY > otherMaxY) {
+            return false;
+        }
+        return true;
+    }
+    // Returns the overlap of this and [other], or null, if no such
+    //          overlap exists
+    intersection(other) {
+        if (!this.intersects(other)) {
+            return null;
+        }
+        const topLeft = this.topLeft.zip(other.topLeft, Math.max);
+        const bottomRight = this.bottomRight.zip(other.bottomRight, Math.min);
+        return Rect2.fromCorners(topLeft, bottomRight);
+    }
+    // Returns a new rectangle containing both [this] and [other].
+    union(other) {
+        const topLeft = this.topLeft.zip(other.topLeft, Math.min);
+        const bottomRight = this.bottomRight.zip(other.bottomRight, Math.max);
+        return Rect2.fromCorners(topLeft, bottomRight);
+    }
+    // Returns a the subdivision of this into [columns] columns
+    // and [rows] rows. For example,
+    //	 Rect2.unitSquare.divideIntoGrid(2, 2)
+    //		-> [ Rect2(0, 0, 0.5, 0.5), Rect2(0.5, 0, 0.5, 0.5), Rect2(0, 0.5, 0.5, 0.5), Rect2(0.5, 0.5, 0.5, 0.5) ]
+    // The rectangles are ordered in row-major order.
+    divideIntoGrid(columns, rows) {
+        const result = [];
+        if (columns <= 0 || rows <= 0) {
+            return result;
+        }
+        const eachRectWidth = this.w / columns;
+        const eachRectHeight = this.h / rows;
+        if (eachRectWidth === 0) {
+            columns = 1;
+        }
+        if (eachRectHeight === 0) {
+            rows = 1;
+        }
+        for (let j = 0; j < rows; j++) {
+            for (let i = 0; i < columns; i++) {
+                const x = eachRectWidth * i + this.x;
+                const y = eachRectHeight * j + this.y;
+                result.push(new Rect2(x, y, eachRectWidth, eachRectHeight));
+            }
+        }
+        return result;
+    }
+    // Returns a rectangle containing this and [point].
+    // [margin] is the minimum distance between the new point and the edge
+    // of the resultant rectangle.
+    grownToPoint(point, margin = 0) {
+        const otherRect = new Rect2(point.x - margin, point.y - margin, margin * 2, margin * 2);
+        return this.union(otherRect);
+    }
+    // Returns this grown by [margin] in both the x and y directions.
+    grownBy(margin) {
+        return new Rect2(this.x - margin, this.y - margin, this.w + margin * 2, this.h + margin * 2);
+    }
+    getClosestPointOnBoundaryTo(target) {
+        const closestEdgePoints = this.getEdges().map(edge => {
+            return edge.closestPointTo(target);
+        });
+        let closest = null;
+        let closestDist = null;
+        for (const point of closestEdgePoints) {
+            const dist = point.minus(target).length();
+            if (closestDist === null || dist < closestDist) {
+                closest = point;
+                closestDist = dist;
+            }
+        }
+        return closest;
+    }
+    get corners() {
+        return [
+            this.bottomRight,
+            this.topRight,
+            this.topLeft,
+            this.bottomLeft,
+        ];
+    }
+    get maxDimension() {
+        return Math.max(this.w, this.h);
+    }
+    get topRight() {
+        return this.bottomRight.plus(Vec2_1.Vec2.of(0, -this.h));
+    }
+    get bottomLeft() {
+        return this.topLeft.plus(Vec2_1.Vec2.of(0, this.h));
+    }
+    get width() {
+        return this.w;
+    }
+    get height() {
+        return this.h;
+    }
+    // Returns edges in the order
+    // [ rightEdge, topEdge, leftEdge, bottomEdge ]
+    getEdges() {
+        const corners = this.corners;
+        return [
+            new LineSegment2_1.default(corners[0], corners[1]),
+            new LineSegment2_1.default(corners[1], corners[2]),
+            new LineSegment2_1.default(corners[2], corners[3]),
+            new LineSegment2_1.default(corners[3], corners[0]),
+        ];
+    }
+    // [affineTransform] is a transformation matrix that both scales and **translates**.
+    // the bounding box of this' four corners after transformed by the given affine transformation.
+    transformedBoundingBox(affineTransform) {
+        return Rect2.bboxOf(this.corners.map(corner => affineTransform.transformVec2(corner)));
+    }
+    /** @return true iff this is equal to [other] ± fuzz */
+    eq(other, fuzz = 0) {
+        return this.topLeft.eq(other.topLeft, fuzz) && this.size.eq(other.size, fuzz);
+    }
+    toString() {
+        return `Rect(point(${this.x}, ${this.y}), size(${this.w}, ${this.h}))`;
+    }
+    static fromCorners(corner1, corner2) {
+        return new Rect2(Math.min(corner1.x, corner2.x), Math.min(corner1.y, corner2.y), Math.abs(corner1.x - corner2.x), Math.abs(corner1.y - corner2.y));
+    }
+    // Returns a box that contains all points in [points] with at least [margin]
+    // between each point and the edge of the box.
+    static bboxOf(points, margin = 0) {
+        let minX = 0;
+        let minY = 0;
+        let maxX = 0;
+        let maxY = 0;
+        let isFirst = true;
+        for (const point of points) {
+            if (isFirst) {
+                minX = point.x;
+                minY = point.y;
+                maxX = point.x;
+                maxY = point.y;
+                isFirst = false;
+            }
+            minX = Math.min(minX, point.x);
+            minY = Math.min(minY, point.y);
+            maxX = Math.max(maxX, point.x);
+            maxY = Math.max(maxY, point.y);
+        }
+        return Rect2.fromCorners(Vec2_1.Vec2.of(minX - margin, minY - margin), Vec2_1.Vec2.of(maxX + margin, maxY + margin));
+    }
+    // @returns a rectangle that contains all of the given rectangles, the bounding box
+    //     of the given rectangles.
+    static union(...rects) {
+        if (rects.length === 0) {
+            return Rect2.empty;
+        }
+        const firstRect = rects[0];
+        let minX = firstRect.topLeft.x;
+        let minY = firstRect.topLeft.y;
+        let maxX = firstRect.bottomRight.x;
+        let maxY = firstRect.bottomRight.y;
+        for (let i = 1; i < rects.length; i++) {
+            const rect = rects[i];
+            minX = Math.min(minX, rect.topLeft.x);
+            minY = Math.min(minY, rect.topLeft.y);
+            maxX = Math.max(maxX, rect.bottomRight.x);
+            maxY = Math.max(maxY, rect.bottomRight.y);
+        }
+        return new Rect2(minX, minY, maxX - minX, maxY - minY);
+    }
+    static of(template) {
+        var _a, _b, _c, _d;
+        const width = (_b = (_a = template.width) !== null && _a !== void 0 ? _a : template.w) !== null && _b !== void 0 ? _b : 0;
+        const height = (_d = (_c = template.height) !== null && _c !== void 0 ? _c : template.h) !== null && _d !== void 0 ? _d : 0;
+        return new Rect2(template.x, template.y, width, height);
+    }
+}
+exports.default = Rect2;
+Rect2.empty = new Rect2(0, 0, 0, 0);
+Rect2.unitSquare = new Rect2(0, 0, 1, 1);

package/dist/cjs/src/math/Triangle.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Triangle {
+    constructor(vertex1, vertex2, vertex3) {
+        this.vertex1 = vertex1;
+        this.vertex2 = vertex2;
+        this.vertex3 = vertex3;
+    }
+    map(mapping) {
+        return new Triangle(mapping(this.vertex1), mapping(this.vertex2), mapping(this.vertex3));
+    }
+    // Transform, treating this as composed of 2D points.
+    transformed2DBy(affineTransform) {
+        return this.map(affineTransform.transformVec2);
+    }
+    // Transforms this by a linear transform --- verticies are treated as
+    // 3D points.
+    transformedBy(linearTransform) {
+        return this.map(linearTransform.transformVec3);
+    }
+}
+exports.default = Triangle;

package/dist/cjs/src/math/Vec2.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vec2 = void 0;
+const Vec3_1 = __importDefault(require("./Vec3"));
+var Vec2;
+(function (Vec2) {
+    Vec2.of = (x, y) => {
+        return Vec3_1.default.of(x, y, 0);
+    };
+    Vec2.ofXY = ({ x, y }) => {
+        return Vec3_1.default.of(x, y, 0);
+    };
+    Vec2.unitX = Vec2.of(1, 0);
+    Vec2.unitY = Vec2.of(0, 1);
+    Vec2.zero = Vec2.of(0, 0);
+})(Vec2 = exports.Vec2 || (exports.Vec2 = {}));

package/dist/cjs/src/math/Vec3.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * A vector with three components. Can also be used to represent a two-component vector.
+ *
+ * A `Vec3` is immutable.
+ */
+class Vec3 {
+    constructor(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    /** Returns the x, y components of this. */
+    get xy() {
+        // Useful for APIs that behave differently if .z is present.
+        return {
+            x: this.x,
+            y: this.y,
+        };
+    }
+    static of(x, y, z) {
+        return new Vec3(x, y, z);
+    }
+    /** Returns this' `idx`th component. For example, `Vec3.of(1, 2, 3).at(1) → 2`. */
+    at(idx) {
+        if (idx === 0)
+            return this.x;
+        if (idx === 1)
+            return this.y;
+        if (idx === 2)
+            return this.z;
+        throw new Error(`${idx} out of bounds!`);
+    }
+    /** Alias for this.magnitude. */
+    length() {
+        return this.magnitude();
+    }
+    magnitude() {
+        return Math.sqrt(this.dot(this));
+    }
+    magnitudeSquared() {
+        return this.dot(this);
+    }
+    /**
+     * Return this' angle in the XY plane (treats this as a Vec2).
+     *
+     * This is equivalent to `Math.atan2(vec.y, vec.x)`.
+     */
+    angle() {
+        return Math.atan2(this.y, this.x);
+    }
+    /**
+     * Returns a unit vector in the same direction as this.
+     *
+     * If `this` has zero length, the resultant vector has `NaN` components.
+     */
+    normalized() {
+        const norm = this.magnitude();
+        return Vec3.of(this.x / norm, this.y / norm, this.z / norm);
+    }
+    /** @returns A copy of `this` multiplied by a scalar. */
+    times(c) {
+        return Vec3.of(this.x * c, this.y * c, this.z * c);
+    }
+    plus(v) {
+        return Vec3.of(this.x + v.x, this.y + v.y, this.z + v.z);
+    }
+    minus(v) {
+        return Vec3.of(this.x - v.x, this.y - v.y, this.z - v.z);
+    }
+    dot(other) {
+        return this.x * other.x + this.y * other.y + this.z * other.z;
+    }
+    cross(other) {
+        // | i  j  k |
+        // | x1 y1 z1| = (i)(y1z2 - y2z1) - (j)(x1z2 - x2z1) + (k)(x1y2 - x2y1)
+        // | x2 y2 z2|
+        return Vec3.of(this.y * other.z - other.y * this.z, other.x * this.z - this.x * other.z, this.x * other.y - other.x * this.y);
+    }
+    /**
+     * If `other` is a `Vec3`, multiplies `this` component-wise by `other`. Otherwise,
+     * if `other is a `number`, returns the result of scalar multiplication.
+     *
+     * @example
+     * ```
+     * Vec3.of(1, 2, 3).scale(Vec3.of(2, 4, 6)); // → Vec3(2, 8, 18)
+     * ```
+     */
+    scale(other) {
+        if (typeof other === 'number') {
+            return this.times(other);
+        }
+        return Vec3.of(this.x * other.x, this.y * other.y, this.z * other.z);
+    }
+    /**
+     * Returns a vector orthogonal to this. If this is a Vec2, returns `this` rotated
+     * 90 degrees counter-clockwise.
+     */
+    orthog() {
+        // If parallel to the z-axis
+        if (this.dot(Vec3.unitX) === 0 && this.dot(Vec3.unitY) === 0) {
+            return this.dot(Vec3.unitX) === 0 ? Vec3.unitX : this.cross(Vec3.unitX).normalized();
+        }
+        return this.cross(Vec3.unitZ.times(-1)).normalized();
+    }
+    /** Returns this plus a vector of length `distance` in `direction`. */
+    extend(distance, direction) {
+        return this.plus(direction.normalized().times(distance));
+    }
+    /** Returns a vector `fractionTo` of the way to target from this. */
+    lerp(target, fractionTo) {
+        return this.times(1 - fractionTo).plus(target.times(fractionTo));
+    }
+    /**
+     * `zip` Maps a component of this and a corresponding component of
+     * `other` to a component of the output vector.
+     *
+     * @example
+     * ```
+     * const a = Vec3.of(1, 2, 3);
+     * const b = Vec3.of(0.5, 2.1, 2.9);
+     *
+     * const zipped = a.zip(b, (aComponent, bComponent) => {
+     *   return Math.min(aComponent, bComponent);
+     * });
+     *
+     * console.log(zipped.toString()); // → Vec(0.5, 2, 2.9)
+     * ```
+     */
+    zip(other, zip) {
+        return Vec3.of(zip(other.x, this.x), zip(other.y, this.y), zip(other.z, this.z));
+    }
+    /**
+     * Returns a vector with each component acted on by `fn`.
+     *
+     * @example
+     * ```
+     * console.log(Vec3.of(1, 2, 3).map(val => val + 1)); // → Vec(2, 3, 4)
+     * ```
+     */
+    map(fn) {
+        return Vec3.of(fn(this.x, 0), fn(this.y, 1), fn(this.z, 2));
+    }
+    asArray() {
+        return [this.x, this.y, this.z];
+    }
+    /**
+     * [fuzz] The maximum difference between two components for this and [other]
+     * to be considered equal.
+     *
+     * @example
+     * ```
+     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 100);  // → true
+     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 0.1);  // → false
+     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 3);    // → true
+     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 3.01); // → true
+     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 2.99); // → false
+     * ```
+     */
+    eq(other, fuzz = 1e-10) {
+        for (let i = 0; i < 3; i++) {
+            if (Math.abs(other.at(i) - this.at(i)) > fuzz) {
+                return false;
+            }
+        }
+        return true;
+    }
+    toString() {
+        return `Vec(${this.x}, ${this.y}, ${this.z})`;
+    }
+}
+exports.default = Vec3;
+Vec3.unitX = Vec3.of(1, 0, 0);
+Vec3.unitY = Vec3.of(0, 1, 0);
+Vec3.unitZ = Vec3.of(0, 0, 1);
+Vec3.zero = Vec3.of(0, 0, 0);

package/dist/cjs/src/math/lib.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vec2 = exports.Vec3 = exports.Rect2 = exports.Path = exports.Mat33 = exports.LineSegment2 = void 0;
+const LineSegment2_1 = __importDefault(require("./LineSegment2"));
+exports.LineSegment2 = LineSegment2_1.default;
+const Mat33_1 = __importDefault(require("./Mat33"));
+exports.Mat33 = Mat33_1.default;
+const Path_1 = __importDefault(require("./Path"));
+exports.Path = Path_1.default;
+const Rect2_1 = __importDefault(require("./Rect2"));
+exports.Rect2 = Rect2_1.default;
+const Vec2_1 = require("./Vec2");
+Object.defineProperty(exports, "Vec2", { enumerable: true, get: function () { return Vec2_1.Vec2; } });
+const Vec3_1 = __importDefault(require("./Vec3"));
+exports.Vec3 = Vec3_1.default;

package/dist/cjs/src/math/rounding.js

@@ -0,0 +1,135 @@
+"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;
+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;