{"version":3,"file":"jsbi-umd.js","sources":["../tsc-out/jsbi.mjs"],"sourcesContent":["// Copyright 2018 Google Inc.\n//\n// Licensed under the Apache License, Version 2.0 (the “License”);\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n// <https://apache.org/licenses/LICENSE-2.0>.\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an “AS IS” BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\nclass JSBI extends Array {\n    constructor(length, sign) {\n        super(length);\n        this.sign = sign;\n        // Explicitly set the prototype as per\n        // https://github.com/Microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n        Object.setPrototypeOf(this, JSBI.prototype);\n        if (length > JSBI.__kMaxLength) {\n            throw new RangeError('Maximum BigInt size exceeded');\n        }\n    }\n    static BigInt(arg) {\n        if (typeof arg === 'number') {\n            if (arg === 0)\n                return JSBI.__zero();\n            if (JSBI.__isOneDigitInt(arg)) {\n                if (arg < 0) {\n                    return JSBI.__oneDigit(-arg, true);\n                }\n                return JSBI.__oneDigit(arg, false);\n            }\n            if (!Number.isFinite(arg) || Math.floor(arg) !== arg) {\n                throw new RangeError('The number ' + arg + ' cannot be converted to ' +\n                    'BigInt because it is not an integer');\n            }\n            return JSBI.__fromDouble(arg);\n        }\n        else if (typeof arg === 'string') {\n            const result = JSBI.__fromString(arg);\n            if (result === null) {\n                throw new SyntaxError('Cannot convert ' + arg + ' to a BigInt');\n            }\n            return result;\n        }\n        else if (typeof arg === 'boolean') {\n            if (arg === true) {\n                return JSBI.__oneDigit(1, false);\n            }\n            return JSBI.__zero();\n        }\n        else if (typeof arg === 'object') {\n            if (arg.constructor === JSBI)\n                return arg;\n            const primitive = JSBI.__toPrimitive(arg);\n            return JSBI.BigInt(primitive);\n        }\n        throw new TypeError('Cannot convert ' + arg + ' to a BigInt');\n    }\n    toDebugString() {\n        const result = ['BigInt['];\n        for (const digit of this) {\n            result.push((digit ? (digit >>> 0).toString(16) : digit) + ', ');\n        }\n        result.push(']');\n        return result.join('');\n    }\n    toString(radix = 10) {\n        if (radix < 2 || radix > 36) {\n            throw new RangeError('toString() radix argument must be between 2 and 36');\n        }\n        if (this.length === 0)\n            return '0';\n        if ((radix & (radix - 1)) === 0) {\n            return JSBI.__toStringBasePowerOfTwo(this, radix);\n        }\n        return JSBI.__toStringGeneric(this, radix, false);\n    }\n    valueOf() {\n        throw new Error('Convert JSBI instances to native numbers using `toNumber`.');\n    }\n    // Equivalent of \"Number(my_bigint)\" in the native implementation.\n    // TODO: add more tests\n    static toNumber(x) {\n        const xLength = x.length;\n        if (xLength === 0)\n            return 0;\n        if (xLength === 1) {\n            const value = x.__unsignedDigit(0);\n            return x.sign ? -value : value;\n        }\n        const xMsd = x.__digit(xLength - 1);\n        const msdLeadingZeros = JSBI.__clz30(xMsd);\n        const xBitLength = xLength * 30 - msdLeadingZeros;\n        if (xBitLength > 1024)\n            return x.sign ? -Infinity : Infinity;\n        let exponent = xBitLength - 1;\n        let currentDigit = xMsd;\n        let digitIndex = xLength - 1;\n        const shift = msdLeadingZeros + 3;\n        let mantissaHigh = (shift === 32) ? 0 : currentDigit << shift;\n        mantissaHigh >>>= 12;\n        const mantissaHighBitsUnset = shift - 12;\n        let mantissaLow = (shift >= 12) ? 0 : (currentDigit << (20 + shift));\n        let mantissaLowBitsUnset = 20 + shift;\n        if (mantissaHighBitsUnset > 0 && digitIndex > 0) {\n            digitIndex--;\n            currentDigit = x.__digit(digitIndex);\n            mantissaHigh |= (currentDigit >>> (30 - mantissaHighBitsUnset));\n            mantissaLow = currentDigit << mantissaHighBitsUnset + 2;\n            mantissaLowBitsUnset = mantissaHighBitsUnset + 2;\n        }\n        while (mantissaLowBitsUnset > 0 && digitIndex > 0) {\n            digitIndex--;\n            currentDigit = x.__digit(digitIndex);\n            if (mantissaLowBitsUnset >= 30) {\n                mantissaLow |= (currentDigit << (mantissaLowBitsUnset - 30));\n            }\n            else {\n                mantissaLow |= (currentDigit >>> (30 - mantissaLowBitsUnset));\n            }\n            mantissaLowBitsUnset -= 30;\n        }\n        const rounding = JSBI.__decideRounding(x, mantissaLowBitsUnset, digitIndex, currentDigit);\n        if (rounding === 1 || (rounding === 0 && (mantissaLow & 1) === 1)) {\n            mantissaLow = (mantissaLow + 1) >>> 0;\n            if (mantissaLow === 0) {\n                // Incrementing mantissaLow overflowed.\n                mantissaHigh++;\n                if ((mantissaHigh >>> 20) !== 0) {\n                    // Incrementing mantissaHigh overflowed.\n                    mantissaHigh = 0;\n                    exponent++;\n                    if (exponent > 1023) {\n                        // Incrementing the exponent overflowed.\n                        return x.sign ? -Infinity : Infinity;\n                    }\n                }\n            }\n        }\n        const signBit = x.sign ? (1 << 31) : 0;\n        exponent = (exponent + 0x3FF) << 20;\n        JSBI.__kBitConversionInts[1] = signBit | exponent | mantissaHigh;\n        JSBI.__kBitConversionInts[0] = mantissaLow;\n        return JSBI.__kBitConversionDouble[0];\n    }\n    // Operations.\n    static unaryMinus(x) {\n        if (x.length === 0)\n            return x;\n        const result = x.__copy();\n        result.sign = !x.sign;\n        return result;\n    }\n    static bitwiseNot(x) {\n        if (x.sign) {\n            // ~(-x) == ~(~(x-1)) == x-1\n            return JSBI.__absoluteSubOne(x).__trim();\n        }\n        // ~x == -x-1 == -(x+1)\n        return JSBI.__absoluteAddOne(x, true);\n    }\n    static exponentiate(x, y) {\n        if (y.sign) {\n            throw new RangeError('Exponent must be positive');\n        }\n        if (y.length === 0) {\n            return JSBI.__oneDigit(1, false);\n        }\n        if (x.length === 0)\n            return x;\n        if (x.length === 1 && x.__digit(0) === 1) {\n            // (-1) ** even_number == 1.\n            if (x.sign && (y.__digit(0) & 1) === 0) {\n                return JSBI.unaryMinus(x);\n            }\n            // (-1) ** odd_number == -1, 1 ** anything == 1.\n            return x;\n        }\n        // For all bases >= 2, very large exponents would lead to unrepresentable\n        // results.\n        if (y.length > 1)\n            throw new RangeError('BigInt too big');\n        let expValue = y.__unsignedDigit(0);\n        if (expValue === 1)\n            return x;\n        if (expValue >= JSBI.__kMaxLengthBits) {\n            throw new RangeError('BigInt too big');\n        }\n        if (x.length === 1 && x.__digit(0) === 2) {\n            // Fast path for 2^n.\n            const neededDigits = 1 + ((expValue / 30) | 0);\n            const sign = x.sign && ((expValue & 1) !== 0);\n            const result = new JSBI(neededDigits, sign);\n            result.__initializeDigits();\n            // All bits are zero. Now set the n-th bit.\n            const msd = 1 << (expValue % 30);\n            result.__setDigit(neededDigits - 1, msd);\n            return result;\n        }\n        let result = null;\n        let runningSquare = x;\n        // This implicitly sets the result's sign correctly.\n        if ((expValue & 1) !== 0)\n            result = x;\n        expValue >>= 1;\n        for (; expValue !== 0; expValue >>= 1) {\n            runningSquare = JSBI.multiply(runningSquare, runningSquare);\n            if ((expValue & 1) !== 0) {\n                if (result === null) {\n                    result = runningSquare;\n                }\n                else {\n                    result = JSBI.multiply(result, runningSquare);\n                }\n            }\n        }\n        // TODO see if there's a way for tsc to infer this will always happen?\n        return result;\n    }\n    static multiply(x, y) {\n        if (x.length === 0)\n            return x;\n        if (y.length === 0)\n            return y;\n        let resultLength = x.length + y.length;\n        if (x.__clzmsd() + y.__clzmsd() >= 30) {\n            resultLength--;\n        }\n        const result = new JSBI(resultLength, x.sign !== y.sign);\n        result.__initializeDigits();\n        for (let i = 0; i < x.length; i++) {\n            JSBI.__multiplyAccumulate(y, x.__digit(i), result, i);\n        }\n        return result.__trim();\n    }\n    static divide(x, y) {\n        if (y.length === 0)\n            throw new RangeError('Division by zero');\n        if (JSBI.__absoluteCompare(x, y) < 0)\n            return JSBI.__zero();\n        const resultSign = x.sign !== y.sign;\n        const divisor = y.__unsignedDigit(0);\n        let quotient;\n        if (y.length === 1 && divisor <= 0x7FFF) {\n            if (divisor === 1) {\n                return resultSign === x.sign ? x : JSBI.unaryMinus(x);\n            }\n            quotient = JSBI.__absoluteDivSmall(x, divisor, null);\n        }\n        else {\n            quotient = JSBI.__absoluteDivLarge(x, y, true, false);\n        }\n        quotient.sign = resultSign;\n        return quotient.__trim();\n    }\n    static remainder(x, y) {\n        if (y.length === 0)\n            throw new RangeError('Division by zero');\n        if (JSBI.__absoluteCompare(x, y) < 0)\n            return x;\n        const divisor = y.__unsignedDigit(0);\n        if (y.length === 1 && divisor <= 0x7FFF) {\n            if (divisor === 1)\n                return JSBI.__zero();\n            const remainderDigit = JSBI.__absoluteModSmall(x, divisor);\n            if (remainderDigit === 0)\n                return JSBI.__zero();\n            return JSBI.__oneDigit(remainderDigit, x.sign);\n        }\n        const remainder = JSBI.__absoluteDivLarge(x, y, false, true);\n        remainder.sign = x.sign;\n        return remainder.__trim();\n    }\n    static add(x, y) {\n        const sign = x.sign;\n        if (sign === y.sign) {\n            // x + y == x + y\n            // -x + -y == -(x + y)\n            return JSBI.__absoluteAdd(x, y, sign);\n        }\n        // x + -y == x - y == -(y - x)\n        // -x + y == y - x == -(x - y)\n        if (JSBI.__absoluteCompare(x, y) >= 0) {\n            return JSBI.__absoluteSub(x, y, sign);\n        }\n        return JSBI.__absoluteSub(y, x, !sign);\n    }\n    static subtract(x, y) {\n        const sign = x.sign;\n        if (sign !== y.sign) {\n            // x - (-y) == x + y\n            // (-x) - y == -(x + y)\n            return JSBI.__absoluteAdd(x, y, sign);\n        }\n        // x - y == -(y - x)\n        // (-x) - (-y) == y - x == -(x - y)\n        if (JSBI.__absoluteCompare(x, y) >= 0) {\n            return JSBI.__absoluteSub(x, y, sign);\n        }\n        return JSBI.__absoluteSub(y, x, !sign);\n    }\n    static leftShift(x, y) {\n        if (y.length === 0 || x.length === 0)\n            return x;\n        if (y.sign)\n            return JSBI.__rightShiftByAbsolute(x, y);\n        return JSBI.__leftShiftByAbsolute(x, y);\n    }\n    static signedRightShift(x, y) {\n        if (y.length === 0 || x.length === 0)\n            return x;\n        if (y.sign)\n            return JSBI.__leftShiftByAbsolute(x, y);\n        return JSBI.__rightShiftByAbsolute(x, y);\n    }\n    static unsignedRightShift() {\n        throw new TypeError('BigInts have no unsigned right shift; use >> instead');\n    }\n    static lessThan(x, y) {\n        return JSBI.__compareToBigInt(x, y) < 0;\n    }\n    static lessThanOrEqual(x, y) {\n        return JSBI.__compareToBigInt(x, y) <= 0;\n    }\n    static greaterThan(x, y) {\n        return JSBI.__compareToBigInt(x, y) > 0;\n    }\n    static greaterThanOrEqual(x, y) {\n        return JSBI.__compareToBigInt(x, y) >= 0;\n    }\n    static equal(x, y) {\n        if (x.sign !== y.sign)\n            return false;\n        if (x.length !== y.length)\n            return false;\n        for (let i = 0; i < x.length; i++) {\n            if (x.__digit(i) !== y.__digit(i))\n                return false;\n        }\n        return true;\n    }\n    static notEqual(x, y) {\n        return !JSBI.equal(x, y);\n    }\n    static bitwiseAnd(x, y) {\n        if (!x.sign && !y.sign) {\n            return JSBI.__absoluteAnd(x, y).__trim();\n        }\n        else if (x.sign && y.sign) {\n            const resultLength = Math.max(x.length, y.length) + 1;\n            // (-x) & (-y) == ~(x-1) & ~(y-1) == ~((x-1) | (y-1))\n            // == -(((x-1) | (y-1)) + 1)\n            let result = JSBI.__absoluteSubOne(x, resultLength);\n            const y1 = JSBI.__absoluteSubOne(y);\n            result = JSBI.__absoluteOr(result, y1, result);\n            return JSBI.__absoluteAddOne(result, true, result).__trim();\n        }\n        // Assume that x is the positive BigInt.\n        if (x.sign) {\n            [x, y] = [y, x];\n        }\n        // x & (-y) == x & ~(y-1) == x &~ (y-1)\n        return JSBI.__absoluteAndNot(x, JSBI.__absoluteSubOne(y)).__trim();\n    }\n    static bitwiseXor(x, y) {\n        if (!x.sign && !y.sign) {\n            return JSBI.__absoluteXor(x, y).__trim();\n        }\n        else if (x.sign && y.sign) {\n            // (-x) ^ (-y) == ~(x-1) ^ ~(y-1) == (x-1) ^ (y-1)\n            const resultLength = Math.max(x.length, y.length);\n            const result = JSBI.__absoluteSubOne(x, resultLength);\n            const y1 = JSBI.__absoluteSubOne(y);\n            return JSBI.__absoluteXor(result, y1, result).__trim();\n        }\n        const resultLength = Math.max(x.length, y.length) + 1;\n        // Assume that x is the positive BigInt.\n        if (x.sign) {\n            [x, y] = [y, x];\n        }\n        // x ^ (-y) == x ^ ~(y-1) == ~(x ^ (y-1)) == -((x ^ (y-1)) + 1)\n        let result = JSBI.__absoluteSubOne(y, resultLength);\n        result = JSBI.__absoluteXor(result, x, result);\n        return JSBI.__absoluteAddOne(result, true, result).__trim();\n    }\n    static bitwiseOr(x, y) {\n        const resultLength = Math.max(x.length, y.length);\n        if (!x.sign && !y.sign) {\n            return JSBI.__absoluteOr(x, y).__trim();\n        }\n        else if (x.sign && y.sign) {\n            // (-x) | (-y) == ~(x-1) | ~(y-1) == ~((x-1) & (y-1))\n            // == -(((x-1) & (y-1)) + 1)\n            let result = JSBI.__absoluteSubOne(x, resultLength);\n            const y1 = JSBI.__absoluteSubOne(y);\n            result = JSBI.__absoluteAnd(result, y1, result);\n            return JSBI.__absoluteAddOne(result, true, result).__trim();\n        }\n        // Assume that x is the positive BigInt.\n        if (x.sign) {\n            [x, y] = [y, x];\n        }\n        // x | (-y) == x | ~(y-1) == ~((y-1) &~ x) == -(((y-1) ~& x) + 1)\n        let result = JSBI.__absoluteSubOne(y, resultLength);\n        result = JSBI.__absoluteAndNot(result, x, result);\n        return JSBI.__absoluteAddOne(result, true, result).__trim();\n    }\n    static asIntN(n, x) {\n        if (x.length === 0)\n            return x;\n        n = Math.floor(n);\n        if (n < 0) {\n            throw new RangeError('Invalid value: not (convertible to) a safe integer');\n        }\n        if (n === 0)\n            return JSBI.__zero();\n        // If {x} has less than {n} bits, return it directly.\n        if (n >= JSBI.__kMaxLengthBits)\n            return x;\n        const neededLength = ((n + 29) / 30) | 0;\n        if (x.length < neededLength)\n            return x;\n        const topDigit = x.__unsignedDigit(neededLength - 1);\n        const compareDigit = 1 << ((n - 1) % 30);\n        if (x.length === neededLength && topDigit < compareDigit)\n            return x;\n        // Otherwise truncate and simulate two's complement.\n        const hasBit = (topDigit & compareDigit) === compareDigit;\n        if (!hasBit)\n            return JSBI.__truncateToNBits(n, x);\n        if (!x.sign)\n            return JSBI.__truncateAndSubFromPowerOfTwo(n, x, true);\n        if ((topDigit & (compareDigit - 1)) === 0) {\n            for (let i = neededLength - 2; i >= 0; i--) {\n                if (x.__digit(i) !== 0) {\n                    return JSBI.__truncateAndSubFromPowerOfTwo(n, x, false);\n                }\n            }\n            if (x.length === neededLength && topDigit === compareDigit)\n                return x;\n            return JSBI.__truncateToNBits(n, x);\n        }\n        return JSBI.__truncateAndSubFromPowerOfTwo(n, x, false);\n    }\n    static asUintN(n, x) {\n        if (x.length === 0)\n            return x;\n        n = Math.floor(n);\n        if (n < 0) {\n            throw new RangeError('Invalid value: not (convertible to) a safe integer');\n        }\n        if (n === 0)\n            return JSBI.__zero();\n        // If {x} is negative, simulate two's complement representation.\n        if (x.sign) {\n            if (n > JSBI.__kMaxLengthBits) {\n                throw new RangeError('BigInt too big');\n            }\n            return JSBI.__truncateAndSubFromPowerOfTwo(n, x, false);\n        }\n        // If {x} is positive and has up to {n} bits, return it directly.\n        if (n >= JSBI.__kMaxLengthBits)\n            return x;\n        const neededLength = ((n + 29) / 30) | 0;\n        if (x.length < neededLength)\n            return x;\n        const bitsInTopDigit = n % 30;\n        if (x.length == neededLength) {\n            if (bitsInTopDigit === 0)\n                return x;\n            const topDigit = x.__digit(neededLength - 1);\n            if ((topDigit >>> bitsInTopDigit) === 0)\n                return x;\n        }\n        // Otherwise, truncate.\n        return JSBI.__truncateToNBits(n, x);\n    }\n    // Operators.\n    static ADD(x, y) {\n        x = JSBI.__toPrimitive(x);\n        y = JSBI.__toPrimitive(y);\n        if (typeof x === 'string') {\n            if (typeof y !== 'string')\n                y = y.toString();\n            return x + y;\n        }\n        if (typeof y === 'string') {\n            return x.toString() + y;\n        }\n        x = JSBI.__toNumeric(x);\n        y = JSBI.__toNumeric(y);\n        if (JSBI.__isBigInt(x) && JSBI.__isBigInt(y)) {\n            return JSBI.add(x, y);\n        }\n        if (typeof x === 'number' && typeof y === 'number') {\n            return x + y;\n        }\n        throw new TypeError('Cannot mix BigInt and other types, use explicit conversions');\n    }\n    static LT(x, y) {\n        return JSBI.__compare(x, y, 0);\n    }\n    static LE(x, y) {\n        return JSBI.__compare(x, y, 1);\n    }\n    static GT(x, y) {\n        return JSBI.__compare(x, y, 2);\n    }\n    static GE(x, y) {\n        return JSBI.__compare(x, y, 3);\n    }\n    static EQ(x, y) {\n        while (true) {\n            if (JSBI.__isBigInt(x)) {\n                if (JSBI.__isBigInt(y))\n                    return JSBI.equal(x, y);\n                return JSBI.EQ(y, x);\n            }\n            else if (typeof x === 'number') {\n                if (JSBI.__isBigInt(y))\n                    return JSBI.__equalToNumber(y, x);\n                if (typeof y !== 'object')\n                    return x == y;\n                y = JSBI.__toPrimitive(y);\n            }\n            else if (typeof x === 'string') {\n                if (JSBI.__isBigInt(y)) {\n                    x = JSBI.__fromString(x);\n                    if (x === null)\n                        return false;\n                    return JSBI.equal(x, y);\n                }\n                if (typeof y !== 'object')\n                    return x == y;\n                y = JSBI.__toPrimitive(y);\n            }\n            else if (typeof x === 'boolean') {\n                if (JSBI.__isBigInt(y))\n                    return JSBI.__equalToNumber(y, +x);\n                if (typeof y !== 'object')\n                    return x == y;\n                y = JSBI.__toPrimitive(y);\n            }\n            else if (typeof x === 'symbol') {\n                if (JSBI.__isBigInt(y))\n                    return false;\n                if (typeof y !== 'object')\n                    return x == y;\n                y = JSBI.__toPrimitive(y);\n            }\n            else if (typeof x === 'object') {\n                if (typeof y === 'object' && y.constructor !== JSBI)\n                    return x == y;\n                x = JSBI.__toPrimitive(x);\n            }\n            else {\n                return x == y;\n            }\n        }\n    }\n    static NE(x, y) {\n        return !JSBI.EQ(x, y);\n    }\n    // DataView-related functionality.\n    static DataViewGetBigInt64(dataview, byteOffset, littleEndian = false) {\n        return JSBI.asIntN(64, JSBI.DataViewGetBigUint64(dataview, byteOffset, littleEndian));\n    }\n    static DataViewGetBigUint64(dataview, byteOffset, littleEndian = false) {\n        const [h, l] = littleEndian ? [4, 0] : [0, 4];\n        const high = dataview.getUint32(byteOffset + h, littleEndian);\n        const low = dataview.getUint32(byteOffset + l, littleEndian);\n        const result = new JSBI(3, false);\n        result.__setDigit(0, low & 0x3FFFFFFF);\n        result.__setDigit(1, ((high & 0xFFFFFFF) << 2) | (low >>> 30));\n        result.__setDigit(2, high >>> 28);\n        return result.__trim();\n    }\n    static DataViewSetBigInt64(dataview, byteOffset, value, littleEndian = false) {\n        JSBI.DataViewSetBigUint64(dataview, byteOffset, value, littleEndian);\n    }\n    static DataViewSetBigUint64(dataview, byteOffset, value, littleEndian = false) {\n        value = JSBI.asUintN(64, value);\n        let high = 0;\n        let low = 0;\n        if (value.length > 0) {\n            low = value.__digit(0);\n            if (value.length > 1) {\n                const d1 = value.__digit(1);\n                low = low | d1 << 30;\n                high = d1 >>> 2;\n                if (value.length > 2) {\n                    high = high | (value.__digit(2) << 28);\n                }\n            }\n        }\n        const [h, l] = littleEndian ? [4, 0] : [0, 4];\n        dataview.setUint32(byteOffset + h, high, littleEndian);\n        dataview.setUint32(byteOffset + l, low, littleEndian);\n    }\n    // Helpers.\n    static __zero() {\n        return new JSBI(0, false);\n    }\n    static __oneDigit(value, sign) {\n        const result = new JSBI(1, sign);\n        result.__setDigit(0, value);\n        return result;\n    }\n    __copy() {\n        const result = new JSBI(this.length, this.sign);\n        for (let i = 0; i < this.length; i++) {\n            result[i] = this[i];\n        }\n        return result;\n    }\n    __trim() {\n        let newLength = this.length;\n        let last = this[newLength - 1];\n        while (last === 0) {\n            newLength--;\n            last = this[newLength - 1];\n            this.pop();\n        }\n        if (newLength === 0)\n            this.sign = false;\n        return this;\n    }\n    __initializeDigits() {\n        for (let i = 0; i < this.length; i++) {\n            this[i] = 0;\n        }\n    }\n    static __decideRounding(x, mantissaBitsUnset, digitIndex, currentDigit) {\n        if (mantissaBitsUnset > 0)\n            return -1;\n        let topUnconsumedBit;\n        if (mantissaBitsUnset < 0) {\n            topUnconsumedBit = -mantissaBitsUnset - 1;\n        }\n        else {\n            // {currentDigit} fit the mantissa exactly; look at the next digit.\n            if (digitIndex === 0)\n                return -1;\n            digitIndex--;\n            currentDigit = x.__digit(digitIndex);\n            topUnconsumedBit = 29;\n        }\n        // If the most significant remaining bit is 0, round down.\n        let mask = 1 << topUnconsumedBit;\n        if ((currentDigit & mask) === 0)\n            return -1;\n        // If any other remaining bit is set, round up.\n        mask -= 1;\n        if ((currentDigit & mask) !== 0)\n            return 1;\n        while (digitIndex > 0) {\n            digitIndex--;\n            if (x.__digit(digitIndex) !== 0)\n                return 1;\n        }\n        return 0;\n    }\n    static __fromDouble(value) {\n        const sign = value < 0;\n        JSBI.__kBitConversionDouble[0] = value;\n        const rawExponent = (JSBI.__kBitConversionInts[1] >>> 20) & 0x7FF;\n        const exponent = rawExponent - 0x3FF;\n        const digits = ((exponent / 30) | 0) + 1;\n        const result = new JSBI(digits, sign);\n        const kHiddenBit = 0x00100000;\n        let mantissaHigh = (JSBI.__kBitConversionInts[1] & 0xFFFFF) | kHiddenBit;\n        let mantissaLow = JSBI.__kBitConversionInts[0];\n        const kMantissaHighTopBit = 20;\n        // 0-indexed position of most significant bit in most significant digit.\n        const msdTopBit = exponent % 30;\n        // Number of unused bits in the mantissa. We'll keep them shifted to the\n        // left (i.e. most significant part).\n        let remainingMantissaBits = 0;\n        // Next digit under construction.\n        let digit;\n        // First, build the MSD by shifting the mantissa appropriately.\n        if (msdTopBit < kMantissaHighTopBit) {\n            const shift = kMantissaHighTopBit - msdTopBit;\n            remainingMantissaBits = shift + 32;\n            digit = mantissaHigh >>> shift;\n            mantissaHigh = (mantissaHigh << (32 - shift)) | (mantissaLow >>> shift);\n            mantissaLow = mantissaLow << (32 - shift);\n        }\n        else if (msdTopBit === kMantissaHighTopBit) {\n            remainingMantissaBits = 32;\n            digit = mantissaHigh;\n            mantissaHigh = mantissaLow;\n            mantissaLow = 0;\n        }\n        else {\n            const shift = msdTopBit - kMantissaHighTopBit;\n            remainingMantissaBits = 32 - shift;\n            digit = (mantissaHigh << shift) | (mantissaLow >>> (32 - shift));\n            mantissaHigh = mantissaLow << shift;\n            mantissaLow = 0;\n        }\n        result.__setDigit(digits - 1, digit);\n        // Then fill in the rest of the digits.\n        for (let digitIndex = digits - 2; digitIndex >= 0; digitIndex--) {\n            if (remainingMantissaBits > 0) {\n                remainingMantissaBits -= 30;\n                digit = mantissaHigh >>> 2;\n                mantissaHigh = (mantissaHigh << 30) | (mantissaLow >>> 2);\n                mantissaLow = (mantissaLow << 30);\n            }\n            else {\n                digit = 0;\n            }\n            result.__setDigit(digitIndex, digit);\n        }\n        return result.__trim();\n    }\n    static __isWhitespace(c) {\n        if (c <= 0x0D && c >= 0x09)\n            return true;\n        if (c <= 0x9F)\n            return c === 0x20;\n        if (c <= 0x01FFFF) {\n            return c === 0xA0 || c === 0x1680;\n        }\n        if (c <= 0x02FFFF) {\n            c &= 0x01FFFF;\n            return c <= 0x0A || c === 0x28 || c === 0x29 || c === 0x2F ||\n                c === 0x5F || c === 0x1000;\n        }\n        return c === 0xFEFF;\n    }\n    static __fromString(string, radix = 0) {\n        let sign = 0;\n        let leadingZero = false;\n        const length = string.length;\n        let cursor = 0;\n        if (cursor === length)\n            return JSBI.__zero();\n        let current = string.charCodeAt(cursor);\n        // Skip whitespace.\n        while (JSBI.__isWhitespace(current)) {\n            if (++cursor === length)\n                return JSBI.__zero();\n            current = string.charCodeAt(cursor);\n        }\n        // Detect radix.\n        if (current === 0x2B) { // '+'\n            if (++cursor === length)\n                return null;\n            current = string.charCodeAt(cursor);\n            sign = 1;\n        }\n        else if (current === 0x2D) { // '-'\n            if (++cursor === length)\n                return null;\n            current = string.charCodeAt(cursor);\n            sign = -1;\n        }\n        if (radix === 0) {\n            radix = 10;\n            if (current === 0x30) { // '0'\n                if (++cursor === length)\n                    return JSBI.__zero();\n                current = string.charCodeAt(cursor);\n                if (current === 0x58 || current === 0x78) { // 'X' or 'x'\n                    radix = 16;\n                    if (++cursor === length)\n                        return null;\n                    current = string.charCodeAt(cursor);\n                }\n                else if (current === 0x4F || current === 0x6F) { // 'O' or 'o'\n                    radix = 8;\n                    if (++cursor === length)\n                        return null;\n                    current = string.charCodeAt(cursor);\n                }\n                else if (current === 0x42 || current === 0x62) { // 'B' or 'b'\n                    radix = 2;\n                    if (++cursor === length)\n                        return null;\n                    current = string.charCodeAt(cursor);\n                }\n                else {\n                    leadingZero = true;\n                }\n            }\n        }\n        else if (radix === 16) {\n            if (current === 0x30) { // '0'\n                // Allow \"0x\" prefix.\n                if (++cursor === length)\n                    return JSBI.__zero();\n                current = string.charCodeAt(cursor);\n                if (current === 0x58 || current === 0x78) { // 'X' or 'x'\n                    if (++cursor === length)\n                        return null;\n                    current = string.charCodeAt(cursor);\n                }\n                else {\n                    leadingZero = true;\n                }\n            }\n        }\n        if (sign !== 0 && radix !== 10)\n            return null;\n        // Skip leading zeros.\n        while (current === 0x30) {\n            leadingZero = true;\n            if (++cursor === length)\n                return JSBI.__zero();\n            current = string.charCodeAt(cursor);\n        }\n        // Allocate result.\n        const chars = length - cursor;\n        let bitsPerChar = JSBI.__kMaxBitsPerChar[radix];\n        let roundup = JSBI.__kBitsPerCharTableMultiplier - 1;\n        if (chars > (1 << 30) / bitsPerChar)\n            return null;\n        const bitsMin = (bitsPerChar * chars + roundup) >>> JSBI.__kBitsPerCharTableShift;\n        const resultLength = ((bitsMin + 29) / 30) | 0;\n        const result = new JSBI(resultLength, false);\n        // Parse.\n        const limDigit = radix < 10 ? radix : 10;\n        const limAlpha = radix > 10 ? radix - 10 : 0;\n        if ((radix & (radix - 1)) === 0) {\n            // Power-of-two radix.\n            bitsPerChar >>= JSBI.__kBitsPerCharTableShift;\n            const parts = [];\n            const partsBits = [];\n            let done = false;\n            do {\n                let part = 0;\n                let bits = 0;\n                while (true) {\n                    let d;\n                    if (((current - 48) >>> 0) < limDigit) {\n                        d = current - 48;\n                    }\n                    else if ((((current | 32) - 97) >>> 0) < limAlpha) {\n                        d = (current | 32) - 87;\n                    }\n                    else {\n                        done = true;\n                        break;\n                    }\n                    bits += bitsPerChar;\n                    part = (part << bitsPerChar) | d;\n                    if (++cursor === length) {\n                        done = true;\n                        break;\n                    }\n                    current = string.charCodeAt(cursor);\n                    if (bits + bitsPerChar > 30)\n                        break;\n                }\n                parts.push(part);\n                partsBits.push(bits);\n            } while (!done);\n            JSBI.__fillFromParts(result, parts, partsBits);\n        }\n        else {\n            result.__initializeDigits();\n            let done = false;\n            let charsSoFar = 0;\n            do {\n                let part = 0;\n                let multiplier = 1;\n                while (true) {\n                    let d;\n                    if (((current - 48) >>> 0) < limDigit) {\n                        d = current - 48;\n                    }\n                    else if ((((current | 32) - 97) >>> 0) < limAlpha) {\n                        d = (current | 32) - 87;\n                    }\n                    else {\n                        done = true;\n                        break;\n                    }\n                    const m = multiplier * radix;\n                    if (m > 0x3FFFFFFF)\n                        break;\n                    multiplier = m;\n                    part = part * radix + d;\n                    charsSoFar++;\n                    if (++cursor === length) {\n                        done = true;\n                        break;\n                    }\n                    current = string.charCodeAt(cursor);\n                }\n                roundup = JSBI.__kBitsPerCharTableMultiplier * 30 - 1;\n                const digitsSoFar = (((bitsPerChar * charsSoFar + roundup) >>>\n                    JSBI.__kBitsPerCharTableShift) / 30) | 0;\n                result.__inplaceMultiplyAdd(multiplier, part, digitsSoFar);\n            } while (!done);\n        }\n        if (cursor !== length) {\n            if (!JSBI.__isWhitespace(current))\n                return null;\n            for (cursor++; cursor < length; cursor++) {\n                current = string.charCodeAt(cursor);\n                if (!JSBI.__isWhitespace(current))\n                    return null;\n            }\n        }\n        // Get result.\n        result.sign = (sign === -1);\n        return result.__trim();\n    }\n    static __fillFromParts(result, parts, partsBits) {\n        let digitIndex = 0;\n        let digit = 0;\n        let bitsInDigit = 0;\n        for (let i = parts.length - 1; i >= 0; i--) {\n            const part = parts[i];\n            const partBits = partsBits[i];\n            digit |= (part << bitsInDigit);\n            bitsInDigit += partBits;\n            if (bitsInDigit === 30) {\n                result.__setDigit(digitIndex++, digit);\n                bitsInDigit = 0;\n                digit = 0;\n            }\n            else if (bitsInDigit > 30) {\n                result.__setDigit(digitIndex++, digit & 0x3FFFFFFF);\n                bitsInDigit -= 30;\n                digit = part >>> (partBits - bitsInDigit);\n            }\n        }\n        if (digit !== 0) {\n            if (digitIndex >= result.length)\n                throw new Error('implementation bug');\n            result.__setDigit(digitIndex++, digit);\n        }\n        for (; digitIndex < result.length; digitIndex++) {\n            result.__setDigit(digitIndex, 0);\n        }\n    }\n    static __toStringBasePowerOfTwo(x, radix) {\n        const length = x.length;\n        let bits = radix - 1;\n        bits = ((bits >>> 1) & 0x55) + (bits & 0x55);\n        bits = ((bits >>> 2) & 0x33) + (bits & 0x33);\n        bits = ((bits >>> 4) & 0x0F) + (bits & 0x0F);\n        const bitsPerChar = bits;\n        const charMask = radix - 1;\n        const msd = x.__digit(length - 1);\n        const msdLeadingZeros = JSBI.__clz30(msd);\n        const bitLength = length * 30 - msdLeadingZeros;\n        let charsRequired = ((bitLength + bitsPerChar - 1) / bitsPerChar) | 0;\n        if (x.sign)\n            charsRequired++;\n        if (charsRequired > (1 << 28))\n            throw new Error('string too long');\n        const result = new Array(charsRequired);\n        let pos = charsRequired - 1;\n        let digit = 0;\n        let availableBits = 0;\n        for (let i = 0; i < length - 1; i++) {\n            const newDigit = x.__digit(i);\n            const current = (digit | (newDigit << availableBits)) & charMask;\n            result[pos--] = JSBI.__kConversionChars[current];\n            const consumedBits = bitsPerChar - availableBits;\n            digit = newDigit >>> consumedBits;\n            availableBits = 30 - consumedBits;\n            while (availableBits >= bitsPerChar) {\n                result[pos--] = JSBI.__kConversionChars[digit & charMask];\n                digit >>>= bitsPerChar;\n                availableBits -= bitsPerChar;\n            }\n        }\n        const current = (digit | (msd << availableBits)) & charMask;\n        result[pos--] = JSBI.__kConversionChars[current];\n        digit = msd >>> (bitsPerChar - availableBits);\n        while (digit !== 0) {\n            result[pos--] = JSBI.__kConversionChars[digit & charMask];\n            digit >>>= bitsPerChar;\n        }\n        if (x.sign)\n            result[pos--] = '-';\n        if (pos !== -1)\n            throw new Error('implementation bug');\n        return result.join('');\n    }\n    static __toStringGeneric(x, radix, isRecursiveCall) {\n        const length = x.length;\n        if (length === 0)\n            return '';\n        if (length === 1) {\n            let result = x.__unsignedDigit(0).toString(radix);\n            if (isRecursiveCall === false && x.sign) {\n                result = '-' + result;\n            }\n            return result;\n        }\n        const bitLength = length * 30 - JSBI.__clz30(x.__digit(length - 1));\n        const maxBitsPerChar = JSBI.__kMaxBitsPerChar[radix];\n        const minBitsPerChar = maxBitsPerChar - 1;\n        let charsRequired = bitLength * JSBI.__kBitsPerCharTableMultiplier;\n        charsRequired += minBitsPerChar - 1;\n        charsRequired = (charsRequired / minBitsPerChar) | 0;\n        const secondHalfChars = (charsRequired + 1) >> 1;\n        // Divide-and-conquer: split by a power of {radix} that's approximately\n        // the square root of {x}, then recurse.\n        const conqueror = JSBI.exponentiate(JSBI.__oneDigit(radix, false), JSBI.__oneDigit(secondHalfChars, false));\n        let quotient;\n        let secondHalf;\n        const divisor = conqueror.__unsignedDigit(0);\n        if (conqueror.length === 1 && divisor <= 0x7FFF) {\n            quotient = new JSBI(x.length, false);\n            quotient.__initializeDigits();\n            let remainder = 0;\n            for (let i = x.length * 2 - 1; i >= 0; i--) {\n                const input = (remainder << 15) | x.__halfDigit(i);\n                quotient.__setHalfDigit(i, (input / divisor) | 0);\n                remainder = (input % divisor) | 0;\n            }\n            secondHalf = remainder.toString(radix);\n        }\n        else {\n            const divisionResult = JSBI.__absoluteDivLarge(x, conqueror, true, true);\n            quotient = divisionResult.quotient;\n            const remainder = divisionResult.remainder.__trim();\n            secondHalf = JSBI.__toStringGeneric(remainder, radix, true);\n        }\n        quotient.__trim();\n        let firstHalf = JSBI.__toStringGeneric(quotient, radix, true);\n        while (secondHalf.length < secondHalfChars) {\n            secondHalf = '0' + secondHalf;\n        }\n        if (isRecursiveCall === false && x.sign) {\n            firstHalf = '-' + firstHalf;\n        }\n        return firstHalf + secondHalf;\n    }\n    static __unequalSign(leftNegative) {\n        return leftNegative ? -1 : 1;\n    }\n    static __absoluteGreater(bothNegative) {\n        return bothNegative ? -1 : 1;\n    }\n    static __absoluteLess(bothNegative) {\n        return bothNegative ? 1 : -1;\n    }\n    static __compareToBigInt(x, y) {\n        const xSign = x.sign;\n        if (xSign !== y.sign)\n            return JSBI.__unequalSign(xSign);\n        const result = JSBI.__absoluteCompare(x, y);\n        if (result > 0)\n            return JSBI.__absoluteGreater(xSign);\n        if (result < 0)\n            return JSBI.__absoluteLess(xSign);\n        return 0;\n    }\n    static __compareToNumber(x, y) {\n        if (JSBI.__isOneDigitInt(y)) {\n            const xSign = x.sign;\n            const ySign = (y < 0);\n            if (xSign !== ySign)\n                return JSBI.__unequalSign(xSign);\n            if (x.length === 0) {\n                if (ySign)\n                    throw new Error('implementation bug');\n                return y === 0 ? 0 : -1;\n            }\n            // Any multi-digit BigInt is bigger than an int32.\n            if (x.length > 1)\n                return JSBI.__absoluteGreater(xSign);\n            const yAbs = Math.abs(y);\n            const xDigit = x.__unsignedDigit(0);\n            if (xDigit > yAbs)\n                return JSBI.__absoluteGreater(xSign);\n            if (xDigit < yAbs)\n                return JSBI.__absoluteLess(xSign);\n            return 0;\n        }\n        return JSBI.__compareToDouble(x, y);\n    }\n    static __compareToDouble(x, y) {\n        if (y !== y)\n            return y; // NaN.\n        if (y === Infinity)\n            return -1;\n        if (y === -Infinity)\n            return 1;\n        const xSign = x.sign;\n        const ySign = (y < 0);\n        if (xSign !== ySign)\n            return JSBI.__unequalSign(xSign);\n        if (y === 0) {\n            throw new Error('implementation bug: should be handled elsewhere');\n        }\n        if (x.length === 0)\n            return -1;\n        JSBI.__kBitConversionDouble[0] = y;\n        const rawExponent = (JSBI.__kBitConversionInts[1] >>> 20) & 0x7FF;\n        if (rawExponent === 0x7FF) {\n            throw new Error('implementation bug: handled elsewhere');\n        }\n        const exponent = rawExponent - 0x3FF;\n        if (exponent < 0) {\n            // The absolute value of y is less than 1. Only 0n has an absolute\n            // value smaller than that, but we've already covered that case.\n            return JSBI.__absoluteGreater(xSign);\n        }\n        const xLength = x.length;\n        let xMsd = x.__digit(xLength - 1);\n        const msdLeadingZeros = JSBI.__clz30(xMsd);\n        const xBitLength = xLength * 30 - msdLeadingZeros;\n        const yBitLength = exponent + 1;\n        if (xBitLength < yBitLength)\n            return JSBI.__absoluteLess(xSign);\n        if (xBitLength > yBitLength)\n            return JSBI.__absoluteGreater(xSign);\n        // Same sign, same bit length. Shift mantissa to align with x and compare\n        // bit for bit.\n        const kHiddenBit = 0x00100000;\n        let mantissaHigh = (JSBI.__kBitConversionInts[1] & 0xFFFFF) | kHiddenBit;\n        let mantissaLow = JSBI.__kBitConversionInts[0];\n        const kMantissaHighTopBit = 20;\n        const msdTopBit = 29 - msdLeadingZeros;\n        if (msdTopBit !== (((xBitLength - 1) % 30) | 0)) {\n            throw new Error('implementation bug');\n        }\n        let compareMantissa; // Shifted chunk of mantissa.\n        let remainingMantissaBits = 0;\n        // First, compare most significant digit against beginning of mantissa.\n        if (msdTopBit < kMantissaHighTopBit) {\n            const shift = kMantissaHighTopBit - msdTopBit;\n            remainingMantissaBits = shift + 32;\n            compareMantissa = mantissaHigh >>> shift;\n            mantissaHigh = (mantissaHigh << (32 - shift)) | (mantissaLow >>> shift);\n            mantissaLow = mantissaLow << (32 - shift);\n        }\n        else if (msdTopBit === kMantissaHighTopBit) {\n            remainingMantissaBits = 32;\n            compareMantissa = mantissaHigh;\n            mantissaHigh = mantissaLow;\n            mantissaLow = 0;\n        }\n        else {\n            const shift = msdTopBit - kMantissaHighTopBit;\n            remainingMantissaBits = 32 - shift;\n            compareMantissa =\n                (mantissaHigh << shift) | (mantissaLow >>> (32 - shift));\n            mantissaHigh = mantissaLow << shift;\n            mantissaLow = 0;\n        }\n        xMsd = xMsd >>> 0;\n        compareMantissa = compareMantissa >>> 0;\n        if (xMsd > compareMantissa)\n            return JSBI.__absoluteGreater(xSign);\n        if (xMsd < compareMantissa)\n            return JSBI.__absoluteLess(xSign);\n        // Then, compare additional digits against remaining mantissa bits.\n        for (let digitIndex = xLength - 2; digitIndex >= 0; digitIndex--) {\n            if (remainingMantissaBits > 0) {\n                remainingMantissaBits -= 30;\n                compareMantissa = mantissaHigh >>> 2;\n                mantissaHigh = (mantissaHigh << 30) | (mantissaLow >>> 2);\n                mantissaLow = (mantissaLow << 30);\n            }\n            else {\n                compareMantissa = 0;\n            }\n            const digit = x.__unsignedDigit(digitIndex);\n            if (digit > compareMantissa)\n                return JSBI.__absoluteGreater(xSign);\n            if (digit < compareMantissa)\n                return JSBI.__absoluteLess(xSign);\n        }\n        // Integer parts are equal; check whether {y} has a fractional part.\n        if (mantissaHigh !== 0 || mantissaLow !== 0) {\n            if (remainingMantissaBits === 0)\n                throw new Error('implementation bug');\n            return JSBI.__absoluteLess(xSign);\n        }\n        return 0;\n    }\n    static __equalToNumber(x, y) {\n        if (JSBI.__isOneDigitInt(y)) {\n            if (y === 0)\n                return x.length === 0;\n            // Any multi-digit BigInt is bigger than an int32.\n            return (x.length === 1) && (x.sign === (y < 0)) &&\n                (x.__unsignedDigit(0) === Math.abs(y));\n        }\n        return JSBI.__compareToDouble(x, y) === 0;\n    }\n    // Comparison operations, chosen such that \"op ^ 2\" reverses direction:\n    // 0 - lessThan\n    // 1 - lessThanOrEqual\n    // 2 - greaterThan\n    // 3 - greaterThanOrEqual\n    static __comparisonResultToBool(result, op) {\n        switch (op) {\n            case 0: return result < 0;\n            case 1: return result <= 0;\n            case 2: return result > 0;\n            case 3: return result >= 0;\n        }\n    }\n    static __compare(x, y, op) {\n        x = JSBI.__toPrimitive(x);\n        y = JSBI.__toPrimitive(y);\n        if (typeof x === 'string' && typeof y === 'string') {\n            switch (op) {\n                case 0: return x < y;\n                case 1: return x <= y;\n                case 2: return x > y;\n                case 3: return x >= y;\n            }\n        }\n        if (JSBI.__isBigInt(x) && typeof y === 'string') {\n            y = JSBI.__fromString(y);\n            if (y === null)\n                return false;\n            return JSBI.__comparisonResultToBool(JSBI.__compareToBigInt(x, y), op);\n        }\n        if (typeof x === 'string' && JSBI.__isBigInt(y)) {\n            x = JSBI.__fromString(x);\n            if (x === null)\n                return false;\n            return JSBI.__comparisonResultToBool(JSBI.__compareToBigInt(x, y), op);\n        }\n        x = JSBI.__toNumeric(x);\n        y = JSBI.__toNumeric(y);\n        if (JSBI.__isBigInt(x)) {\n            if (JSBI.__isBigInt(y)) {\n                return JSBI.__comparisonResultToBool(JSBI.__compareToBigInt(x, y), op);\n            }\n            if (typeof y !== 'number')\n                throw new Error('implementation bug');\n            return JSBI.__comparisonResultToBool(JSBI.__compareToNumber(x, y), op);\n        }\n        if (typeof x !== 'number')\n            throw new Error('implementation bug');\n        if (JSBI.__isBigInt(y)) {\n            // Note that \"op ^ 2\" reverses the op's direction.\n            return JSBI.__comparisonResultToBool(JSBI.__compareToNumber(y, x), (op ^ 2));\n        }\n        if (typeof y !== 'number')\n            throw new Error('implementation bug');\n        switch (op) {\n            case 0: return x < y;\n            case 1: return x <= y;\n            case 2: return x > y;\n            case 3: return x >= y;\n        }\n    }\n    __clzmsd() {\n        return JSBI.__clz30(this.__digit(this.length - 1));\n    }\n    static __absoluteAdd(x, y, resultSign) {\n        if (x.length < y.length)\n            return JSBI.__absoluteAdd(y, x, resultSign);\n        if (x.length === 0)\n            return x;\n        if (y.length === 0)\n            return x.sign === resultSign ? x : JSBI.unaryMinus(x);\n        let resultLength = x.length;\n        if (x.__clzmsd() === 0 || (y.length === x.length && y.__clzmsd() === 0)) {\n            resultLength++;\n        }\n        const result = new JSBI(resultLength, resultSign);\n        let carry = 0;\n        let i = 0;\n        for (; i < y.length; i++) {\n            const r = x.__digit(i) + y.__digit(i) + carry;\n            carry = r >>> 30;\n            result.__setDigit(i, r & 0x3FFFFFFF);\n        }\n        for (; i < x.length; i++) {\n            const r = x.__digit(i) + carry;\n            carry = r >>> 30;\n            result.__setDigit(i, r & 0x3FFFFFFF);\n        }\n        if (i < result.length) {\n            result.__setDigit(i, carry);\n        }\n        return result.__trim();\n    }\n    static __absoluteSub(x, y, resultSign) {\n        if (x.length === 0)\n            return x;\n        if (y.length === 0)\n            return x.sign === resultSign ? x : JSBI.unaryMinus(x);\n        const result = new JSBI(x.length, resultSign);\n        let borrow = 0;\n        let i = 0;\n        for (; i < y.length; i++) {\n            const r = x.__digit(i) - y.__digit(i) - borrow;\n            borrow = (r >>> 30) & 1;\n            result.__setDigit(i, r & 0x3FFFFFFF);\n        }\n        for (; i < x.length; i++) {\n            const r = x.__digit(i) - borrow;\n            borrow = (r >>> 30) & 1;\n            result.__setDigit(i, r & 0x3FFFFFFF);\n        }\n        return result.__trim();\n    }\n    static __absoluteAddOne(x, sign, result = null) {\n        const inputLength = x.length;\n        if (result === null) {\n            result = new JSBI(inputLength, sign);\n        }\n        else {\n            result.sign = sign;\n        }\n        let carry = 1;\n        for (let i = 0; i < inputLength; i++) {\n            const r = x.__digit(i) + carry;\n            carry = r >>> 30;\n            result.__setDigit(i, r & 0x3FFFFFFF);\n        }\n        if (carry !== 0) {\n            result.__setDigitGrow(inputLength, 1);\n        }\n        return result;\n    }\n    static __absoluteSubOne(x, resultLength) {\n        const length = x.length;\n        resultLength = resultLength || length;\n        const result = new JSBI(resultLength, false);\n        let borrow = 1;\n        for (let i = 0; i < length; i++) {\n            const r = x.__digit(i) - borrow;\n            borrow = (r >>> 30) & 1;\n            result.__setDigit(i, r & 0x3FFFFFFF);\n        }\n        if (borrow !== 0)\n            throw new Error('implementation bug');\n        for (let i = length; i < resultLength; i++) {\n            result.__setDigit(i, 0);\n        }\n        return result;\n    }\n    static __absoluteAnd(x, y, result = null) {\n        let xLength = x.length;\n        let yLength = y.length;\n        let numPairs = yLength;\n        if (xLength < yLength) {\n            numPairs = xLength;\n            const tmp = x;\n            const tmpLength = xLength;\n            x = y;\n            xLength = yLength;\n            y = tmp;\n            yLength = tmpLength;\n        }\n        let resultLength = numPairs;\n        if (result === null) {\n            result = new JSBI(resultLength, false);\n        }\n        else {\n            resultLength = result.length;\n        }\n        let i = 0;\n        for (; i < numPairs; i++) {\n            result.__setDigit(i, x.__digit(i) & y.__digit(i));\n        }\n        for (; i < resultLength; i++) {\n            result.__setDigit(i, 0);\n        }\n        return result;\n    }\n    static __absoluteAndNot(x, y, result = null) {\n        const xLength = x.length;\n        const yLength = y.length;\n        let numPairs = yLength;\n        if (xLength < yLength) {\n            numPairs = xLength;\n        }\n        let resultLength = xLength;\n        if (result === null) {\n            result = new JSBI(resultLength, false);\n        }\n        else {\n            resultLength = result.length;\n        }\n        let i = 0;\n        for (; i < numPairs; i++) {\n            result.__setDigit(i, x.__digit(i) & ~y.__digit(i));\n        }\n        for (; i < xLength; i++) {\n            result.__setDigit(i, x.__digit(i));\n        }\n        for (; i < resultLength; i++) {\n            result.__setDigit(i, 0);\n        }\n        return result;\n    }\n    static __absoluteOr(x, y, result = null) {\n        let xLength = x.length;\n        let yLength = y.length;\n        let numPairs = yLength;\n        if (xLength < yLength) {\n            numPairs = xLength;\n            const tmp = x;\n            const tmpLength = xLength;\n            x = y;\n            xLength = yLength;\n            y = tmp;\n            yLength = tmpLength;\n        }\n        let resultLength = xLength;\n        if (result === null) {\n            result = new JSBI(resultLength, false);\n        }\n        else {\n            resultLength = result.length;\n        }\n        let i = 0;\n        for (; i < numPairs; i++) {\n            result.__setDigit(i, x.__digit(i) | y.__digit(i));\n        }\n        for (; i < xLength; i++) {\n            result.__setDigit(i, x.__digit(i));\n        }\n        for (; i < resultLength; i++) {\n            result.__setDigit(i, 0);\n        }\n        return result;\n    }\n    static __absoluteXor(x, y, result = null) {\n        let xLength = x.length;\n        let yLength = y.length;\n        let numPairs = yLength;\n        if (xLength < yLength) {\n            numPairs = xLength;\n            const tmp = x;\n            const tmpLength = xLength;\n            x = y;\n            xLength = yLength;\n            y = tmp;\n            yLength = tmpLength;\n        }\n        let resultLength = xLength;\n        if (result === null) {\n            result = new JSBI(resultLength, false);\n        }\n        else {\n            resultLength = result.length;\n        }\n        let i = 0;\n        for (; i < numPairs; i++) {\n            result.__setDigit(i, x.__digit(i) ^ y.__digit(i));\n        }\n        for (; i < xLength; i++) {\n            result.__setDigit(i, x.__digit(i));\n        }\n        for (; i < resultLength; i++) {\n            result.__setDigit(i, 0);\n        }\n        return result;\n    }\n    static __absoluteCompare(x, y) {\n        const diff = x.length - y.length;\n        if (diff !== 0)\n            return diff;\n        let i = x.length - 1;\n        while (i >= 0 && x.__digit(i) === y.__digit(i))\n            i--;\n        if (i < 0)\n            return 0;\n        return x.__unsignedDigit(i) > y.__unsignedDigit(i) ? 1 : -1;\n    }\n    static __multiplyAccumulate(multiplicand, multiplier, accumulator, accumulatorIndex) {\n        if (multiplier === 0)\n            return;\n        const m2Low = multiplier & 0x7FFF;\n        const m2High = multiplier >>> 15;\n        let carry = 0;\n        let high = 0;\n        for (let i = 0; i < multiplicand.length; i++, accumulatorIndex++) {\n            let acc = accumulator.__digit(accumulatorIndex);\n            const m1 = multiplicand.__digit(i);\n            const m1Low = m1 & 0x7FFF;\n            const m1High = m1 >>> 15;\n            const rLow = JSBI.__imul(m1Low, m2Low);\n            const rMid1 = JSBI.__imul(m1Low, m2High);\n            const rMid2 = JSBI.__imul(m1High, m2Low);\n            const rHigh = JSBI.__imul(m1High, m2High);\n            acc += high + rLow + carry;\n            carry = acc >>> 30;\n            acc &= 0x3FFFFFFF;\n            acc += ((rMid1 & 0x7FFF) << 15) + ((rMid2 & 0x7FFF) << 15);\n            carry += acc >>> 30;\n            high = rHigh + (rMid1 >>> 15) + (rMid2 >>> 15);\n            accumulator.__setDigit(accumulatorIndex, acc & 0x3FFFFFFF);\n        }\n        for (; carry !== 0 || high !== 0; accumulatorIndex++) {\n            let acc = accumulator.__digit(accumulatorIndex);\n            acc += carry + high;\n            high = 0;\n            carry = acc >>> 30;\n            accumulator.__setDigit(accumulatorIndex, acc & 0x3FFFFFFF);\n        }\n    }\n    static __internalMultiplyAdd(source, factor, summand, n, result) {\n        let carry = summand;\n        let high = 0;\n        for (let i = 0; i < n; i++) {\n            const digit = source.__digit(i);\n            const rx = JSBI.__imul(digit & 0x7FFF, factor);\n            const ry = JSBI.__imul(digit >>> 15, factor);\n            const r = rx + ((ry & 0x7FFF) << 15) + high + carry;\n            carry = r >>> 30;\n            high = ry >>> 15;\n            result.__setDigit(i, r & 0x3FFFFFFF);\n        }\n        if (result.length > n) {\n            result.__setDigit(n++, carry + high);\n            while (n < result.length) {\n                result.__setDigit(n++, 0);\n            }\n        }\n        else {\n            if (carry + high !== 0)\n                throw new Error('implementation bug');\n        }\n    }\n    __inplaceMultiplyAdd(multiplier, summand, length) {\n        if (length > this.length)\n            length = this.length;\n        const mLow = multiplier & 0x7FFF;\n        const mHigh = multiplier >>> 15;\n        let carry = 0;\n        let high = summand;\n        for (let i = 0; i < length; i++) {\n            const d = this.__digit(i);\n            const dLow = d & 0x7FFF;\n            const dHigh = d >>> 15;\n            const pLow = JSBI.__imul(dLow, mLow);\n            const pMid1 = JSBI.__imul(dLow, mHigh);\n            const pMid2 = JSBI.__imul(dHigh, mLow);\n            const pHigh = JSBI.__imul(dHigh, mHigh);\n            let result = high + pLow + carry;\n            carry = result >>> 30;\n            result &= 0x3FFFFFFF;\n            result += ((pMid1 & 0x7FFF) << 15) + ((pMid2 & 0x7FFF) << 15);\n            carry += result >>> 30;\n            high = pHigh + (pMid1 >>> 15) + (pMid2 >>> 15);\n            this.__setDigit(i, result & 0x3FFFFFFF);\n        }\n        if (carry !== 0 || high !== 0) {\n            throw new Error('implementation bug');\n        }\n    }\n    static __absoluteDivSmall(x, divisor, quotient = null) {\n        if (quotient === null)\n            quotient = new JSBI(x.length, false);\n        let remainder = 0;\n        for (let i = x.length * 2 - 1; i >= 0; i -= 2) {\n            let input = ((remainder << 15) | x.__halfDigit(i)) >>> 0;\n            const upperHalf = (input / divisor) | 0;\n            remainder = (input % divisor) | 0;\n            input = ((remainder << 15) | x.__halfDigit(i - 1)) >>> 0;\n            const lowerHalf = (input / divisor) | 0;\n            remainder = (input % divisor) | 0;\n            quotient.__setDigit(i >>> 1, (upperHalf << 15) | lowerHalf);\n        }\n        return quotient;\n    }\n    static __absoluteModSmall(x, divisor) {\n        let remainder = 0;\n        for (let i = x.length * 2 - 1; i >= 0; i--) {\n            const input = ((remainder << 15) | x.__halfDigit(i)) >>> 0;\n            remainder = (input % divisor) | 0;\n        }\n        return remainder;\n    }\n    static __absoluteDivLarge(dividend, divisor, wantQuotient, wantRemainder) {\n        const n = divisor.__halfDigitLength();\n        const n2 = divisor.length;\n        const m = dividend.__halfDigitLength() - n;\n        let q = null;\n        if (wantQuotient) {\n            q = new JSBI((m + 2) >>> 1, false);\n            q.__initializeDigits();\n        }\n        const qhatv = new JSBI((n + 2) >>> 1, false);\n        qhatv.__initializeDigits();\n        // D1.\n        const shift = JSBI.__clz15(divisor.__halfDigit(n - 1));\n        if (shift > 0) {\n            divisor = JSBI.__specialLeftShift(divisor, shift, 0 /* add no digits*/);\n        }\n        const u = JSBI.__specialLeftShift(dividend, shift, 1 /* add one digit */);\n        // D2.\n        const vn1 = divisor.__halfDigit(n - 1);\n        let halfDigitBuffer = 0;\n        for (let j = m; j >= 0; j--) {\n            // D3.\n            let qhat = 0x7FFF;\n            const ujn = u.__halfDigit(j + n);\n            if (ujn !== vn1) {\n                const input = ((ujn << 15) | u.__halfDigit(j + n - 1)) >>> 0;\n                qhat = (input / vn1) | 0;\n                let rhat = (input % vn1) | 0;\n                const vn2 = divisor.__halfDigit(n - 2);\n                const ujn2 = u.__halfDigit(j + n - 2);\n                while ((JSBI.__imul(qhat, vn2) >>> 0) > (((rhat << 16) | ujn2) >>> 0)) {\n                    qhat--;\n                    rhat += vn1;\n                    if (rhat > 0x7FFF)\n                        break;\n                }\n            }\n            // D4.\n            JSBI.__internalMultiplyAdd(divisor, qhat, 0, n2, qhatv);\n            let c = u.__inplaceSub(qhatv, j, n + 1);\n            if (c !== 0) {\n                c = u.__inplaceAdd(divisor, j, n);\n                u.__setHalfDigit(j + n, (u.__halfDigit(j + n) + c) & 0x7FFF);\n                qhat--;\n            }\n            if (wantQuotient) {\n                if (j & 1) {\n                    halfDigitBuffer = qhat << 15;\n                }\n                else {\n                    // TODO make this statically determinable\n                    q.__setDigit(j >>> 1, halfDigitBuffer | qhat);\n                }\n            }\n        }\n        if (wantRemainder) {\n            u.__inplaceRightShift(shift);\n            if (wantQuotient) {\n                return { quotient: q, remainder: u };\n            }\n            return u;\n        }\n        if (wantQuotient)\n            return q;\n        // TODO find a way to make this statically unreachable?\n        throw new Error('unreachable');\n    }\n    static __clz15(value) {\n        return JSBI.__clz30(value) - 15;\n    }\n    // TODO: work on full digits, like __inplaceSub?\n    __inplaceAdd(summand, startIndex, halfDigits) {\n        let carry = 0;\n        for (let i = 0; i < halfDigits; i++) {\n            const sum = this.__halfDigit(startIndex + i) +\n                summand.__halfDigit(i) +\n                carry;\n            carry = sum >>> 15;\n            this.__setHalfDigit(startIndex + i, sum & 0x7FFF);\n        }\n        return carry;\n    }\n    __inplaceSub(subtrahend, startIndex, halfDigits) {\n        const fullSteps = (halfDigits - 1) >>> 1;\n        let borrow = 0;\n        if (startIndex & 1) {\n            // this:   [..][..][..]\n            // subtr.:   [..][..]\n            startIndex >>= 1;\n            let current = this.__digit(startIndex);\n            let r0 = current & 0x7FFF;\n            let i = 0;\n            for (; i < fullSteps; i++) {\n                const sub = subtrahend.__digit(i);\n                const r15 = (current >>> 15) - (sub & 0x7FFF) - borrow;\n                borrow = (r15 >>> 15) & 1;\n                this.__setDigit(startIndex + i, ((r15 & 0x7FFF) << 15) | (r0 & 0x7FFF));\n                current = this.__digit(startIndex + i + 1);\n                r0 = (current & 0x7FFF) - (sub >>> 15) - borrow;\n                borrow = (r0 >>> 15) & 1;\n            }\n            // Unrolling the last iteration gives a 5% performance benefit!\n            const sub = subtrahend.__digit(i);\n            const r15 = (current >>> 15) - (sub & 0x7FFF) - borrow;\n            borrow = (r15 >>> 15) & 1;\n            this.__setDigit(startIndex + i, ((r15 & 0x7FFF) << 15) | (r0 & 0x7FFF));\n            const subTop = sub >>> 15;\n            if (startIndex + i + 1 >= this.length) {\n                throw new RangeError('out of bounds');\n            }\n            if ((halfDigits & 1) === 0) {\n                current = this.__digit(startIndex + i + 1);\n                r0 = (current & 0x7FFF) - subTop - borrow;\n                borrow = (r0 >>> 15) & 1;\n                this.__setDigit(startIndex + subtrahend.length, (current & 0x3FFF8000) | (r0 & 0x7FFF));\n            }\n        }\n        else {\n            startIndex >>= 1;\n            let i = 0;\n            for (; i < subtrahend.length - 1; i++) {\n                const current = this.__digit(startIndex + i);\n                const sub = subtrahend.__digit(i);\n                const r0 = (current & 0x7FFF) - (sub & 0x7FFF) - borrow;\n                borrow = (r0 >>> 15) & 1;\n                const r15 = (current >>> 15) - (sub >>> 15) - borrow;\n                borrow = (r15 >>> 15) & 1;\n                this.__setDigit(startIndex + i, ((r15 & 0x7FFF) << 15) | (r0 & 0x7FFF));\n            }\n            const current = this.__digit(startIndex + i);\n            const sub = subtrahend.__digit(i);\n            const r0 = (current & 0x7FFF) - (sub & 0x7FFF) - borrow;\n            borrow = (r0 >>> 15) & 1;\n            let r15 = 0;\n            if ((halfDigits & 1) === 0) {\n                r15 = (current >>> 15) - (sub >>> 15) - borrow;\n                borrow = (r15 >>> 15) & 1;\n            }\n            this.__setDigit(startIndex + i, ((r15 & 0x7FFF) << 15) | (r0 & 0x7FFF));\n        }\n        return borrow;\n    }\n    __inplaceRightShift(shift) {\n        if (shift === 0)\n            return;\n        let carry = this.__digit(0) >>> shift;\n        const last = this.length - 1;\n        for (let i = 0; i < last; i++) {\n            const d = this.__digit(i + 1);\n            this.__setDigit(i, ((d << (30 - shift)) & 0x3FFFFFFF) | carry);\n            carry = d >>> shift;\n        }\n        this.__setDigit(last, carry);\n    }\n    static __specialLeftShift(x, shift, addDigit) {\n        const n = x.length;\n        const resultLength = n + addDigit;\n        const result = new JSBI(resultLength, false);\n        if (shift === 0) {\n            for (let i = 0; i < n; i++)\n                result.__setDigit(i, x.__digit(i));\n            if (addDigit > 0)\n                result.__setDigit(n, 0);\n            return result;\n        }\n        let carry = 0;\n        for (let i = 0; i < n; i++) {\n            const d = x.__digit(i);\n            result.__setDigit(i, ((d << shift) & 0x3FFFFFFF) | carry);\n            carry = d >>> (30 - shift);\n        }\n        if (addDigit > 0) {\n            result.__setDigit(n, carry);\n        }\n        return result;\n    }\n    static __leftShiftByAbsolute(x, y) {\n        const shift = JSBI.__toShiftAmount(y);\n        if (shift < 0)\n            throw new RangeError('BigInt too big');\n        const digitShift = (shift / 30) | 0;\n        const bitsShift = shift % 30;\n        const length = x.length;\n        const grow = bitsShift !== 0 &&\n            (x.__digit(length - 1) >>> (30 - bitsShift)) !== 0;\n        const resultLength = length + digitShift + (grow ? 1 : 0);\n        const result = new JSBI(resultLength, x.sign);\n        if (bitsShift === 0) {\n            let i = 0;\n            for (; i < digitShift; i++)\n                result.__setDigit(i, 0);\n            for (; i < resultLength; i++) {\n                result.__setDigit(i, x.__digit(i - digitShift));\n            }\n        }\n        else {\n            let carry = 0;\n            for (let i = 0; i < digitShift; i++)\n                result.__setDigit(i, 0);\n            for (let i = 0; i < length; i++) {\n                const d = x.__digit(i);\n                result.__setDigit(i + digitShift, ((d << bitsShift) & 0x3FFFFFFF) | carry);\n                carry = d >>> (30 - bitsShift);\n            }\n            if (grow) {\n                result.__setDigit(length + digitShift, carry);\n            }\n            else {\n                if (carry !== 0)\n                    throw new Error('implementation bug');\n            }\n        }\n        return result.__trim();\n    }\n    static __rightShiftByAbsolute(x, y) {\n        const length = x.length;\n        const sign = x.sign;\n        const shift = JSBI.__toShiftAmount(y);\n        if (shift < 0)\n            return JSBI.__rightShiftByMaximum(sign);\n        const digitShift = (shift / 30) | 0;\n        const bitsShift = shift % 30;\n        let resultLength = length - digitShift;\n        if (resultLength <= 0)\n            return JSBI.__rightShiftByMaximum(sign);\n        // For negative numbers, round down if any bit was shifted out (so that\n        // e.g. -5n >> 1n == -3n and not -2n). Check now whether this will happen\n        // and whether itc an cause overflow into a new digit. If we allocate the\n        // result large enough up front, it avoids having to do grow it later.\n        let mustRoundDown = false;\n        if (sign) {\n            const mask = (1 << bitsShift) - 1;\n            if ((x.__digit(digitShift) & mask) !== 0) {\n                mustRoundDown = true;\n            }\n            else {\n                for (let i = 0; i < digitShift; i++) {\n                    if (x.__digit(i) !== 0) {\n                        mustRoundDown = true;\n                        break;\n                    }\n                }\n            }\n        }\n        // If bitsShift is non-zero, it frees up bits, preventing overflow.\n        if (mustRoundDown && bitsShift === 0) {\n            // Overflow cannot happen if the most significant digit has unset bits.\n            const msd = x.__digit(length - 1);\n            const roundingCanOverflow = ~msd === 0;\n            if (roundingCanOverflow)\n                resultLength++;\n        }\n        let result = new JSBI(resultLength, sign);\n        if (bitsShift === 0) {\n            // Zero out any overflow digit (see \"roundingCanOverflow\" above).\n            result.__setDigit(resultLength - 1, 0);\n            for (let i = digitShift; i < length; i++) {\n                result.__setDigit(i - digitShift, x.__digit(i));\n            }\n        }\n        else {\n            let carry = x.__digit(digitShift) >>> bitsShift;\n            const last = length - digitShift - 1;\n            for (let i = 0; i < last; i++) {\n                const d = x.__digit(i + digitShift + 1);\n                result.__setDigit(i, ((d << (30 - bitsShift)) & 0x3FFFFFFF) | carry);\n                carry = d >>> bitsShift;\n            }\n            result.__setDigit(last, carry);\n        }\n        if (mustRoundDown) {\n            // Since the result is negative, rounding down means adding one to its\n            // absolute value. This cannot overflow.\n            result = JSBI.__absoluteAddOne(result, true, result);\n        }\n        return result.__trim();\n    }\n    static __rightShiftByMaximum(sign) {\n        if (sign) {\n            return JSBI.__oneDigit(1, true);\n        }\n        return JSBI.__zero();\n    }\n    static __toShiftAmount(x) {\n        if (x.length > 1)\n            return -1;\n        const value = x.__unsignedDigit(0);\n        if (value > JSBI.__kMaxLengthBits)\n            return -1;\n        return value;\n    }\n    static __toPrimitive(obj, hint = 'default') {\n        if (typeof obj !== 'object')\n            return obj;\n        if (obj.constructor === JSBI)\n            return obj;\n        if (typeof Symbol !== 'undefined' &&\n            typeof Symbol.toPrimitive === 'symbol') {\n            const exoticToPrim = obj[Symbol.toPrimitive];\n            if (exoticToPrim) {\n                const primitive = exoticToPrim(hint);\n                if (typeof primitive !== 'object')\n                    return primitive;\n                throw new TypeError('Cannot convert object to primitive value');\n            }\n        }\n        const valueOf = obj.valueOf;\n        if (valueOf) {\n            const primitive = valueOf.call(obj);\n            if (typeof primitive !== 'object')\n                return primitive;\n        }\n        const toString = obj.toString;\n        if (toString) {\n            const primitive = toString.call(obj);\n            if (typeof primitive !== 'object')\n                return primitive;\n        }\n        throw new TypeError('Cannot convert object to primitive value');\n    }\n    static __toNumeric(value) {\n        if (JSBI.__isBigInt(value))\n            return value;\n        return +value;\n    }\n    static __isBigInt(value) {\n        return typeof value === 'object' && value !== null &&\n            value.constructor === JSBI;\n    }\n    static __truncateToNBits(n, x) {\n        const neededDigits = ((n + 29) / 30) | 0;\n        const result = new JSBI(neededDigits, x.sign);\n        const last = neededDigits - 1;\n        for (let i = 0; i < last; i++) {\n            result.__setDigit(i, x.__digit(i));\n        }\n        let msd = x.__digit(last);\n        if ((n % 30) !== 0) {\n            const drop = 32 - (n % 30);\n            msd = (msd << drop) >>> drop;\n        }\n        result.__setDigit(last, msd);\n        return result.__trim();\n    }\n    static __truncateAndSubFromPowerOfTwo(n, x, resultSign) {\n        const neededDigits = ((n + 29) / 30) | 0;\n        const result = new JSBI(neededDigits, resultSign);\n        let i = 0;\n        const last = neededDigits - 1;\n        let borrow = 0;\n        const limit = Math.min(last, x.length);\n        for (; i < limit; i++) {\n            const r = 0 - x.__digit(i) - borrow;\n            borrow = (r >>> 30) & 1;\n            result.__setDigit(i, r & 0x3FFFFFFF);\n        }\n        for (; i < last; i++) {\n            result.__setDigit(i, (-borrow & 0x3FFFFFFF) | 0);\n        }\n        let msd = last < x.length ? x.__digit(last) : 0;\n        const msdBitsConsumed = n % 30;\n        let resultMsd;\n        if (msdBitsConsumed === 0) {\n            resultMsd = 0 - msd - borrow;\n            resultMsd &= 0x3FFFFFFF;\n        }\n        else {\n            const drop = 32 - msdBitsConsumed;\n            msd = (msd << drop) >>> drop;\n            const minuendMsd = 1 << (32 - drop);\n            resultMsd = minuendMsd - msd - borrow;\n            resultMsd &= (minuendMsd - 1);\n        }\n        result.__setDigit(last, resultMsd);\n        return result.__trim();\n    }\n    // Digit helpers.\n    __digit(i) {\n        return this[i];\n    }\n    __unsignedDigit(i) {\n        return this[i] >>> 0;\n    }\n    __setDigit(i, digit) {\n        this[i] = digit | 0;\n    }\n    __setDigitGrow(i, digit) {\n        this[i] = digit | 0;\n    }\n    __halfDigitLength() {\n        const len = this.length;\n        if (this.__unsignedDigit(len - 1) <= 0x7FFF)\n            return len * 2 - 1;\n        return len * 2;\n    }\n    __halfDigit(i) {\n        return (this[i >>> 1] >>> ((i & 1) * 15)) & 0x7FFF;\n    }\n    __setHalfDigit(i, value) {\n        const digitIndex = i >>> 1;\n        const previous = this.__digit(digitIndex);\n        const updated = (i & 1) ? (previous & 0x7FFF) | (value << 15)\n            : (previous & 0x3FFF8000) | (value & 0x7FFF);\n        this.__setDigit(digitIndex, updated);\n    }\n    static __digitPow(base, exponent) {\n        let result = 1;\n        while (exponent > 0) {\n            if (exponent & 1)\n                result *= base;\n            exponent >>>= 1;\n            base *= base;\n        }\n        return result;\n    }\n    static __isOneDigitInt(x) {\n        return (x & 0x3FFFFFFF) === x;\n    }\n}\nJSBI.__kMaxLength = 1 << 25;\nJSBI.__kMaxLengthBits = JSBI.__kMaxLength << 5;\n// Lookup table for the maximum number of bits required per character of a\n// base-N string representation of a number. To increase accuracy, the array\n// value is the actual value multiplied by 32. To generate this table:\n//\n// for (let i = 0; i <= 36; i++) {\n//   console.log(Math.ceil(Math.log2(i) * 32) + ',');\n// }\nJSBI.__kMaxBitsPerChar = [\n    0, 0, 32, 51, 64, 75, 83, 90, 96,\n    102, 107, 111, 115, 119, 122, 126, 128,\n    131, 134, 136, 139, 141, 143, 145, 147,\n    149, 151, 153, 154, 156, 158, 159, 160,\n    162, 163, 165, 166, // 33..36\n];\nJSBI.__kBitsPerCharTableShift = 5;\nJSBI.__kBitsPerCharTableMultiplier = 1 << JSBI.__kBitsPerCharTableShift;\nJSBI.__kConversionChars = '0123456789abcdefghijklmnopqrstuvwxyz'.split('');\nJSBI.__kBitConversionBuffer = new ArrayBuffer(8);\nJSBI.__kBitConversionDouble = new Float64Array(JSBI.__kBitConversionBuffer);\nJSBI.__kBitConversionInts = new Int32Array(JSBI.__kBitConversionBuffer);\n// For IE11 compatibility.\n// Note that the custom replacements are tailored for JSBI's needs, and as\n// such are not reusable as general-purpose polyfills.\nJSBI.__clz30 = Math.clz32 ? function (x) {\n    return Math.clz32(x) - 2;\n} : function (x) {\n    if (x === 0)\n        return 30;\n    return 29 - (Math.log(x >>> 0) / Math.LN2 | 0) | 0;\n};\nJSBI.__imul = Math.imul || function (a, b) {\n    return (a * b) | 0;\n};\nexport default JSBI;\n//# sourceMappingURL=jsbi.js.map"],"names":["Math","imul","clz32","JSBI","abs","max","floor","length","sign","setPrototypeOf","prototype","__kMaxLength","RangeError","result","digit","push","toString","join","radix","__toStringBasePowerOfTwo","__toStringGeneric","Error","i","newLength","last","pop","__clz30","__digit","multiplier","summand","mLow","mHigh","carry","high","d","dLow","dHigh","pLow","__imul","pMid1","pMid2","pHigh","__setDigit","startIndex","halfDigits","sum","__halfDigit","__setHalfDigit","subtrahend","borrow","current","r0","sub","r15","shift","len","__unsignedDigit","value","digitIndex","previous","updated","arg","Number","isFinite","__zero","__isOneDigitInt","__oneDigit","__fromDouble","__fromString","SyntaxError","_typeof","constructor","primitive","__toPrimitive","BigInt","TypeError","x","xLength","xMsd","msdLeadingZeros","xBitLength","Infinity","exponent","currentDigit","mantissaHigh","mantissaHighBitsUnset","mantissaLow","mantissaLowBitsUnset","rounding","__decideRounding","signBit","__kBitConversionInts","__kBitConversionDouble","__copy","__absoluteSubOne","__trim","__absoluteAddOne","y","unaryMinus","expValue","__kMaxLengthBits","neededDigits","__initializeDigits","msd","runningSquare","multiply","resultLength","__clzmsd","__multiplyAccumulate","__absoluteCompare","quotient","resultSign","divisor","__absoluteDivSmall","__absoluteDivLarge","remainderDigit","__absoluteModSmall","remainder","__absoluteAdd","__absoluteSub","__rightShiftByAbsolute","__leftShiftByAbsolute","__compareToBigInt","equal","__absoluteAnd","y1","__absoluteOr","__absoluteAndNot","__absoluteXor","n","neededLength","topDigit","compareDigit","__truncateToNBits","__truncateAndSubFromPowerOfTwo","bitsInTopDigit","__toNumeric","__isBigInt","add","__compare","EQ","__equalToNumber","dataview","byteOffset","littleEndian","asIntN","DataViewGetBigUint64","h","l","getUint32","low","DataViewSetBigUint64","asUintN","d1","setUint32","mantissaBitsUnset","topUnconsumedBit","mask","rawExponent","digits","kMantissaHighTopBit","msdTopBit","remainingMantissaBits","c","string","cursor","charCodeAt","__isWhitespace","chars","bitsPerChar","__kMaxBitsPerChar","roundup","__kBitsPerCharTableMultiplier","bitsMin","__kBitsPerCharTableShift","limDigit","limAlpha","parts","partsBits","done","part","bits","__fillFromParts","charsSoFar","m","digitsSoFar","__inplaceMultiplyAdd","bitsInDigit","partBits","charMask","charsRequired","bitLength","Array","pos","availableBits","newDigit","__kConversionChars","consumedBits","isRecursiveCall","maxBitsPerChar","minBitsPerChar","secondHalf","secondHalfChars","conqueror","exponentiate","input","divisionResult","firstHalf","leftNegative","bothNegative","xSign","__unequalSign","__absoluteGreater","__absoluteLess","ySign","yAbs","xDigit","__compareToDouble","yBitLength","compareMantissa","op","__comparisonResultToBool","__compareToNumber","r","inputLength","__setDigitGrow","yLength","numPairs","tmp","tmpLength","diff","multiplicand","accumulator","accumulatorIndex","m2Low","m2High","acc","m1","m1Low","m1High","rLow","rMid1","rMid2","rHigh","source","factor","rx","ry","upperHalf","lowerHalf","dividend","wantQuotient","wantRemainder","__halfDigitLength","n2","q","qhatv","__clz15","__specialLeftShift","u","vn1","halfDigitBuffer","j","qhat","ujn","rhat","vn2","ujn2","__internalMultiplyAdd","__inplaceSub","__inplaceAdd","__inplaceRightShift","addDigit","__toShiftAmount","digitShift","bitsShift","grow","__rightShiftByMaximum","mustRoundDown","obj","hint","Symbol","toPrimitive","exoticToPrim","valueOf","call","drop","min","limit","resultMsd","msdBitsConsumed","minuendMsd","base","ArrayBuffer","Float64Array","__kBitConversionBuffer","Int32Array","LN2","log","a","b"],"mappings":"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"}