@typeonce/ritmo-math 0.8.0 → 0.10.0

package/dist/internal/fdlibm.js

@@ -0,0 +1,1291 @@
+/**
+ * Pure-JavaScript ports of FreeBSD msun / musl libm (originally Sun fdlibm),
+ * built only from `+ - * /`, `Math.sqrt`, and bit access. ECMAScript rounds
+ * each of those exactly, so every engine and CPU returns the same bits.
+ *
+ * Copyright (C) 1993-2004 by Sun Microsystems, Inc. All rights reserved.
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this software is freely
+ * granted, provided that this notice is preserved.
+ *
+ * musl libm is MIT licensed, Copyright (c) 2005-2020 Rich Felker, et al.
+ *
+ * Changes from the C sources: results follow ECMAScript where it differs from
+ * C (`pow(1, NaN)` and `pow(±1, ±Infinity)` are NaN), arguments of sin,
+ * cos, and tan beyond 2^20·π/2 are reduced exactly with BigInt instead of
+ * `__rem_pio2_large`, and `exp(1)` returns `Math.E`.
+ *
+ * @internal
+ */
+const scratch = new Float64Array(1);
+const words = new Uint32Array(scratch.buffer);
+const LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+const HI = LITTLE_ENDIAN ? 1 : 0;
+const LO = LITTLE_ENDIAN ? 0 : 1;
+/** The high 32 bits of `x`, as a signed integer (sign, exponent, top of the mantissa). */
+const highWord = (x) => {
+    scratch[0] = x;
+    return words[HI] | 0;
+};
+/** The low 32 bits of `x`, unsigned. */
+const lowWord = (x) => {
+    scratch[0] = x;
+    return words[LO];
+};
+const fromWords = (high, low) => {
+    words[HI] = high;
+    words[LO] = low;
+    return scratch[0];
+};
+/** `x` with its low 32 bits cleared. */
+const clearLow = (x) => {
+    scratch[0] = x;
+    words[LO] = 0;
+    return scratch[0];
+};
+const TWO_1023 = fromWords(0x7fe00000, 0);
+const TWO_M1022 = fromWords(0x00100000, 0);
+const TWO_53 = 9007199254740992;
+/** `x * 2^n`, rounded once. */
+const scalbn = (x, n) => {
+    let y = x;
+    let k = n;
+    if (k > 1023) {
+        y *= TWO_1023;
+        k -= 1023;
+        if (k > 1023) {
+            y *= TWO_1023;
+            k -= 1023;
+            if (k > 1023)
+                k = 1023;
+        }
+    }
+    else if (k < -1022) {
+        // Keep the final k below -53 to avoid double rounding into subnormals.
+        y *= TWO_M1022 * TWO_53;
+        k += 1022 - 53;
+        if (k < -1022) {
+            y *= TWO_M1022 * TWO_53;
+            k += 1022 - 53;
+            if (k < -1022)
+                k = -1022;
+        }
+    }
+    return y * fromWords((0x3ff + k) << 20, 0);
+};
+// ---------------------------------------------------------------------------
+// Argument reduction: x = n·(π/2) + (y0 + y1), |y0 + y1| <= π/4
+let reducedHigh = 0;
+let reducedLow = 0;
+const TO_INT = 1.5 / 2.220446049250313e-16;
+const PIO4 = 7.85398163397448278999e-01;
+const INVPIO2 = 6.36619772367581382433e-01;
+const PIO2_1 = 1.57079632673412561417e+00;
+const PIO2_1T = 6.07710050650619224932e-11;
+const PIO2_2 = 6.07710050630396597660e-11;
+const PIO2_2T = 2.02226624879595063154e-21;
+const PIO2_3 = 2.02226624871116645580e-21;
+const PIO2_3T = 8.47842766036889956997e-32;
+/** Sets `reducedHigh`/`reducedLow` and returns n (only n mod 4 is meaningful for huge x). */
+const remPio2 = (x) => {
+    const ix = highWord(x) & 0x7fffffff;
+    if (ix < 0x413921fb) {
+        // |x| < 2^20·π/2: Cody–Waite reduction with up to three rounds.
+        let fn = x * INVPIO2 + TO_INT - TO_INT;
+        let n = fn | 0;
+        let r = x - fn * PIO2_1;
+        let w = fn * PIO2_1T;
+        if (r - w < -PIO4) {
+            n--;
+            fn--;
+            r = x - fn * PIO2_1;
+            w = fn * PIO2_1T;
+        }
+        else if (r - w > PIO4) {
+            n++;
+            fn++;
+            r = x - fn * PIO2_1;
+            w = fn * PIO2_1T;
+        }
+        let y0 = r - w;
+        const ex = ix >> 20;
+        let ey = (highWord(y0) >> 20) & 0x7ff;
+        if (ex - ey > 16) {
+            let t = r;
+            w = fn * PIO2_2;
+            r = t - w;
+            w = fn * PIO2_2T - ((t - r) - w);
+            y0 = r - w;
+            ey = (highWord(y0) >> 20) & 0x7ff;
+            if (ex - ey > 49) {
+                t = r;
+                w = fn * PIO2_3;
+                r = t - w;
+                w = fn * PIO2_3T - ((t - r) - w);
+                y0 = r - w;
+            }
+        }
+        reducedHigh = y0;
+        reducedLow = (r - y0) - w;
+        return n;
+    }
+    if (ix >= 0x7ff00000) {
+        reducedHigh = x - x;
+        reducedLow = reducedHigh;
+        return 0;
+    }
+    return remPio2Large(x);
+};
+// Huge arguments: exact reduction with BigInt against 2/π to 1280 bits.
+const PI_BITS = 1400;
+let twoOverPi = 0n;
+let halfPi130 = 0n;
+/** arctan(1/k) · 2^bits, by its Taylor series in fixed point. */
+const arctanInverse = (k, bits) => {
+    const one = 1n << bits;
+    const k2 = k * k;
+    let power = one / k;
+    let sum = power;
+    for (let i = 1n; power !== 0n; i++) {
+        power /= k2;
+        const term = power / (2n * i + 1n);
+        sum = i % 2n === 1n ? sum - term : sum + term;
+    }
+    return sum;
+};
+const TWO_OVER_PI_BITS = 1280n;
+const initReduction = () => {
+    const bits = BigInt(PI_BITS);
+    // Machin: π = 16·atan(1/5) − 4·atan(1/239)
+    const pi = 16n * arctanInverse(5n, bits) - 4n * arctanInverse(239n, bits);
+    twoOverPi = (1n << (TWO_OVER_PI_BITS + 1n + bits)) / pi;
+    halfPi130 = pi >> (bits - 129n);
+};
+const remPio2Large = (x) => {
+    if (twoOverPi === 0n)
+        initReduction();
+    const negative = x < 0;
+    const ax = negative ? -x : x;
+    // ax = mantissa · 2^exponent, exactly (ax >= 2^20 here, so it is normal).
+    const exponent = ((highWord(ax) >> 20) & 0x7ff) - 1075;
+    const mantissa = BigInt(ax / fromWords((exponent + 1023) << 20, 0));
+    // ax · 2/π = product / 2^shift
+    const shift = TWO_OVER_PI_BITS - BigInt(exponent);
+    const product = mantissa * twoOverPi;
+    const unit = 1n << shift;
+    let n = Number((product >> shift) & 3n);
+    let fraction = product & (unit - 1n);
+    if (fraction >= unit >> 1n) {
+        fraction -= unit;
+        n = (n + 1) & 3;
+    }
+    // Keep 250 fraction bits, multiply by π/2 (130 bits): r = fraction·π/2 · 2^-380
+    const r = (fraction >> (shift - 250n)) * halfPi130;
+    const scale = fromWords((380 + 1023) << 20, 0);
+    const high = Number(r) / scale;
+    const low = Number(r - BigInt(high * scale)) / scale;
+    reducedHigh = negative ? -high : high;
+    reducedLow = negative ? -low : low;
+    return negative ? -n : n;
+};
+// ---------------------------------------------------------------------------
+// Kernels on [-π/4, π/4]
+const S1 = -1.66666666666666324348e-01;
+const S2 = 8.33333333332248946124e-03;
+const S3 = -1.98412698298579493134e-04;
+const S4 = 2.75573137070700676789e-06;
+const S5 = -2.50507602534068634195e-08;
+const S6 = 1.58969099521155010221e-10;
+const kernelSin = (x, y, hasTail) => {
+    const z = x * x;
+    const w = z * z;
+    const r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);
+    const v = z * x;
+    if (!hasTail)
+        return x + v * (S1 + z * r);
+    return x - ((z * (0.5 * y - v * r) - y) - v * S1);
+};
+const C1 = 4.16666666666666019037e-02;
+const C2 = -1.38888888888741095749e-03;
+const C3 = 2.48015872894767294178e-05;
+const C4 = -2.75573143513906633035e-07;
+const C5 = 2.08757232129817482790e-09;
+const C6 = -1.13596475577881948265e-11;
+const kernelCos = (x, y) => {
+    const z = x * x;
+    const w = z * z;
+    const r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));
+    const hz = 0.5 * z;
+    const v = 1.0 - hz;
+    return v + (((1.0 - v) - hz) + (z * r - x * y));
+};
+const T = [
+    3.33333333333334091986e-01,
+    1.33333333333201242699e-01,
+    5.39682539762260521377e-02,
+    2.18694882948595424599e-02,
+    8.86323982359930005737e-03,
+    3.59207910759131235356e-03,
+    1.45620945432529025516e-03,
+    5.88041240820264096874e-04,
+    2.46463134818469906812e-04,
+    7.81794442939557092300e-05,
+    7.14072491382608190305e-05,
+    -1.85586374855275456654e-05,
+    2.59073051863633712884e-05
+];
+const PIO4_LO = 3.06161699786838301793e-17;
+/** tan(x + y) when `odd` is false, -1/tan(x + y) when it is true. */
+const kernelTan = (xIn, yIn, odd) => {
+    let x = xIn;
+    let y = yIn;
+    const hx = highWord(x);
+    const big = (hx & 0x7fffffff) >= 0x3fe59428; // |x| >= 0.6744
+    const negative = hx < 0;
+    if (big) {
+        if (negative) {
+            x = -x;
+            y = -y;
+        }
+        x = (PIO4 - x) + (PIO4_LO - y);
+        y = 0.0;
+    }
+    const z = x * x;
+    let w = z * z;
+    let r = T[1] + w * (T[3] + w * (T[5] + w * (T[7] + w * (T[9] + w * T[11]))));
+    let v = z * (T[2] + w * (T[4] + w * (T[6] + w * (T[8] + w * (T[10] + w * T[12])))));
+    let s = z * x;
+    r = y + z * (s * (r + v) + y) + s * T[0];
+    w = x + r;
+    if (big) {
+        s = odd ? -1 : 1;
+        v = s - 2.0 * (x + (r - w * w / (w + s)));
+        return negative ? -v : v;
+    }
+    if (!odd)
+        return w;
+    // -1/(x + r) has up to 2 ulp error, so compute it accurately.
+    const w0 = clearLow(w);
+    v = r - (w0 - x);
+    const a = -1.0 / w;
+    const a0 = clearLow(a);
+    return a0 + a * (1.0 + a0 * w0 + a0 * v);
+};
+// ---------------------------------------------------------------------------
+// Trigonometric functions
+export const sin = (x) => {
+    const ix = highWord(x) & 0x7fffffff;
+    if (ix <= 0x3fe921fb) {
+        if (ix < 0x3e500000)
+            return x; // |x| < 2^-26
+        return kernelSin(x, 0, false);
+    }
+    if (ix >= 0x7ff00000)
+        return x - x;
+    const n = remPio2(x);
+    switch (n & 3) {
+        case 0:
+            return kernelSin(reducedHigh, reducedLow, true);
+        case 1:
+            return kernelCos(reducedHigh, reducedLow);
+        case 2:
+            return -kernelSin(reducedHigh, reducedLow, true);
+        default:
+            return -kernelCos(reducedHigh, reducedLow);
+    }
+};
+export const cos = (x) => {
+    const ix = highWord(x) & 0x7fffffff;
+    if (ix <= 0x3fe921fb) {
+        if (ix < 0x3e46a09e)
+            return 1.0; // |x| < 2^-27·√2
+        return kernelCos(x, 0);
+    }
+    if (ix >= 0x7ff00000)
+        return x - x;
+    const n = remPio2(x);
+    switch (n & 3) {
+        case 0:
+            return kernelCos(reducedHigh, reducedLow);
+        case 1:
+            return -kernelSin(reducedHigh, reducedLow, true);
+        case 2:
+            return -kernelCos(reducedHigh, reducedLow);
+        default:
+            return kernelSin(reducedHigh, reducedLow, true);
+    }
+};
+export const tan = (x) => {
+    const ix = highWord(x) & 0x7fffffff;
+    if (ix <= 0x3fe921fb) {
+        if (ix < 0x3e400000)
+            return x; // |x| < 2^-27
+        return kernelTan(x, 0.0, false);
+    }
+    if (ix >= 0x7ff00000)
+        return x - x;
+    const n = remPio2(x);
+    return kernelTan(reducedHigh, reducedLow, (n & 1) !== 0);
+};
+// ---------------------------------------------------------------------------
+// Inverse trigonometric functions
+const PIO2_HI = 1.57079632679489655800e+00;
+const PIO2_LO = 6.12323399573676603587e-17;
+const PS0 = 1.66666666666666657415e-01;
+const PS1 = -3.25565818622400915405e-01;
+const PS2 = 2.01212532134862925881e-01;
+const PS3 = -4.00555345006794114027e-02;
+const PS4 = 7.91534994289814532176e-04;
+const PS5 = 3.47933107596021167570e-05;
+const QS1 = -2.40339491173441421878e+00;
+const QS2 = 2.02094576023350569471e+00;
+const QS3 = -6.88283971605453293030e-01;
+const QS4 = 7.70381505559019352791e-02;
+const asinRatio = (z) => {
+    const p = z * (PS0 + z * (PS1 + z * (PS2 + z * (PS3 + z * (PS4 + z * PS5)))));
+    const q = 1.0 + z * (QS1 + z * (QS2 + z * (QS3 + z * QS4)));
+    return p / q;
+};
+export const asin = (x) => {
+    const hx = highWord(x);
+    const ix = hx & 0x7fffffff;
+    if (ix >= 0x3ff00000) {
+        // |x| >= 1 or NaN
+        if (((ix - 0x3ff00000) | lowWord(x)) === 0)
+            return x * PIO2_HI;
+        return 0 / (x - x);
+    }
+    if (ix < 0x3fe00000) {
+        // |x| < 0.5
+        if (ix < 0x3e500000 && ix >= 0x00100000)
+            return x;
+        return x + x * asinRatio(x * x);
+    }
+    // 0.5 <= |x| < 1
+    const z = (1 - Math.abs(x)) * 0.5;
+    const s = Math.sqrt(z);
+    const r = asinRatio(z);
+    let result;
+    if (ix >= 0x3fef3333) {
+        // |x| > 0.975
+        result = PIO2_HI - (2 * (s + s * r) - PIO2_LO);
+    }
+    else {
+        const f = clearLow(s);
+        const c = (z - f * f) / (s + f);
+        result = 0.5 * PIO2_HI - (2 * s * r - (PIO2_LO - 2 * c) - (0.5 * PIO2_HI - 2 * f));
+    }
+    return hx < 0 ? -result : result;
+};
+export const acos = (x) => {
+    const hx = highWord(x);
+    const ix = hx & 0x7fffffff;
+    if (ix >= 0x3ff00000) {
+        // |x| >= 1 or NaN
+        if (((ix - 0x3ff00000) | lowWord(x)) === 0)
+            return hx < 0 ? 2 * PIO2_HI : 0;
+        return 0 / (x - x);
+    }
+    if (ix < 0x3fe00000) {
+        // |x| < 0.5
+        if (ix <= 0x3c600000)
+            return PIO2_HI; // |x| < 2^-57
+        return PIO2_HI - (x - (PIO2_LO - x * asinRatio(x * x)));
+    }
+    if (hx < 0) {
+        // x < -0.5
+        const z = (1.0 + x) * 0.5;
+        const s = Math.sqrt(z);
+        const w = asinRatio(z) * s - PIO2_LO;
+        return 2 * (PIO2_HI - (s + w));
+    }
+    // x > 0.5
+    const z = (1.0 - x) * 0.5;
+    const s = Math.sqrt(z);
+    const df = clearLow(s);
+    const c = (z - df * df) / (s + df);
+    const w = asinRatio(z) * s + c;
+    return 2 * (df + w);
+};
+const ATAN_HI = [
+    4.63647609000806093515e-01,
+    7.85398163397448278999e-01,
+    9.82793723247329054082e-01,
+    1.57079632679489655800e+00
+];
+const ATAN_LO = [
+    2.26987774529616870924e-17,
+    3.06161699786838301793e-17,
+    1.39033110312309984516e-17,
+    6.12323399573676603587e-17
+];
+const AT = [
+    3.33333333333329318027e-01,
+    -1.99999999998764832476e-01,
+    1.42857142725034663711e-01,
+    -1.11111104054623557880e-01,
+    9.09088713343650656196e-02,
+    -7.69187620504482999495e-02,
+    6.66107313738753120669e-02,
+    -5.83357013379057348645e-02,
+    4.97687799461593236017e-02,
+    -3.65315727442169155270e-02,
+    1.62858201153657823623e-02
+];
+export const atan = (xIn) => {
+    let x = xIn;
+    const hx = highWord(x);
+    const negative = hx < 0;
+    const ix = hx & 0x7fffffff;
+    if (ix >= 0x44100000) {
+        // |x| >= 2^66 or NaN
+        if (x !== x)
+            return x;
+        return negative ? -ATAN_HI[3] : ATAN_HI[3];
+    }
+    let id;
+    if (ix < 0x3fdc0000) {
+        // |x| < 0.4375
+        if (ix < 0x3e400000)
+            return x; // |x| < 2^-27
+        id = -1;
+    }
+    else {
+        x = Math.abs(x);
+        if (ix < 0x3ff30000) {
+            // |x| < 1.1875
+            if (ix < 0x3fe60000) {
+                // 7/16 <= |x| < 11/16
+                id = 0;
+                x = (2.0 * x - 1.0) / (2.0 + x);
+            }
+            else {
+                // 11/16 <= |x| < 19/16
+                id = 1;
+                x = (x - 1.0) / (x + 1.0);
+            }
+        }
+        else if (ix < 0x40038000) {
+            // |x| < 2.4375
+            id = 2;
+            x = (x - 1.5) / (1.0 + 1.5 * x);
+        }
+        else {
+            // 2.4375 <= |x| < 2^66
+            id = 3;
+            x = -1.0 / x;
+        }
+    }
+    const z = x * x;
+    const w = z * z;
+    const s1 = z * (AT[0] + w * (AT[2] + w * (AT[4] + w * (AT[6] + w * (AT[8] + w * AT[10])))));
+    const s2 = w * (AT[1] + w * (AT[3] + w * (AT[5] + w * (AT[7] + w * AT[9]))));
+    if (id < 0)
+        return x - x * (s1 + s2);
+    const result = ATAN_HI[id] - ((x * (s1 + s2) - ATAN_LO[id]) - x);
+    return negative ? -result : result;
+};
+const PI = 3.1415926535897931160e+00;
+const PI_LO = 1.2246467991473531772e-16;
+export const atan2 = (y, x) => {
+    if (x !== x || y !== y)
+        return x + y;
+    const hx = highWord(x);
+    const lx = lowWord(x);
+    const hy = highWord(y);
+    const ly = lowWord(y);
+    if (((hx - 0x3ff00000) | lx) === 0)
+        return atan(y); // x = 1
+    const m = ((hy >>> 31) & 1) | ((hx >>> 30) & 2); // 2·sign(x) + sign(y)
+    const ix = hx & 0x7fffffff;
+    const iy = hy & 0x7fffffff;
+    if ((iy | ly) === 0) {
+        // y = ±0
+        switch (m) {
+            case 0:
+            case 1:
+                return y;
+            case 2:
+                return PI;
+            default:
+                return -PI;
+        }
+    }
+    if ((ix | lx) === 0)
+        return m & 1 ? -PI / 2 : PI / 2; // x = ±0
+    if (ix === 0x7ff00000) {
+        // x = ±Infinity
+        if (iy === 0x7ff00000) {
+            switch (m) {
+                case 0:
+                    return PI / 4;
+                case 1:
+                    return -PI / 4;
+                case 2:
+                    return 3 * PI / 4;
+                default:
+                    return -3 * PI / 4;
+            }
+        }
+        switch (m) {
+            case 0:
+                return 0.0;
+            case 1:
+                return -0.0;
+            case 2:
+                return PI;
+            default:
+                return -PI;
+        }
+    }
+    // |y/x| > 2^64
+    if (ix + (64 << 20) < iy || iy === 0x7ff00000)
+        return m & 1 ? -PI / 2 : PI / 2;
+    // atan(|y/x|) without spurious underflow
+    const z = (m & 2) !== 0 && iy + (64 << 20) < ix ? 0 : atan(Math.abs(y / x));
+    switch (m) {
+        case 0:
+            return z;
+        case 1:
+            return -z;
+        case 2:
+            return PI - (z - PI_LO);
+        default:
+            return (z - PI_LO) - PI;
+    }
+};
+// ---------------------------------------------------------------------------
+// Exponential functions
+const LN2_HI = 6.93147180369123816490e-01;
+const LN2_LO = 1.90821492927058770002e-10;
+const INV_LN2 = 1.44269504088896338700e+00;
+const P1 = 1.66666666666666019037e-01;
+const P2 = -2.77777777770155933842e-03;
+const P3 = 6.61375632143793436117e-05;
+const P4 = -1.65339022054652515390e-06;
+const P5 = 4.13813679705723846039e-08;
+export const exp = (xIn) => {
+    let x = xIn;
+    const hx = highWord(x);
+    const negative = hx < 0;
+    const ix = hx & 0x7fffffff;
+    if (ix >= 0x4086232b) {
+        // |x| >= 708.39 or NaN
+        if (x !== x)
+            return x;
+        if (x > 709.782712893383973096)
+            return x * TWO_1023; // overflow
+        if (x < -745.13321910194110842)
+            return 0; // underflow
+    }
+    if (x === 1)
+        return 2.718281828459045; // Math.E: the reduction below lands 1 ulp above it
+    let hi = 0;
+    let lo = 0;
+    let k = 0;
+    if (ix > 0x3fd62e42) {
+        // |x| > 0.5·ln2
+        if (ix >= 0x3ff0a2b2) {
+            // |x| >= 1.5·ln2
+            k = (INV_LN2 * x + (negative ? -0.5 : 0.5)) | 0;
+        }
+        else {
+            k = negative ? -1 : 1;
+        }
+        hi = x - k * LN2_HI;
+        lo = k * LN2_LO;
+        x = hi - lo;
+    }
+    else if (ix > 0x3e300000) {
+        // |x| > 2^-28
+        hi = x;
+    }
+    else {
+        return 1 + x;
+    }
+    const xx = x * x;
+    const c = x - xx * (P1 + xx * (P2 + xx * (P3 + xx * (P4 + xx * P5))));
+    const y = 1 + (x * c / (2 - c) - lo + hi);
+    return k === 0 ? y : scalbn(y, k);
+};
+const O_THRESHOLD = 7.09782712893383973096e+02;
+const Q1 = -3.33333333333331316428e-02;
+const Q2 = 1.58730158725481460165e-03;
+const Q3 = -7.93650757867487942473e-05;
+const Q4 = 4.00821782732936239552e-06;
+const Q5 = -2.01099218183624371326e-07;
+/** e^x − 1, accurate near 0. */
+export const expm1 = (xIn) => {
+    let x = xIn;
+    const hx = highWord(x);
+    const negative = hx < 0;
+    const ix = hx & 0x7fffffff;
+    if (ix >= 0x4043687a) {
+        // |x| >= 56·ln2
+        if (x !== x)
+            return x;
+        if (negative)
+            return -1;
+        if (x > O_THRESHOLD)
+            return x * TWO_1023;
+    }
+    let k;
+    let c = 0;
+    if (ix > 0x3fd62e42) {
+        // |x| > 0.5·ln2
+        let hi;
+        let lo;
+        if (ix < 0x3ff0a2b2) {
+            // |x| < 1.5·ln2
+            if (!negative) {
+                hi = x - LN2_HI;
+                lo = LN2_LO;
+                k = 1;
+            }
+            else {
+                hi = x + LN2_HI;
+                lo = -LN2_LO;
+                k = -1;
+            }
+        }
+        else {
+            k = (INV_LN2 * x + (negative ? -0.5 : 0.5)) | 0;
+            hi = x - k * LN2_HI;
+            lo = k * LN2_LO;
+        }
+        x = hi - lo;
+        c = (hi - x) - lo;
+    }
+    else if (ix < 0x3c900000) {
+        return x; // |x| < 2^-54
+    }
+    else {
+        k = 0;
+    }
+    const hfx = 0.5 * x;
+    const hxs = x * hfx;
+    const r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));
+    const t = 3.0 - r1 * hfx;
+    let e = hxs * ((r1 - t) / (6.0 - x * t));
+    if (k === 0)
+        return x - (x * e - hxs);
+    e = x * (e - c) - c;
+    e -= hxs;
+    if (k === -1)
+        return 0.5 * (x - e) - 0.5;
+    if (k === 1) {
+        if (x < -0.25)
+            return -2.0 * (e - (x + 0.5));
+        return 1.0 + 2.0 * (x - e);
+    }
+    if (k < 0 || k > 56) {
+        const y = x - e + 1.0;
+        return (k === 1024 ? y * 2.0 * TWO_1023 : y * fromWords((0x3ff + k) << 20, 0)) - 1.0;
+    }
+    const twopk = fromWords((0x3ff + k) << 20, 0);
+    const twomk = fromWords((0x3ff - k) << 20, 0);
+    if (k < 20)
+        return (x - e + (1 - twomk)) * twopk;
+    return (x - (e + twomk) + 1) * twopk;
+};
+export const tanh = (xIn) => {
+    const negative = highWord(xIn) < 0;
+    const x = Math.abs(xIn);
+    const w = highWord(x);
+    let t;
+    if (w > 0x3fe193ea) {
+        // |x| > log(3)/2 or NaN
+        if (w > 0x40340000) {
+            t = 1 - 0 / x; // |x| > 20 or NaN
+        }
+        else {
+            t = expm1(2 * x);
+            t = 1 - 2 / (t + 2);
+        }
+    }
+    else if (w > 0x3fd058ae) {
+        // |x| > log(5/3)/2
+        t = expm1(2 * x);
+        t = t / (t + 2);
+    }
+    else if (w >= 0x00100000) {
+        t = expm1(-2 * x);
+        t = -t / (t + 2);
+    }
+    else {
+        t = x; // subnormal
+    }
+    return negative ? -t : t;
+};
+// ---------------------------------------------------------------------------
+// Power
+const BP = [1.0, 1.5];
+const DP_H = [0.0, 5.84962487220764160156e-01];
+const DP_L = [0.0, 1.35003920212974897128e-08];
+const HUGE = 1.0e300;
+const TINY = 1.0e-300;
+const L1 = 5.99999999999994648725e-01;
+const L2 = 4.28571428578550184252e-01;
+const L3 = 3.33333329818377432918e-01;
+const L4 = 2.72728123808534006489e-01;
+const L5 = 2.30660745775561754067e-01;
+const L6 = 2.06975017800338417784e-01;
+const LG2 = 6.93147180559945286227e-01;
+const LG2_H = 6.93147182464599609375e-01;
+const LG2_L = -1.90465429995776804525e-09;
+const OVT = 8.0085662595372944372e-17;
+const CP = 9.61796693925975554329e-01;
+const CP_H = 9.61796700954437255859e-01;
+const CP_L = -7.02846165095275826516e-09;
+const IVLN2 = 1.44269504088896338700e+00;
+const IVLN2_H = 1.44269502162933349609e+00;
+const IVLN2_L = 1.92596299112661746887e-08;
+export const pow = (x, y) => {
+    // ECMAScript Number::exponentiate, where it differs from C pow.
+    if (y !== y)
+        return NaN;
+    if (y === 0)
+        return 1;
+    if (x !== x)
+        return NaN;
+    const hx = highWord(x);
+    const lx = lowWord(x);
+    const hy = highWord(y);
+    const ly = lowWord(y);
+    let ix = hx & 0x7fffffff;
+    const iy = hy & 0x7fffffff;
+    if (iy === 0x7ff00000 && ly === 0 && ((ix - 0x3ff00000) | lx) === 0)
+        return NaN; // (±1) ** ±Infinity
+    if (hx === 0x3ff00000 && lx === 0)
+        return 1.0; // 1 ** y
+    // yisint: 0 when y is not an integer, 1 when odd, 2 when even (only when x < 0).
+    let yisint = 0;
+    if (hx < 0) {
+        if (iy >= 0x43400000) {
+            yisint = 2;
+        }
+        else if (iy >= 0x3ff00000) {
+            const e = (iy >> 20) - 0x3ff;
+            if (e > 20) {
+                const j = ly >>> (52 - e);
+                if (((j << (52 - e)) >>> 0) === ly)
+                    yisint = 2 - (j & 1);
+            }
+            else if (ly === 0) {
+                const j = iy >> (20 - e);
+                if ((j << (20 - e)) === iy)
+                    yisint = 2 - (j & 1);
+            }
+        }
+    }
+    if (ly === 0) {
+        if (iy === 0x7ff00000) {
+            // y = ±Infinity
+            if (ix >= 0x3ff00000)
+                return hy >= 0 ? y : 0.0; // (|x| > 1) ** ±Infinity
+            return hy >= 0 ? 0.0 : -y; // (|x| < 1) ** ±Infinity
+        }
+        if (iy === 0x3ff00000)
+            return hy >= 0 ? x : 1 / x; // y = ±1
+        if (hy === 0x40000000)
+            return x * x; // y = 2
+        if (hy === 0x3fe00000 && hx >= 0)
+            return Math.sqrt(x); // y = 0.5, x >= +0
+    }
+    let ax = Math.abs(x);
+    if (lx === 0 && (ix === 0x7ff00000 || ix === 0 || ix === 0x3ff00000)) {
+        // x = ±0, ±Infinity, ±1
+        let z = ax;
+        if (hy < 0)
+            z = 1.0 / z;
+        if (hx < 0) {
+            if (((ix - 0x3ff00000) | yisint) === 0) {
+                z = (z - z) / (z - z); // (-1) ** non-integer
+            }
+            else if (yisint === 1) {
+                z = -z;
+            }
+        }
+        return z;
+    }
+    let s = 1.0; // sign of the result
+    if (hx < 0) {
+        if (yisint === 0)
+            return (x - x) / (x - x); // (x < 0) ** non-integer
+        if (yisint === 1)
+            s = -1.0;
+    }
+    let t1;
+    let t2;
+    if (iy > 0x41e00000) {
+        // |y| > 2^31
+        if (iy > 0x43f00000) {
+            // |y| > 2^64: must overflow or underflow
+            if (ix <= 0x3fefffff)
+                return hy < 0 ? HUGE * HUGE : TINY * TINY;
+            if (ix >= 0x3ff00000)
+                return hy > 0 ? HUGE * HUGE : TINY * TINY;
+        }
+        // Overflow or underflow when x is not close to one.
+        if (ix < 0x3fefffff)
+            return hy < 0 ? s * HUGE * HUGE : s * TINY * TINY;
+        if (ix > 0x3ff00000)
+            return hy > 0 ? s * HUGE * HUGE : s * TINY * TINY;
+        // |1 - x| <= 2^-20: log(x) by x - x^2/2 + x^3/3 - x^4/4
+        const t = ax - 1.0;
+        const w = (t * t) * (0.5 - t * (0.3333333333333333333333 - t * 0.25));
+        const u = IVLN2_H * t;
+        const v = t * IVLN2_L - w * IVLN2;
+        t1 = clearLow(u + v);
+        t2 = v - (t1 - u);
+    }
+    else {
+        let n = 0;
+        if (ix < 0x00100000) {
+            // subnormal x
+            ax *= TWO_53;
+            n -= 53;
+            ix = highWord(ax);
+        }
+        n += (ix >> 20) - 0x3ff;
+        const j = ix & 0x000fffff;
+        ix = j | 0x3ff00000;
+        let k;
+        if (j <= 0x3988e) {
+            k = 0; // |x| < sqrt(3/2)
+        }
+        else if (j < 0xbb67a) {
+            k = 1; // |x| < sqrt(3)
+        }
+        else {
+            k = 0;
+            n += 1;
+            ix -= 0x00100000;
+        }
+        ax = fromWords(ix, lowWord(ax));
+        // ss = s_h + s_l = (x - 1)/(x + 1) or (x - 1.5)/(x + 1.5)
+        let u = ax - BP[k];
+        let v = 1.0 / (ax + BP[k]);
+        const ss = u * v;
+        const sH = clearLow(ss);
+        let tH = fromWords(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18), 0);
+        let tL = ax - (tH - BP[k]);
+        const sL = v * ((u - sH * tH) - sH * tL);
+        // log(ax)
+        let s2 = ss * ss;
+        let r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));
+        r += sL * (sH + ss);
+        s2 = sH * sH;
+        tH = clearLow(3.0 + s2 + r);
+        tL = r - ((tH - 3.0) - s2);
+        u = sH * tH;
+        v = sL * tH + tL * ss;
+        const pH = clearLow(u + v);
+        const pL = v - (pH - u);
+        const zH = CP_H * pH;
+        const zL = CP_L * pH + pL * CP + DP_L[k];
+        const t = n;
+        t1 = clearLow(((zH + zL) + DP_H[k]) + t);
+        t2 = zL - (((t1 - t) - DP_H[k]) - zH);
+    }
+    // (y1 + y2)·(t1 + t2)
+    const y1 = clearLow(y);
+    const pL = (y - y1) * t1 + y * t2;
+    let pH = y1 * t1;
+    let z = pL + pH;
+    let j = highWord(z);
+    const i = lowWord(z);
+    if (j >= 0x40900000) {
+        // z >= 1024
+        if (((j - 0x40900000) | i) !== 0)
+            return s * HUGE * HUGE;
+        if (pL + OVT > z - pH)
+            return s * HUGE * HUGE;
+    }
+    else if ((j & 0x7fffffff) >= 0x4090cc00) {
+        // z <= -1075
+        if (((j - (0xc090cc00 | 0)) | i) !== 0)
+            return s * TINY * TINY;
+        if (pL <= z - pH)
+            return s * TINY * TINY;
+    }
+    // 2^(pH + pL)
+    const abs = j & 0x7fffffff;
+    let k = (abs >> 20) - 0x3ff;
+    let n = 0;
+    if (abs > 0x3fe00000) {
+        // |z| > 0.5: n = [z + 0.5]
+        n = j + (0x00100000 >> (k + 1));
+        k = ((n & 0x7fffffff) >> 20) - 0x3ff;
+        const t = fromWords(n & ~(0x000fffff >> k), 0);
+        n = ((n & 0x000fffff) | 0x00100000) >> (20 - k);
+        if (j < 0)
+            n = -n;
+        pH -= t;
+    }
+    const t = clearLow(pL + pH);
+    const u = t * LG2_H;
+    const v = (pL - (t - pH)) * LG2 + t * LG2_L;
+    z = u + v;
+    const w = v - (z - u);
+    const tt = z * z;
+    const r1 = z - tt * (P1 + tt * (P2 + tt * (P3 + tt * (P4 + tt * P5))));
+    const r = (z * r1) / (r1 - 2.0) - (w + z * w);
+    z = 1.0 - (r - z);
+    j = highWord(z);
+    j += n << 20;
+    if ((j >> 20) <= 0) {
+        z = scalbn(z, n); // subnormal result
+    }
+    else {
+        z = fromWords(j, lowWord(z));
+    }
+    return s * z;
+};
+// ---------------------------------------------------------------------------
+// hypot
+const SPLIT = 134217729; // 2^27 + 1
+const TWO_700 = fromWords((700 + 1023) << 20, 0);
+const TWO_M700 = fromWords((-700 + 1023) << 20, 0);
+export const hypot = (xIn, yIn) => {
+    let hx = highWord(xIn) & 0x7fffffff;
+    let lx = lowWord(xIn);
+    let hy = highWord(yIn) & 0x7fffffff;
+    let ly = lowWord(yIn);
+    // Arrange |x| >= |y| by their bits, so NaN sorts above Infinity.
+    if (hx < hy || (hx === hy && lx < ly)) {
+        const th = hx;
+        const tl = lx;
+        hx = hy;
+        lx = ly;
+        hy = th;
+        ly = tl;
+    }
+    const ex = hx >>> 20;
+    const ey = hy >>> 20;
+    let x = fromWords(hx, lx);
+    let y = fromWords(hy, ly);
+    if (ey === 0x7ff)
+        return y; // hypot(Infinity, NaN) is Infinity
+    if (ex === 0x7ff || (hy | ly) === 0)
+        return x;
+    if (ex - ey > 64)
+        return x + y;
+    // Scale so xh·xh cannot overflow and xl·xl cannot underflow.
+    let z = 1;
+    if (ex > 0x3ff + 510) {
+        z = TWO_700;
+        x *= TWO_M700;
+        y *= TWO_M700;
+    }
+    else if (ey < 0x3ff - 450) {
+        z = TWO_M700;
+        x *= TWO_700;
+        y *= TWO_700;
+    }
+    // x² and y² as exact double-double sums (Dekker split).
+    let c = x * SPLIT;
+    const xh = x - c + c;
+    const xl = x - xh;
+    const hxx = x * x;
+    const lxx = xh * xh - hxx + 2 * xh * xl + xl * xl;
+    c = y * SPLIT;
+    const yh = y - c + c;
+    const yl = y - yh;
+    const hyy = y * y;
+    const lyy = yh * yh - hyy + 2 * yh * yl + yl * yl;
+    return z * Math.sqrt(lyy + lxx + hyy + hxx);
+};
+// ---------------------------------------------------------------------------
+// Logarithms
+const LOG1 = 6.666666666666735130e-01;
+const LOG2 = 3.999999999940941908e-01;
+const LOG3 = 2.857142874366239149e-01;
+const LOG4 = 2.222219843214978396e-01;
+const LOG5 = 1.818357216161805012e-01;
+const LOG6 = 1.531383769920937332e-01;
+const LOG7 = 1.479819860511658591e-01;
+const TWO_54 = fromWords(0x43500000, 0);
+let logK = 0;
+let logF = 0;
+/**
+ * Splits a positive finite non-unit `x` into `2^logK · (1 + logF)` with
+ * `1 + logF` in [√2/2, √2]. Returns a result for the special cases
+ * (±0, negative, NaN, Infinity), or `undefined` once split.
+ */
+const logSplit = (xIn) => {
+    let x = xIn;
+    let hx = highWord(x) >>> 0;
+    let k = 0;
+    if (hx < 0x00100000 || hx >>> 31 !== 0) {
+        if (x === 0)
+            return -1 / (x * x); // log(±0) = -Infinity
+        if (hx >>> 31 !== 0)
+            return (x - x) / 0.0; // log(negative) = NaN
+        k -= 54; // subnormal: scale up
+        x *= TWO_54;
+        hx = highWord(x) >>> 0;
+    }
+    else if (hx >= 0x7ff00000) {
+        return x; // Infinity or NaN
+    }
+    else if (hx === 0x3ff00000 && lowWord(x) === 0) {
+        return 0; // log(1) = +0
+    }
+    hx += 0x3ff00000 - 0x3fe6a09e;
+    k += (hx >>> 20) - 0x3ff;
+    hx = (hx & 0x000fffff) + 0x3fe6a09e;
+    logK = k;
+    logF = fromWords(hx, lowWord(x)) - 1.0;
+    return undefined;
+};
+/** s·(hfsq + R) of the log kernel on f = logF. */
+const logKernel = (f, hfsq) => {
+    const s = f / (2.0 + f);
+    const z = s * s;
+    const w = z * z;
+    const t1 = w * (LOG2 + w * (LOG4 + w * LOG6));
+    const t2 = z * (LOG1 + w * (LOG3 + w * (LOG5 + w * LOG7)));
+    return s * (hfsq + t2 + t1);
+};
+export const log = (x) => {
+    const special = logSplit(x);
+    if (special !== undefined)
+        return special;
+    const f = logF;
+    const hfsq = 0.5 * f * f;
+    const dk = logK;
+    return logKernel(f, hfsq) + dk * LN2_LO - hfsq + f + dk * LN2_HI;
+};
+const IVLN2HI = 1.44269504072144627571e+00;
+const IVLN2LO = 1.67517131648865118353e-10;
+export const log2 = (x) => {
+    const special = logSplit(x);
+    if (special !== undefined)
+        return special;
+    const f = logF;
+    const hfsq = 0.5 * f * f;
+    const hi = clearLow(f - hfsq);
+    const lo = f - hi - hfsq + logKernel(f, hfsq);
+    let valHi = hi * IVLN2HI;
+    let valLo = (lo + hi) * IVLN2LO + lo * IVLN2HI;
+    const y = logK;
+    const w = y + valHi;
+    valLo += (y - w) + valHi;
+    valHi = w;
+    return valLo + valHi;
+};
+const IVLN10HI = 4.34294481878168880939e-01;
+const IVLN10LO = 2.50829467116452752298e-11;
+const LOG10_2HI = 3.01029995663611771306e-01;
+const LOG10_2LO = 3.69423907715893078616e-13;
+export const log10 = (x) => {
+    const special = logSplit(x);
+    if (special !== undefined)
+        return special;
+    const f = logF;
+    const hfsq = 0.5 * f * f;
+    const hi = clearLow(f - hfsq);
+    const lo = f - hi - hfsq + logKernel(f, hfsq);
+    let valHi = hi * IVLN10HI;
+    const dk = logK;
+    const y = dk * LOG10_2HI;
+    let valLo = dk * LOG10_2LO + (lo + hi) * IVLN10LO + lo * IVLN10HI;
+    const w = y + valHi;
+    valLo += (y - w) + valHi;
+    valHi = w;
+    return valLo + valHi;
+};
+export const log1p = (x) => {
+    const hx = highWord(x) >>> 0;
+    let k = 1;
+    let c = 0;
+    let f = 0;
+    if (hx < 0x3fda827a || hx >>> 31 !== 0) {
+        // 1 + x < √2
+        if (hx >= 0xbff00000) {
+            // x <= -1
+            if (x === -1)
+                return x / 0.0; // -Infinity
+            return (x - x) / 0.0; // NaN
+        }
+        if (((hx << 1) >>> 0) < 0x79400000)
+            return x; // |x| < 2^-53
+        if (hx <= 0xbfd2bec4) {
+            // √2/2 <= 1 + x < √2
+            k = 0;
+            f = x;
+        }
+    }
+    else if (hx >= 0x7ff00000) {
+        return x;
+    }
+    if (k !== 0) {
+        const u = 1 + x;
+        let hu = highWord(u) >>> 0;
+        hu += 0x3ff00000 - 0x3fe6a09e;
+        k = (hu >>> 20) - 0x3ff;
+        // Correction term ~ log(1 + x) - log(u), avoiding underflow in c/u.
+        if (k < 54) {
+            c = k >= 2 ? 1 - (u - x) : x - (u - 1);
+            c /= u;
+        }
+        else {
+            c = 0;
+        }
+        hu = (hu & 0x000fffff) + 0x3fe6a09e;
+        f = fromWords(hu, lowWord(u)) - 1;
+    }
+    const hfsq = 0.5 * f * f;
+    const dk = k;
+    return logKernel(f, hfsq) + (dk * LN2_LO + c) - hfsq + f + dk * LN2_HI;
+};
+// ---------------------------------------------------------------------------
+// Hyperbolic functions
+const EXPO2_KLN2 = fromWords(0x40962066, 0x151add8b); // 2043·ln2 (musl __expo2)
+const EXPO2_SCALE = fromWords((0x3ff + 1021) << 20, 0); // 2^1021
+/** exp(x)/2·sign for x > log(DBL_MAX): exp(x - 2043·ln2)·2^2042, without overflowing early. */
+const expo2 = (x, sign) => exp(x - EXPO2_KLN2) * (sign * EXPO2_SCALE) * EXPO2_SCALE;
+export const sinh = (x) => {
+    const h = highWord(x) < 0 ? -0.5 : 0.5;
+    const absx = Math.abs(x);
+    const w = highWord(absx);
+    if (w < 0x40862e42) {
+        // |x| < log(DBL_MAX)
+        const t = expm1(absx);
+        if (w < 0x3ff00000) {
+            if (w < 0x3ff00000 - (26 << 20))
+                return x;
+            return h * (2 * t - t * t / (t + 1));
+        }
+        return h * (t + t / (t + 1));
+    }
+    return expo2(absx, 2 * h); // overflow or NaN
+};
+export const cosh = (xIn) => {
+    const x = Math.abs(xIn);
+    const w = highWord(x);
+    if (w < 0x3fe62e42) {
+        // |x| < log(2)
+        if (w < 0x3ff00000 - (26 << 20))
+            return 1;
+        const t = expm1(x);
+        return 1 + t * t / (2 * (1 + t));
+    }
+    if (w < 0x40862e42) {
+        // |x| < log(DBL_MAX)
+        const t = exp(x);
+        return 0.5 * (t + 1 / t);
+    }
+    return expo2(x, 1.0); // overflow or NaN
+};
+const LN2 = 6.93147180559945286227e-01;
+export const asinh = (x) => {
+    const hx = highWord(x);
+    const ix = hx & 0x7fffffff;
+    if (ix >= 0x7ff00000)
+        return x + x; // Infinity or NaN
+    if (ix < 0x3e300000)
+        return x; // |x| < 2^-28
+    let w;
+    if (ix > 0x41b00000) {
+        // |x| > 2^28
+        w = log(Math.abs(x)) + LN2;
+    }
+    else if (ix > 0x40000000) {
+        // 2 < |x| <= 2^28
+        const t = Math.abs(x);
+        w = log(2.0 * t + 1 / (Math.sqrt(x * x + 1) + t));
+    }
+    else {
+        // 2^-28 <= |x| <= 2
+        const t = x * x;
+        w = log1p(Math.abs(x) + t / (1 + Math.sqrt(1 + t)));
+    }
+    return hx > 0 ? w : -w;
+};
+export const acosh = (x) => {
+    const hx = highWord(x);
+    if (hx < 0x3ff00000)
+        return (x - x) / (x - x); // x < 1 or negative NaN
+    if (hx >= 0x41b00000) {
+        // x > 2^28
+        if (hx >= 0x7ff00000)
+            return x + x; // Infinity or NaN
+        return log(x) + LN2;
+    }
+    if (((hx - 0x3ff00000) | lowWord(x)) === 0)
+        return 0; // acosh(1) = 0
+    if (hx > 0x40000000) {
+        // 2 < x <= 2^28
+        const t = x * x;
+        return log(2.0 * x - 1 / (x + Math.sqrt(t - 1)));
+    }
+    // 1 < x <= 2
+    const t = x - 1;
+    return log1p(t + Math.sqrt(2.0 * t + t * t));
+};
+export const atanh = (xIn) => {
+    const hx = highWord(xIn);
+    const lx = lowWord(xIn);
+    const ix = hx & 0x7fffffff;
+    if ((ix | ((lx | ((-lx) >>> 0)) >>> 31)) > 0x3ff00000)
+        return (xIn - xIn) / (xIn - xIn); // |x| > 1 or NaN
+    if (ix === 0x3ff00000)
+        return xIn / 0; // ±Infinity
+    if (ix < 0x3e300000)
+        return xIn; // |x| < 2^-28
+    const x = Math.abs(xIn);
+    let t;
+    if (ix < 0x3fe00000) {
+        // |x| < 0.5
+        t = x + x;
+        t = 0.5 * log1p(t + t * x / (1 - x));
+    }
+    else {
+        t = 0.5 * log1p((x + x) / (1 - x));
+    }
+    return hx >= 0 ? t : -t;
+};
+// ---------------------------------------------------------------------------
+// Cube root
+const B1 = 715094163; // (1023 - 1023/3 - 0.03306235651)·2^20
+const B2 = 696219795; // (1023 - 1023/3 - 54/3 - 0.03306235651)·2^20
+const CP0 = 1.87595182427177009643;
+const CP1 = -1.88497979543377169875;
+const CP2 = 1.621429720105354466140;
+const CP3 = -0.758397934778766047437;
+const CP4 = 0.145996192886612446982;
+export const cbrt = (x) => {
+    const high = highWord(x);
+    const sign = high & 0x80000000;
+    let hx = high & 0x7fffffff;
+    if (hx >= 0x7ff00000)
+        return x + x; // Infinity or NaN
+    // Rough cube root to 5 bits.
+    if (hx < 0x00100000) {
+        // zero or subnormal
+        hx = highWord(x * TWO_54) & 0x7fffffff;
+        if (hx === 0)
+            return x; // ±0
+        hx = Math.floor(hx / 3) + B2;
+    }
+    else {
+        hx = Math.floor(hx / 3) + B1;
+    }
+    let t = fromWords((sign | hx) >>> 0, 0);
+    // New cube root to 23 bits.
+    let r = (t * t) * (t / x);
+    t = t * ((CP0 + r * (CP1 + r * CP2)) + ((r * r) * r) * (CP3 + r * CP4));
+    // Round t away from zero to 23 bits.
+    const sum = lowWord(t) + 0x80000000;
+    const carry = sum >= 0x100000000 ? 1 : 0;
+    t = fromWords(((highWord(t) >>> 0) + carry) >>> 0, (sum & 0xc0000000) >>> 0);
+    // One Newton step to 53 bits, error < 0.667 ulp.
+    const s = t * t;
+    r = x / s;
+    const w = t + t;
+    r = (r - t) / (w + r);
+    return t + t * r;
+};
+//# sourceMappingURL=fdlibm.js.map