@fulcro/types 0.1.0

package/dist/decimal/arithmetic.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roundParts = exports.powerParts = exports.compareParts = exports.remainderParts = exports.divideParts = exports.multiplyParts = exports.addParts = void 0;
+const parts_1 = require("./parts");
+const round_1 = require("./round");
+/**
+ * The operations of `Decimal`, on parts.
+ *
+ * Each one computes an exact result on integers and hands it to `finish`, which
+ * rounds it into the format once. The care is in keeping "exact" affordable: a
+ * decimal128 exponent spans more than twelve thousand powers of ten, and an
+ * operation that aligned two operands by multiplying one of them out would
+ * build a twelve-thousand-digit integer to add 1 to 10^6000. None of the
+ * operations below lets an intermediate grow past about a hundred digits,
+ * whatever the exponents, and the performance suite holds them to it.
+ */
+/**
+ * Adds two values.
+ *
+ * @param left First operand.
+ * @param right Second operand.
+ * @param mode Rounding mode.
+ * @returns The rounded sum.
+ */
+const addParts = (left, right, mode) => {
+    if (left.kind === 'nan' || right.kind === 'nan')
+        return parts_1.NOT_A_NUMBER;
+    if (left.kind === 'infinity' || right.kind === 'infinity') {
+        if (left.kind === 'infinity' && right.kind === 'infinity') {
+            return left.negative === right.negative ? left : parts_1.NOT_A_NUMBER;
+        }
+        return left.kind === 'infinity' ? left : right;
+    }
+    if ((0, parts_1.isZero)(left) && (0, parts_1.isZero)(right)) {
+        // IEEE 754: a sum of zeros is negative only when both are, or, for zeros
+        // of opposite sign, when rounding towards negative infinity.
+        const negative = left.negative === right.negative ? left.negative : mode === 'floor';
+        return (0, parts_1.zero)(negative);
+    }
+    if ((0, parts_1.isZero)(left))
+        return right;
+    if ((0, parts_1.isZero)(right))
+        return left;
+    // The larger operand in magnitude of exponent goes first; it decides where
+    // the result's last digit can fall.
+    const [larger, smaller] = (0, parts_1.adjustedExponent)(left) >= (0, parts_1.adjustedExponent)(right)
+        ? [left, right]
+        : [right, left];
+    // Exponent of the thirty-fourth digit of the larger operand.
+    const lastPlace = (0, parts_1.adjustedExponent)(larger) - (parts_1.PRECISION - 1);
+    // An operand below a hundredth of that place can only decide the rounding,
+    // never a digit. It is replaced by the smallest non-zero value three places
+    // below it, which rounds every way it would have — up, down, or past a
+    // borrow — and keeps the alignment below to a few dozen digits instead of
+    // one per power of ten between the two.
+    const addend = (0, parts_1.adjustedExponent)(smaller) < lastPlace - 2
+        ? { ...smaller, coefficient: 1n, exponent: lastPlace - 3 }
+        : smaller;
+    const exponent = Math.min(larger.exponent, addend.exponent);
+    const signed = (parts) => {
+        const magnitude = parts.coefficient * (0, parts_1.powerOfTen)(parts.exponent - exponent);
+        return parts.negative ? -magnitude : magnitude;
+    };
+    const sum = signed(larger) + signed(addend);
+    // An exact cancellation is +0, except when rounding towards negative
+    // infinity, where it is -0.
+    if (sum === 0n)
+        return (0, parts_1.zero)(mode === 'floor');
+    return (0, round_1.finish)(sum < 0n, sum < 0n ? -sum : sum, exponent, mode);
+};
+exports.addParts = addParts;
+/**
+ * Multiplies two values.
+ *
+ * The product of two coefficients has at most sixty-eight digits, and the
+ * exponents simply add, so nothing here needs guarding.
+ *
+ * @param left First operand.
+ * @param right Second operand.
+ * @param mode Rounding mode.
+ * @returns The rounded product.
+ */
+const multiplyParts = (left, right, mode) => {
+    const negative = left.negative !== right.negative;
+    if (left.kind === 'nan' || right.kind === 'nan')
+        return parts_1.NOT_A_NUMBER;
+    if (left.kind === 'infinity' || right.kind === 'infinity') {
+        return (0, parts_1.isZero)(left) || (0, parts_1.isZero)(right) ? parts_1.NOT_A_NUMBER : (0, parts_1.infinity)(negative);
+    }
+    return (0, round_1.finish)(negative, left.coefficient * right.coefficient, left.exponent + right.exponent, mode);
+};
+exports.multiplyParts = multiplyParts;
+/**
+ * Divides one value by another.
+ *
+ * The dividend is scaled so that the quotient has thirty-five digits — one
+ * more than the format keeps — and a non-zero remainder is recorded as a
+ * thirty-sixth digit of 1. Those two digits are all the rounding reads, so the
+ * quotient is rounded exactly as the infinitely precise one would be.
+ *
+ * Division by zero follows IEEE 754 rather than throwing: a non-zero value over
+ * zero is an infinity, and zero over zero is not a number.
+ *
+ * @param left Dividend.
+ * @param right Divisor.
+ * @param mode Rounding mode.
+ * @returns The rounded quotient.
+ */
+const divideParts = (left, right, mode) => {
+    const negative = left.negative !== right.negative;
+    if (left.kind === 'nan' || right.kind === 'nan')
+        return parts_1.NOT_A_NUMBER;
+    if (left.kind === 'infinity') {
+        return right.kind === 'infinity' ? parts_1.NOT_A_NUMBER : (0, parts_1.infinity)(negative);
+    }
+    if (right.kind === 'infinity')
+        return (0, parts_1.zero)(negative);
+    if ((0, parts_1.isZero)(right))
+        return (0, parts_1.isZero)(left) ? parts_1.NOT_A_NUMBER : (0, parts_1.infinity)(negative);
+    if ((0, parts_1.isZero)(left))
+        return (0, parts_1.zero)(negative);
+    const shift = Math.max(0, parts_1.PRECISION +
+        1 +
+        (0, parts_1.digitCount)(right.coefficient) -
+        (0, parts_1.digitCount)(left.coefficient));
+    const dividend = left.coefficient * (0, parts_1.powerOfTen)(shift);
+    const quotient = dividend / right.coefficient;
+    const exponent = left.exponent - right.exponent - shift;
+    if (dividend % right.coefficient === 0n) {
+        return (0, round_1.finish)(negative, quotient, exponent, mode);
+    }
+    return (0, round_1.finish)(negative, quotient * 10n + 1n, exponent - 1, mode);
+};
+exports.divideParts = divideParts;
+/**
+ * 10^exponent modulo a value, by repeated squaring.
+ *
+ * What lets the remainder of 1 × 10^6000 by 7 be found without writing out
+ * 10^6000: thirteen squarings of numbers smaller than the divisor.
+ *
+ * @param exponent Non-negative power of ten.
+ * @param modulus Positive modulus.
+ * @returns 10^exponent mod modulus.
+ */
+const powerOfTenModulo = (exponent, modulus) => {
+    let result = 1n % modulus;
+    let base = 10n % modulus;
+    let remaining = exponent;
+    while (remaining > 0) {
+        if (remaining % 2 === 1)
+            result = (result * base) % modulus;
+        base = (base * base) % modulus;
+        remaining = Math.floor(remaining / 2);
+    }
+    return result;
+};
+/**
+ * The remainder of a division truncated towards zero, carrying the sign of the
+ * dividend — what `%` computes on numbers.
+ *
+ * Always exact: the remainder is smaller than the divisor and no finer than the
+ * finer of the two operands, so it always fits the format.
+ *
+ * @param left Dividend.
+ * @param right Divisor.
+ * @returns The remainder.
+ */
+const remainderParts = (left, right) => {
+    if (left.kind === 'nan' || right.kind === 'nan')
+        return parts_1.NOT_A_NUMBER;
+    if (left.kind === 'infinity' || (0, parts_1.isZero)(right))
+        return parts_1.NOT_A_NUMBER;
+    if (right.kind === 'infinity' || (0, parts_1.isZero)(left))
+        return left;
+    // A dividend smaller than the divisor is its own remainder.
+    if ((0, parts_1.adjustedExponent)(left) < (0, parts_1.adjustedExponent)(right))
+        return left;
+    let remainder;
+    let exponent;
+    if (left.exponent >= right.exponent) {
+        // The dividend is coefficient × 10^gap in units of the divisor's last
+        // place, and the gap can be twelve thousand: reduce the power instead.
+        const gap = left.exponent - right.exponent;
+        remainder =
+            (left.coefficient * powerOfTenModulo(gap, right.coefficient)) %
+                right.coefficient;
+        exponent = right.exponent;
+    }
+    else {
+        // The divisor's last place is the coarser one. Since the dividend is at
+        // least as large, the gap is under thirty-four places.
+        remainder =
+            left.coefficient %
+                (right.coefficient * (0, parts_1.powerOfTen)(right.exponent - left.exponent));
+        exponent = left.exponent;
+    }
+    if (remainder === 0n)
+        return (0, parts_1.zero)(left.negative);
+    return (0, round_1.finish)(left.negative, remainder, exponent, 'halfEven');
+};
+exports.remainderParts = remainderParts;
+/**
+ * Compares two values in magnitude and sign.
+ *
+ * @param left First operand.
+ * @param right Second operand.
+ * @returns -1, 0 or 1, or `undefined` when either is not a number, which is
+ * ordered against nothing.
+ */
+const compareParts = (left, right) => {
+    if (left.kind === 'nan' || right.kind === 'nan')
+        return undefined;
+    // Both zeros are equal, whatever their signs.
+    if ((0, parts_1.isZero)(left) && (0, parts_1.isZero)(right))
+        return 0;
+    const sign = (parts) => (0, parts_1.isZero)(parts) ? 0 : parts.negative ? -1 : 1;
+    if (sign(left) !== sign(right))
+        return sign(left) < sign(right) ? -1 : 1;
+    const direction = left.negative ? -1 : 1;
+    if (left.kind === 'infinity' || right.kind === 'infinity') {
+        if (left.kind === right.kind)
+            return 0;
+        return left.kind === 'infinity' ? direction : -direction;
+    }
+    const leftAdjusted = (0, parts_1.adjustedExponent)(left);
+    const rightAdjusted = (0, parts_1.adjustedExponent)(right);
+    if (leftAdjusted !== rightAdjusted) {
+        return leftAdjusted > rightAdjusted ? direction : -direction;
+    }
+    // Same leading exponent, so the alignment is under thirty-four places.
+    const exponent = Math.min(left.exponent, right.exponent);
+    const leftAligned = left.coefficient * (0, parts_1.powerOfTen)(left.exponent - exponent);
+    const rightAligned = right.coefficient * (0, parts_1.powerOfTen)(right.exponent - exponent);
+    if (leftAligned === rightAligned)
+        return 0;
+    return leftAligned > rightAligned ? direction : -direction;
+};
+exports.compareParts = compareParts;
+/** One, the result of any value raised to the power zero. */
+const ONE = {
+    kind: 'finite',
+    negative: false,
+    coefficient: 1n,
+    exponent: 0,
+};
+/**
+ * The largest exact power computed, in digits. The exact power of a
+ * thirty-four-digit coefficient to `n` has `34n` digits; below this the power is
+ * computed exactly and rounded once, above it — a base within a hair of one
+ * raised to an enormous exponent, the one way to get here without overflowing —
+ * with {@link GUARD_DIGITS} digits more than the format keeps.
+ */
+const EXACT_DIGIT_LIMIT = 200_000;
+/** Digits carried beyond the format's thirty-four when a power is not exact. */
+const GUARD_DIGITS = 50;
+/**
+ * The decimal logarithm of a finite, non-zero magnitude, as a double.
+ *
+ * Only ever used to rule a power out as an overflow or an underflow before it is
+ * computed, with a margin of whole powers of ten around the limits, so the
+ * double's own error never decides anything.
+ *
+ * @param parts Magnitude to measure.
+ * @returns log10 of the magnitude.
+ */
+const decimalLogarithm = (parts) => {
+    const digits = parts.coefficient.toString();
+    const leading = digits.slice(0, 15);
+    return (parts.exponent +
+        Math.log10(Number(leading)) +
+        (digits.length - leading.length));
+};
+/**
+ * A positive integer power computed with a bounded number of digits: every
+ * product is cut back to {@link GUARD_DIGITS} beyond the format, and a digit
+ * of 1 is kept below them when anything non-zero was cut.
+ *
+ * @param coefficient Coefficient of the base.
+ * @param exponent Exponent of the base.
+ * @param power Exponent it is raised to, positive.
+ * @returns The coefficient and exponent of the power, the last digit sticky.
+ */
+const guardedPower = (coefficient, exponent, power) => {
+    const kept = parts_1.PRECISION + GUARD_DIGITS;
+    let inexact = false;
+    const cut = (value, scale) => {
+        const excess = (0, parts_1.digitCount)(value) - kept;
+        if (excess <= 0)
+            return [value, scale];
+        const divisor = (0, parts_1.powerOfTen)(excess);
+        if (value % divisor !== 0n)
+            inexact = true;
+        return [value / divisor, scale + excess];
+    };
+    let result = [1n, 0];
+    let factor = [coefficient, exponent];
+    let remaining = power;
+    while (remaining > 0n) {
+        if (remaining % 2n === 1n) {
+            result = cut(result[0] * factor[0], result[1] + factor[1]);
+        }
+        remaining /= 2n;
+        if (remaining > 0n) {
+            factor = cut(factor[0] * factor[0], factor[1] * 2);
+        }
+    }
+    return inexact
+        ? { coefficient: result[0] * 10n + 1n, exponent: result[1] - 1 }
+        : { coefficient: result[0], exponent: result[1] };
+};
+/**
+ * Raises a value to an integer power, with the special cases of IEEE 754's
+ * `pown`: anything to the power zero is one, `NaN` included; a zero or an
+ * infinity to a negative power swaps with the other; and the sign is negative
+ * only for a negative base and an odd power.
+ *
+ * The finite case is computed exactly and rounded once, so the result is the
+ * correctly rounded one — up to {@link EXACT_DIGIT_LIMIT} digits of exact
+ * power, past which it carries {@link GUARD_DIGITS} guard digits instead. A
+ * result that plainly overflows or underflows is settled from its logarithm,
+ * without building a number only to discard it.
+ *
+ * @param base Value raised.
+ * @param power Integer exponent.
+ * @param mode Rounding mode.
+ * @returns The rounded power.
+ */
+const powerParts = (base, power, mode) => {
+    if (power === 0n)
+        return ONE;
+    if (base.kind === 'nan')
+        return parts_1.NOT_A_NUMBER;
+    const negative = base.negative && power % 2n !== 0n;
+    const positive = power > 0n;
+    if (base.kind === 'infinity') {
+        return positive ? (0, parts_1.infinity)(negative) : (0, parts_1.zero)(negative);
+    }
+    if ((0, parts_1.isZero)(base))
+        return positive ? (0, parts_1.zero)(negative) : (0, parts_1.infinity)(negative);
+    if (base.coefficient === 1n && base.exponent === 0) {
+        return { ...ONE, negative };
+    }
+    const magnitude = power < 0n ? -power : power;
+    const logarithm = decimalLogarithm(base) * Number(power);
+    // Two whole powers of ten of margin either side: the double estimate is off
+    // by far less, and anything inside the margin is computed.
+    if (logarithm > parts_1.MAXIMUM_ADJUSTED_EXPONENT + 2) {
+        return (0, round_1.finish)(negative, 1n, parts_1.MAXIMUM_ADJUSTED_EXPONENT + 1, mode);
+    }
+    if (logarithm < parts_1.MINIMUM_EXPONENT - 2) {
+        return (0, round_1.finish)(negative, 1n, parts_1.MINIMUM_EXPONENT - 2, mode);
+    }
+    const exact = magnitude * BigInt((0, parts_1.digitCount)(base.coefficient)) <=
+        BigInt(EXACT_DIGIT_LIMIT);
+    const raised = exact
+        ? {
+            coefficient: base.coefficient ** magnitude,
+            exponent: base.exponent * Number(magnitude),
+        }
+        : guardedPower(base.coefficient, base.exponent, magnitude);
+    if (positive) {
+        return (0, round_1.finish)(negative, raised.coefficient, raised.exponent, mode);
+    }
+    return (0, exports.divideParts)(ONE, {
+        kind: 'finite',
+        negative,
+        coefficient: raised.coefficient,
+        exponent: raised.exponent,
+    }, mode);
+};
+exports.powerParts = powerParts;
+/**
+ * Rounds a value to a number of places after the point.
+ *
+ * @param parts Value to round.
+ * @param places Places after the point; negative to round to tens, hundreds…
+ * @param mode Rounding mode.
+ * @returns The rounded value.
+ */
+const roundParts = (parts, places, mode) => {
+    if (parts.kind !== 'finite' || (0, parts_1.isZero)(parts))
+        return parts;
+    if (parts.exponent >= -places)
+        return parts;
+    const coefficient = (0, round_1.discardDigits)(parts.coefficient, -places - parts.exponent, mode, parts.negative);
+    return (0, round_1.finish)(parts.negative, coefficient, -places, mode);
+};
+exports.roundParts = roundParts;

package/dist/decimal/format.d.ts

@@ -0,0 +1,55 @@
+import type { RoundingMode } from '../roundingMode/index.js';
+import { type DecimalParts } from './parts';
+/**
+ * Refuses a digit count outside what the `Number` methods accept.
+ *
+ * @param operation Method being called.
+ * @param digits Count it was handed.
+ * @param minimum Smallest count accepted.
+ * @returns The count.
+ * @throws {RangeError} When the count is not an integer in range.
+ */
+export declare const requireDigits: (operation: string, digits: number, minimum: number) => number;
+/**
+ * The shortest text that reads back as the same value.
+ *
+ * Plain notation from 10^-6 up to 10^21 and exponential outside it, the points
+ * where `Number.prototype.toString` switches. A zero keeps its sign, so `-0`
+ * prints as `-0` — a decimal can round to it, and it would otherwise print as a
+ * value it is not.
+ *
+ * @param parts Parts to print.
+ * @returns The text.
+ */
+export declare const formatDecimal: (parts: DecimalParts) => string;
+/**
+ * The value with a fixed number of digits after the point, in plain notation
+ * whatever its magnitude.
+ *
+ * @param parts Parts to print.
+ * @param fractionDigits Digits after the point.
+ * @param mode Rounding mode.
+ * @returns The text.
+ */
+export declare const formatFixed: (parts: DecimalParts, fractionDigits: number, mode: RoundingMode) => string;
+/**
+ * The value with a number of significant digits, in plain notation unless the
+ * exponent is below -6 or at least the precision — the rule of
+ * `Number.prototype.toPrecision`.
+ *
+ * @param parts Parts to print.
+ * @param precision Significant digits.
+ * @param mode Rounding mode.
+ * @returns The text.
+ */
+export declare const formatPrecision: (parts: DecimalParts, precision: number, mode: RoundingMode) => string;
+/**
+ * The value in exponential notation, with a number of digits after the point,
+ * or with as many as it takes when none is given.
+ *
+ * @param parts Parts to print.
+ * @param fractionDigits Digits after the point, or `undefined` for all of them.
+ * @param mode Rounding mode.
+ * @returns The text.
+ */
+export declare const formatExponential: (parts: DecimalParts, fractionDigits: number | undefined, mode: RoundingMode) => string;

package/dist/decimal/format.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatExponential = exports.formatPrecision = exports.formatFixed = exports.formatDecimal = exports.requireDigits = void 0;
+const parts_1 = require("./parts");
+const round_1 = require("./round");
+/**
+ * The textual forms of a decimal, each following the method of `Number` it is
+ * named after — the same switch points between plain and exponential notation,
+ * the same argument ranges — so a reader who knows one knows the other.
+ */
+/** Largest digit count `toFixed`, `toPrecision` and `toExponential` accept. */
+const MAXIMUM_DIGITS = 100;
+/**
+ * Refuses a digit count outside what the `Number` methods accept.
+ *
+ * @param operation Method being called.
+ * @param digits Count it was handed.
+ * @param minimum Smallest count accepted.
+ * @returns The count.
+ * @throws {RangeError} When the count is not an integer in range.
+ */
+const requireDigits = (operation, digits, minimum) => {
+    if (!Number.isInteger(digits) ||
+        digits < minimum ||
+        digits > MAXIMUM_DIGITS) {
+        throw new RangeError(`Decimal.${operation}: expected an integer from ${minimum} to ${MAXIMUM_DIGITS}, received ${digits}.`);
+    }
+    return digits;
+};
+exports.requireDigits = requireDigits;
+/**
+ * The text of a value that is not finite, or `null` for one that is.
+ *
+ * @param parts Parts to print.
+ * @returns `'NaN'`, `'Infinity'`, `'-Infinity'` or `null`.
+ */
+const specialText = (parts) => {
+    if (parts.kind === 'nan')
+        return 'NaN';
+    if (parts.kind === 'infinity') {
+        return parts.negative ? '-Infinity' : 'Infinity';
+    }
+    return null;
+};
+/**
+ * Places a decimal point in a string of digits.
+ *
+ * @param digits Digits of the value.
+ * @param exponent Power of ten the digits are scaled by.
+ * @returns The value in plain notation.
+ */
+const placePoint = (digits, exponent) => {
+    if (exponent >= 0)
+        return digits + '0'.repeat(exponent);
+    const point = digits.length + exponent;
+    return point > 0
+        ? `${digits.slice(0, point)}.${digits.slice(point)}`
+        : `0.${'0'.repeat(-point)}${digits}`;
+};
+/**
+ * Writes digits in exponential notation, as `Number` does: `1.25e+3`.
+ *
+ * @param digits Digits of the value, the first one non-zero unless all are.
+ * @param adjusted Exponent of the leading digit.
+ * @returns The value in exponential notation.
+ */
+const exponential = (digits, adjusted) => `${digits[0]}${digits.length > 1 ? `.${digits.slice(1)}` : ''}e${adjusted < 0 ? '-' : '+'}${Math.abs(adjusted)}`;
+/**
+ * The shortest text that reads back as the same value.
+ *
+ * Plain notation from 10^-6 up to 10^21 and exponential outside it, the points
+ * where `Number.prototype.toString` switches. A zero keeps its sign, so `-0`
+ * prints as `-0` — a decimal can round to it, and it would otherwise print as a
+ * value it is not.
+ *
+ * @param parts Parts to print.
+ * @returns The text.
+ */
+const formatDecimal = (parts) => {
+    const special = specialText(parts);
+    if (special !== null)
+        return special;
+    const sign = parts.negative ? '-' : '';
+    if ((0, parts_1.isZero)(parts))
+        return `${sign}0`;
+    const digits = parts.coefficient.toString();
+    const adjusted = (0, parts_1.adjustedExponent)(parts);
+    return adjusted >= 21 || adjusted < -6
+        ? sign + exponential(digits, adjusted)
+        : sign + placePoint(digits, parts.exponent);
+};
+exports.formatDecimal = formatDecimal;
+/**
+ * The value with a fixed number of digits after the point, in plain notation
+ * whatever its magnitude.
+ *
+ * @param parts Parts to print.
+ * @param fractionDigits Digits after the point.
+ * @param mode Rounding mode.
+ * @returns The text.
+ */
+const formatFixed = (parts, fractionDigits, mode) => {
+    const special = specialText(parts);
+    if (special !== null)
+        return special;
+    const { negative, coefficient, exponent } = parts;
+    // The digits scaled so that the last one is the last one printed.
+    const scaled = exponent + fractionDigits >= 0
+        ? coefficient * (0, parts_1.powerOfTen)(exponent + fractionDigits)
+        : (0, round_1.discardDigits)(coefficient, -(exponent + fractionDigits), mode, negative);
+    const digits = scaled.toString().padStart(fractionDigits + 1, '0');
+    const point = digits.length - fractionDigits;
+    const text = fractionDigits === 0
+        ? digits
+        : `${digits.slice(0, point)}.${digits.slice(point)}`;
+    // A negative value that rounded to zero still prints its sign, as
+    // `(-0.001).toFixed(2)` does; `-0` itself does not, as `(-0).toFixed(2)`
+    // does not.
+    return negative && !(0, parts_1.isZero)(parts) ? `-${text}` : text;
+};
+exports.formatFixed = formatFixed;
+/**
+ * The digits of a value rounded to a number of significant digits, padded with
+ * zeros when it has fewer.
+ *
+ * @param parts Finite, non-zero parts.
+ * @param precision Significant digits wanted.
+ * @param mode Rounding mode.
+ * @returns The digits, and the exponent of the leading one.
+ */
+const significantDigits = (parts, precision, mode) => {
+    const { negative, coefficient, exponent } = parts;
+    const excess = (0, parts_1.digitCount)(coefficient) - precision;
+    if (excess <= 0) {
+        return {
+            digits: coefficient.toString() + '0'.repeat(-excess),
+            adjusted: (0, parts_1.adjustedExponent)(parts),
+        };
+    }
+    let rounded = (0, round_1.discardDigits)(coefficient, excess, mode, negative);
+    let scale = exponent + excess;
+    // 9.99 to two digits is 10, which is one digit too many and a power of ten.
+    if (rounded === (0, parts_1.powerOfTen)(precision)) {
+        rounded /= 10n;
+        scale += 1;
+    }
+    return { digits: rounded.toString(), adjusted: scale + precision - 1 };
+};
+/**
+ * The value with a number of significant digits, in plain notation unless the
+ * exponent is below -6 or at least the precision — the rule of
+ * `Number.prototype.toPrecision`.
+ *
+ * @param parts Parts to print.
+ * @param precision Significant digits.
+ * @param mode Rounding mode.
+ * @returns The text.
+ */
+const formatPrecision = (parts, precision, mode) => {
+    const special = specialText(parts);
+    if (special !== null)
+        return special;
+    const sign = parts.negative && !(0, parts_1.isZero)(parts) ? '-' : '';
+    if ((0, parts_1.isZero)(parts))
+        return placePoint('0'.repeat(precision), 1 - precision);
+    const { digits, adjusted } = significantDigits(parts, precision, mode);
+    return adjusted < -6 || adjusted >= precision
+        ? sign + exponential(digits, adjusted)
+        : sign + placePoint(digits, adjusted - precision + 1);
+};
+exports.formatPrecision = formatPrecision;
+/**
+ * The value in exponential notation, with a number of digits after the point,
+ * or with as many as it takes when none is given.
+ *
+ * @param parts Parts to print.
+ * @param fractionDigits Digits after the point, or `undefined` for all of them.
+ * @param mode Rounding mode.
+ * @returns The text.
+ */
+const formatExponential = (parts, fractionDigits, mode) => {
+    const special = specialText(parts);
+    if (special !== null)
+        return special;
+    const sign = parts.negative && !(0, parts_1.isZero)(parts) ? '-' : '';
+    if ((0, parts_1.isZero)(parts)) {
+        return exponential('0'.repeat((fractionDigits ?? 0) + 1), 0);
+    }
+    const precision = fractionDigits === undefined
+        ? (0, parts_1.digitCount)(parts.coefficient)
+        : fractionDigits + 1;
+    const { digits, adjusted } = significantDigits(parts, precision, mode);
+    return sign + exponential(digits, adjusted);
+};
+exports.formatExponential = formatExponential;