@norionsoft/hd-derivations 1.0.0-beta.0

package/build/browser/bchaddr-DGcVCvZc.js

@@ -0,0 +1,2340 @@
+import { r as requireBs58check } from './index-CGhg1ff2.js';
+import { r as requireDist } from './bn-C5dpaNMj.js';
+
+/**
+ * @license
+ * https://github.com/ealmansi/cashaddrjs
+ * Copyright (c) 2017-2020 Emilio Almansi
+ * Distributed under the MIT software license, see the accompanying
+ * file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+ */
+
+var validation;
+var hasRequiredValidation;
+
+function requireValidation () {
+	if (hasRequiredValidation) return validation;
+	hasRequiredValidation = 1;
+
+	/**
+	 * Validation utility.
+	 *
+	 * @module validation
+	 */
+
+	/**
+	 * Error thrown when encoding or decoding fail due to invalid input.
+	 *
+	 * @constructor ValidationError
+	 * @param {string} message Error description.
+	 */
+	function ValidationError(message) {
+	  var error = new Error();
+	  this.name = error.name = 'ValidationError';
+	  this.message = error.message = message;
+	  this.stack = error.stack;
+	}
+
+	ValidationError.prototype = Object.create(Error.prototype);
+
+	/**
+	 * Validates a given condition, throwing a {@link ValidationError} if
+	 * the given condition does not hold.
+	 *
+	 * @static
+	 * @param {boolean} condition Condition to validate.
+	 * @param {string} message Error message in case the condition does not hold.
+	 */
+	function validate(condition, message) {
+	  if (!condition) {
+	    throw new ValidationError(message);
+	  }
+	}
+
+	validation = {
+	  ValidationError: ValidationError,
+	  validate: validate,
+	};
+	return validation;
+}
+
+/**
+ * @license
+ * https://github.com/ealmansi/cashaddrjs
+ * Copyright (c) 2017-2020 Emilio Almansi
+ * Distributed under the MIT software license, see the accompanying
+ * file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+ */
+
+var base32;
+var hasRequiredBase32;
+
+function requireBase32 () {
+	if (hasRequiredBase32) return base32;
+	hasRequiredBase32 = 1;
+
+	var validate = requireValidation().validate;
+
+	/**
+	 * Base32 encoding and decoding.
+	 *
+	 * @module base32
+	 */
+
+	/**
+	 * Charset containing the 32 symbols used in the base32 encoding.
+	 * @private
+	 */
+	var CHARSET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
+
+	/**
+	 * Inverted index mapping each symbol into its index within the charset.
+	 * @private
+	 */
+	var CHARSET_INVERSE_INDEX = {
+	  'q': 0, 'p': 1, 'z': 2, 'r': 3, 'y': 4, '9': 5, 'x': 6, '8': 7,
+	  'g': 8, 'f': 9, '2': 10, 't': 11, 'v': 12, 'd': 13, 'w': 14, '0': 15,
+	  's': 16, '3': 17, 'j': 18, 'n': 19, '5': 20, '4': 21, 'k': 22, 'h': 23,
+	  'c': 24, 'e': 25, '6': 26, 'm': 27, 'u': 28, 'a': 29, '7': 30, 'l': 31,
+	};
+
+	/**
+	 * Encodes the given array of 5-bit integers as a base32-encoded string.
+	 *
+	 * @static
+	 * @param {Uint8Array} data Array of integers between 0 and 31 inclusive.
+	 * @returns {string}
+	 * @throws {ValidationError}
+	 */
+	function encode(data) {
+	  validate(data instanceof Uint8Array, 'Invalid data: ' + data + '.');
+	  var base32 = '';
+	  for (var i = 0; i < data.length; ++i) {
+	    var value = data[i];
+	    validate(0 <= value && value < 32, 'Invalid value: ' + value + '.');
+	    base32 += CHARSET[value];
+	  }
+	  return base32;
+	}
+
+	/**
+	 * Decodes the given base32-encoded string into an array of 5-bit integers.
+	 *
+	 * @static
+	 * @param {string} string
+	 * @returns {Uint8Array}
+	 * @throws {ValidationError}
+	 */
+	function decode(string) {
+	  validate(typeof string === 'string', 'Invalid base32-encoded string: ' + string + '.');
+	  var data = new Uint8Array(string.length);
+	  for (var i = 0; i < string.length; ++i) {
+	    var value = string[i];
+	    validate(value in CHARSET_INVERSE_INDEX, 'Invalid value: ' + value + '.');
+	    data[i] = CHARSET_INVERSE_INDEX[value];
+	  }
+	  return data;
+	}
+
+	base32 = {
+	  encode: encode,
+	  decode: decode,
+	};
+	return base32;
+}
+
+var BigInteger = {exports: {}};
+
+var hasRequiredBigInteger;
+
+function requireBigInteger () {
+	if (hasRequiredBigInteger) return BigInteger.exports;
+	hasRequiredBigInteger = 1;
+	(function (module) {
+		var bigInt = (function (undefined$1) {
+
+		    var BASE = 1e7,
+		        LOG_BASE = 7,
+		        MAX_INT = 9007199254740992,
+		        MAX_INT_ARR = smallToArray(MAX_INT),
+		        LOG_MAX_INT = Math.log(MAX_INT);
+
+		    function Integer(v, radix) {
+		        if (typeof v === "undefined") return Integer[0];
+		        if (typeof radix !== "undefined") return +radix === 10 ? parseValue(v) : parseBase(v, radix);
+		        return parseValue(v);
+		    }
+
+		    function BigInteger(value, sign) {
+		        this.value = value;
+		        this.sign = sign;
+		        this.isSmall = false;
+		    }
+		    BigInteger.prototype = Object.create(Integer.prototype);
+
+		    function SmallInteger(value) {
+		        this.value = value;
+		        this.sign = value < 0;
+		        this.isSmall = true;
+		    }
+		    SmallInteger.prototype = Object.create(Integer.prototype);
+
+		    function isPrecise(n) {
+		        return -MAX_INT < n && n < MAX_INT;
+		    }
+
+		    function smallToArray(n) { // For performance reasons doesn't reference BASE, need to change this function if BASE changes
+		        if (n < 1e7)
+		            return [n];
+		        if (n < 1e14)
+		            return [n % 1e7, Math.floor(n / 1e7)];
+		        return [n % 1e7, Math.floor(n / 1e7) % 1e7, Math.floor(n / 1e14)];
+		    }
+
+		    function arrayToSmall(arr) { // If BASE changes this function may need to change
+		        trim(arr);
+		        var length = arr.length;
+		        if (length < 4 && compareAbs(arr, MAX_INT_ARR) < 0) {
+		            switch (length) {
+		                case 0: return 0;
+		                case 1: return arr[0];
+		                case 2: return arr[0] + arr[1] * BASE;
+		                default: return arr[0] + (arr[1] + arr[2] * BASE) * BASE;
+		            }
+		        }
+		        return arr;
+		    }
+
+		    function trim(v) {
+		        var i = v.length;
+		        while (v[--i] === 0);
+		        v.length = i + 1;
+		    }
+
+		    function createArray(length) { // function shamelessly stolen from Yaffle's library https://github.com/Yaffle/BigInteger
+		        var x = new Array(length);
+		        var i = -1;
+		        while (++i < length) {
+		            x[i] = 0;
+		        }
+		        return x;
+		    }
+
+		    function truncate(n) {
+		        if (n > 0) return Math.floor(n);
+		        return Math.ceil(n);
+		    }
+
+		    function add(a, b) { // assumes a and b are arrays with a.length >= b.length
+		        var l_a = a.length,
+		            l_b = b.length,
+		            r = new Array(l_a),
+		            carry = 0,
+		            base = BASE,
+		            sum, i;
+		        for (i = 0; i < l_b; i++) {
+		            sum = a[i] + b[i] + carry;
+		            carry = sum >= base ? 1 : 0;
+		            r[i] = sum - carry * base;
+		        }
+		        while (i < l_a) {
+		            sum = a[i] + carry;
+		            carry = sum === base ? 1 : 0;
+		            r[i++] = sum - carry * base;
+		        }
+		        if (carry > 0) r.push(carry);
+		        return r;
+		    }
+
+		    function addAny(a, b) {
+		        if (a.length >= b.length) return add(a, b);
+		        return add(b, a);
+		    }
+
+		    function addSmall(a, carry) { // assumes a is array, carry is number with 0 <= carry < MAX_INT
+		        var l = a.length,
+		            r = new Array(l),
+		            base = BASE,
+		            sum, i;
+		        for (i = 0; i < l; i++) {
+		            sum = a[i] - base + carry;
+		            carry = Math.floor(sum / base);
+		            r[i] = sum - carry * base;
+		            carry += 1;
+		        }
+		        while (carry > 0) {
+		            r[i++] = carry % base;
+		            carry = Math.floor(carry / base);
+		        }
+		        return r;
+		    }
+
+		    BigInteger.prototype.add = function (v) {
+		        var n = parseValue(v);
+		        if (this.sign !== n.sign) {
+		            return this.subtract(n.negate());
+		        }
+		        var a = this.value, b = n.value;
+		        if (n.isSmall) {
+		            return new BigInteger(addSmall(a, Math.abs(b)), this.sign);
+		        }
+		        return new BigInteger(addAny(a, b), this.sign);
+		    };
+		    BigInteger.prototype.plus = BigInteger.prototype.add;
+
+		    SmallInteger.prototype.add = function (v) {
+		        var n = parseValue(v);
+		        var a = this.value;
+		        if (a < 0 !== n.sign) {
+		            return this.subtract(n.negate());
+		        }
+		        var b = n.value;
+		        if (n.isSmall) {
+		            if (isPrecise(a + b)) return new SmallInteger(a + b);
+		            b = smallToArray(Math.abs(b));
+		        }
+		        return new BigInteger(addSmall(b, Math.abs(a)), a < 0);
+		    };
+		    SmallInteger.prototype.plus = SmallInteger.prototype.add;
+
+		    function subtract(a, b) { // assumes a and b are arrays with a >= b
+		        var a_l = a.length,
+		            b_l = b.length,
+		            r = new Array(a_l),
+		            borrow = 0,
+		            base = BASE,
+		            i, difference;
+		        for (i = 0; i < b_l; i++) {
+		            difference = a[i] - borrow - b[i];
+		            if (difference < 0) {
+		                difference += base;
+		                borrow = 1;
+		            } else borrow = 0;
+		            r[i] = difference;
+		        }
+		        for (i = b_l; i < a_l; i++) {
+		            difference = a[i] - borrow;
+		            if (difference < 0) difference += base;
+		            else {
+		                r[i++] = difference;
+		                break;
+		            }
+		            r[i] = difference;
+		        }
+		        for (; i < a_l; i++) {
+		            r[i] = a[i];
+		        }
+		        trim(r);
+		        return r;
+		    }
+
+		    function subtractAny(a, b, sign) {
+		        var value;
+		        if (compareAbs(a, b) >= 0) {
+		            value = subtract(a, b);
+		        } else {
+		            value = subtract(b, a);
+		            sign = !sign;
+		        }
+		        value = arrayToSmall(value);
+		        if (typeof value === "number") {
+		            if (sign) value = -value;
+		            return new SmallInteger(value);
+		        }
+		        return new BigInteger(value, sign);
+		    }
+
+		    function subtractSmall(a, b, sign) { // assumes a is array, b is number with 0 <= b < MAX_INT
+		        var l = a.length,
+		            r = new Array(l),
+		            carry = -b,
+		            base = BASE,
+		            i, difference;
+		        for (i = 0; i < l; i++) {
+		            difference = a[i] + carry;
+		            carry = Math.floor(difference / base);
+		            difference %= base;
+		            r[i] = difference < 0 ? difference + base : difference;
+		        }
+		        r = arrayToSmall(r);
+		        if (typeof r === "number") {
+		            if (sign) r = -r;
+		            return new SmallInteger(r);
+		        } return new BigInteger(r, sign);
+		    }
+
+		    BigInteger.prototype.subtract = function (v) {
+		        var n = parseValue(v);
+		        if (this.sign !== n.sign) {
+		            return this.add(n.negate());
+		        }
+		        var a = this.value, b = n.value;
+		        if (n.isSmall)
+		            return subtractSmall(a, Math.abs(b), this.sign);
+		        return subtractAny(a, b, this.sign);
+		    };
+		    BigInteger.prototype.minus = BigInteger.prototype.subtract;
+
+		    SmallInteger.prototype.subtract = function (v) {
+		        var n = parseValue(v);
+		        var a = this.value;
+		        if (a < 0 !== n.sign) {
+		            return this.add(n.negate());
+		        }
+		        var b = n.value;
+		        if (n.isSmall) {
+		            return new SmallInteger(a - b);
+		        }
+		        return subtractSmall(b, Math.abs(a), a >= 0);
+		    };
+		    SmallInteger.prototype.minus = SmallInteger.prototype.subtract;
+
+		    BigInteger.prototype.negate = function () {
+		        return new BigInteger(this.value, !this.sign);
+		    };
+		    SmallInteger.prototype.negate = function () {
+		        var sign = this.sign;
+		        var small = new SmallInteger(-this.value);
+		        small.sign = !sign;
+		        return small;
+		    };
+
+		    BigInteger.prototype.abs = function () {
+		        return new BigInteger(this.value, false);
+		    };
+		    SmallInteger.prototype.abs = function () {
+		        return new SmallInteger(Math.abs(this.value));
+		    };
+
+		    function multiplyLong(a, b) {
+		        var a_l = a.length,
+		            b_l = b.length,
+		            l = a_l + b_l,
+		            r = createArray(l),
+		            base = BASE,
+		            product, carry, i, a_i, b_j;
+		        for (i = 0; i < a_l; ++i) {
+		            a_i = a[i];
+		            for (var j = 0; j < b_l; ++j) {
+		                b_j = b[j];
+		                product = a_i * b_j + r[i + j];
+		                carry = Math.floor(product / base);
+		                r[i + j] = product - carry * base;
+		                r[i + j + 1] += carry;
+		            }
+		        }
+		        trim(r);
+		        return r;
+		    }
+
+		    function multiplySmall(a, b) { // assumes a is array, b is number with |b| < BASE
+		        var l = a.length,
+		            r = new Array(l),
+		            base = BASE,
+		            carry = 0,
+		            product, i;
+		        for (i = 0; i < l; i++) {
+		            product = a[i] * b + carry;
+		            carry = Math.floor(product / base);
+		            r[i] = product - carry * base;
+		        }
+		        while (carry > 0) {
+		            r[i++] = carry % base;
+		            carry = Math.floor(carry / base);
+		        }
+		        return r;
+		    }
+
+		    function shiftLeft(x, n) {
+		        var r = [];
+		        while (n-- > 0) r.push(0);
+		        return r.concat(x);
+		    }
+
+		    function multiplyKaratsuba(x, y) {
+		        var n = Math.max(x.length, y.length);
+
+		        if (n <= 30) return multiplyLong(x, y);
+		        n = Math.ceil(n / 2);
+
+		        var b = x.slice(n),
+		            a = x.slice(0, n),
+		            d = y.slice(n),
+		            c = y.slice(0, n);
+
+		        var ac = multiplyKaratsuba(a, c),
+		            bd = multiplyKaratsuba(b, d),
+		            abcd = multiplyKaratsuba(addAny(a, b), addAny(c, d));
+
+		        var product = addAny(addAny(ac, shiftLeft(subtract(subtract(abcd, ac), bd), n)), shiftLeft(bd, 2 * n));
+		        trim(product);
+		        return product;
+		    }
+
+		    // The following function is derived from a surface fit of a graph plotting the performance difference
+		    // between long multiplication and karatsuba multiplication versus the lengths of the two arrays.
+		    function useKaratsuba(l1, l2) {
+		        return -0.012 * l1 - 0.012 * l2 + 0.000015 * l1 * l2 > 0;
+		    }
+
+		    BigInteger.prototype.multiply = function (v) {
+		        var n = parseValue(v),
+		            a = this.value, b = n.value,
+		            sign = this.sign !== n.sign,
+		            abs;
+		        if (n.isSmall) {
+		            if (b === 0) return Integer[0];
+		            if (b === 1) return this;
+		            if (b === -1) return this.negate();
+		            abs = Math.abs(b);
+		            if (abs < BASE) {
+		                return new BigInteger(multiplySmall(a, abs), sign);
+		            }
+		            b = smallToArray(abs);
+		        }
+		        if (useKaratsuba(a.length, b.length)) // Karatsuba is only faster for certain array sizes
+		            return new BigInteger(multiplyKaratsuba(a, b), sign);
+		        return new BigInteger(multiplyLong(a, b), sign);
+		    };
+
+		    BigInteger.prototype.times = BigInteger.prototype.multiply;
+
+		    function multiplySmallAndArray(a, b, sign) { // a >= 0
+		        if (a < BASE) {
+		            return new BigInteger(multiplySmall(b, a), sign);
+		        }
+		        return new BigInteger(multiplyLong(b, smallToArray(a)), sign);
+		    }
+		    SmallInteger.prototype._multiplyBySmall = function (a) {
+		        if (isPrecise(a.value * this.value)) {
+		            return new SmallInteger(a.value * this.value);
+		        }
+		        return multiplySmallAndArray(Math.abs(a.value), smallToArray(Math.abs(this.value)), this.sign !== a.sign);
+		    };
+		    BigInteger.prototype._multiplyBySmall = function (a) {
+		        if (a.value === 0) return Integer[0];
+		        if (a.value === 1) return this;
+		        if (a.value === -1) return this.negate();
+		        return multiplySmallAndArray(Math.abs(a.value), this.value, this.sign !== a.sign);
+		    };
+		    SmallInteger.prototype.multiply = function (v) {
+		        return parseValue(v)._multiplyBySmall(this);
+		    };
+		    SmallInteger.prototype.times = SmallInteger.prototype.multiply;
+
+		    function square(a) {
+		        //console.assert(2 * BASE * BASE < MAX_INT);
+		        var l = a.length,
+		            r = createArray(l + l),
+		            base = BASE,
+		            product, carry, i, a_i, a_j;
+		        for (i = 0; i < l; i++) {
+		            a_i = a[i];
+		            carry = 0 - a_i * a_i;
+		            for (var j = i; j < l; j++) {
+		                a_j = a[j];
+		                product = 2 * (a_i * a_j) + r[i + j] + carry;
+		                carry = Math.floor(product / base);
+		                r[i + j] = product - carry * base;
+		            }
+		            r[i + l] = carry;
+		        }
+		        trim(r);
+		        return r;
+		    }
+
+		    BigInteger.prototype.square = function () {
+		        return new BigInteger(square(this.value), false);
+		    };
+
+		    SmallInteger.prototype.square = function () {
+		        var value = this.value * this.value;
+		        if (isPrecise(value)) return new SmallInteger(value);
+		        return new BigInteger(square(smallToArray(Math.abs(this.value))), false);
+		    };
+
+		    function divMod1(a, b) { // Left over from previous version. Performs faster than divMod2 on smaller input sizes.
+		        var a_l = a.length,
+		            b_l = b.length,
+		            base = BASE,
+		            result = createArray(b.length),
+		            divisorMostSignificantDigit = b[b_l - 1],
+		            // normalization
+		            lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)),
+		            remainder = multiplySmall(a, lambda),
+		            divisor = multiplySmall(b, lambda),
+		            quotientDigit, shift, carry, borrow, i, l, q;
+		        if (remainder.length <= a_l) remainder.push(0);
+		        divisor.push(0);
+		        divisorMostSignificantDigit = divisor[b_l - 1];
+		        for (shift = a_l - b_l; shift >= 0; shift--) {
+		            quotientDigit = base - 1;
+		            if (remainder[shift + b_l] !== divisorMostSignificantDigit) {
+		                quotientDigit = Math.floor((remainder[shift + b_l] * base + remainder[shift + b_l - 1]) / divisorMostSignificantDigit);
+		            }
+		            // quotientDigit <= base - 1
+		            carry = 0;
+		            borrow = 0;
+		            l = divisor.length;
+		            for (i = 0; i < l; i++) {
+		                carry += quotientDigit * divisor[i];
+		                q = Math.floor(carry / base);
+		                borrow += remainder[shift + i] - (carry - q * base);
+		                carry = q;
+		                if (borrow < 0) {
+		                    remainder[shift + i] = borrow + base;
+		                    borrow = -1;
+		                } else {
+		                    remainder[shift + i] = borrow;
+		                    borrow = 0;
+		                }
+		            }
+		            while (borrow !== 0) {
+		                quotientDigit -= 1;
+		                carry = 0;
+		                for (i = 0; i < l; i++) {
+		                    carry += remainder[shift + i] - base + divisor[i];
+		                    if (carry < 0) {
+		                        remainder[shift + i] = carry + base;
+		                        carry = 0;
+		                    } else {
+		                        remainder[shift + i] = carry;
+		                        carry = 1;
+		                    }
+		                }
+		                borrow += carry;
+		            }
+		            result[shift] = quotientDigit;
+		        }
+		        // denormalization
+		        remainder = divModSmall(remainder, lambda)[0];
+		        return [arrayToSmall(result), arrayToSmall(remainder)];
+		    }
+
+		    function divMod2(a, b) { // Implementation idea shamelessly stolen from Silent Matt's library http://silentmatt.com/biginteger/
+		        // Performs faster than divMod1 on larger input sizes.
+		        var a_l = a.length,
+		            b_l = b.length,
+		            result = [],
+		            part = [],
+		            base = BASE,
+		            guess, xlen, highx, highy, check;
+		        while (a_l) {
+		            part.unshift(a[--a_l]);
+		            trim(part);
+		            if (compareAbs(part, b) < 0) {
+		                result.push(0);
+		                continue;
+		            }
+		            xlen = part.length;
+		            highx = part[xlen - 1] * base + part[xlen - 2];
+		            highy = b[b_l - 1] * base + b[b_l - 2];
+		            if (xlen > b_l) {
+		                highx = (highx + 1) * base;
+		            }
+		            guess = Math.ceil(highx / highy);
+		            do {
+		                check = multiplySmall(b, guess);
+		                if (compareAbs(check, part) <= 0) break;
+		                guess--;
+		            } while (guess);
+		            result.push(guess);
+		            part = subtract(part, check);
+		        }
+		        result.reverse();
+		        return [arrayToSmall(result), arrayToSmall(part)];
+		    }
+
+		    function divModSmall(value, lambda) {
+		        var length = value.length,
+		            quotient = createArray(length),
+		            base = BASE,
+		            i, q, remainder, divisor;
+		        remainder = 0;
+		        for (i = length - 1; i >= 0; --i) {
+		            divisor = remainder * base + value[i];
+		            q = truncate(divisor / lambda);
+		            remainder = divisor - q * lambda;
+		            quotient[i] = q | 0;
+		        }
+		        return [quotient, remainder | 0];
+		    }
+
+		    function divModAny(self, v) {
+		        var value, n = parseValue(v);
+		        var a = self.value, b = n.value;
+		        var quotient;
+		        if (b === 0) throw new Error("Cannot divide by zero");
+		        if (self.isSmall) {
+		            if (n.isSmall) {
+		                return [new SmallInteger(truncate(a / b)), new SmallInteger(a % b)];
+		            }
+		            return [Integer[0], self];
+		        }
+		        if (n.isSmall) {
+		            if (b === 1) return [self, Integer[0]];
+		            if (b == -1) return [self.negate(), Integer[0]];
+		            var abs = Math.abs(b);
+		            if (abs < BASE) {
+		                value = divModSmall(a, abs);
+		                quotient = arrayToSmall(value[0]);
+		                var remainder = value[1];
+		                if (self.sign) remainder = -remainder;
+		                if (typeof quotient === "number") {
+		                    if (self.sign !== n.sign) quotient = -quotient;
+		                    return [new SmallInteger(quotient), new SmallInteger(remainder)];
+		                }
+		                return [new BigInteger(quotient, self.sign !== n.sign), new SmallInteger(remainder)];
+		            }
+		            b = smallToArray(abs);
+		        }
+		        var comparison = compareAbs(a, b);
+		        if (comparison === -1) return [Integer[0], self];
+		        if (comparison === 0) return [Integer[self.sign === n.sign ? 1 : -1], Integer[0]];
+
+		        // divMod1 is faster on smaller input sizes
+		        if (a.length + b.length <= 200)
+		            value = divMod1(a, b);
+		        else value = divMod2(a, b);
+
+		        quotient = value[0];
+		        var qSign = self.sign !== n.sign,
+		            mod = value[1],
+		            mSign = self.sign;
+		        if (typeof quotient === "number") {
+		            if (qSign) quotient = -quotient;
+		            quotient = new SmallInteger(quotient);
+		        } else quotient = new BigInteger(quotient, qSign);
+		        if (typeof mod === "number") {
+		            if (mSign) mod = -mod;
+		            mod = new SmallInteger(mod);
+		        } else mod = new BigInteger(mod, mSign);
+		        return [quotient, mod];
+		    }
+
+		    BigInteger.prototype.divmod = function (v) {
+		        var result = divModAny(this, v);
+		        return {
+		            quotient: result[0],
+		            remainder: result[1]
+		        };
+		    };
+		    SmallInteger.prototype.divmod = BigInteger.prototype.divmod;
+
+		    BigInteger.prototype.divide = function (v) {
+		        return divModAny(this, v)[0];
+		    };
+		    SmallInteger.prototype.over = SmallInteger.prototype.divide = BigInteger.prototype.over = BigInteger.prototype.divide;
+
+		    BigInteger.prototype.mod = function (v) {
+		        return divModAny(this, v)[1];
+		    };
+		    SmallInteger.prototype.remainder = SmallInteger.prototype.mod = BigInteger.prototype.remainder = BigInteger.prototype.mod;
+
+		    BigInteger.prototype.pow = function (v) {
+		        var n = parseValue(v),
+		            a = this.value,
+		            b = n.value,
+		            value, x, y;
+		        if (b === 0) return Integer[1];
+		        if (a === 0) return Integer[0];
+		        if (a === 1) return Integer[1];
+		        if (a === -1) return n.isEven() ? Integer[1] : Integer[-1];
+		        if (n.sign) {
+		            return Integer[0];
+		        }
+		        if (!n.isSmall) throw new Error("The exponent " + n.toString() + " is too large.");
+		        if (this.isSmall) {
+		            if (isPrecise(value = Math.pow(a, b)))
+		                return new SmallInteger(truncate(value));
+		        }
+		        x = this;
+		        y = Integer[1];
+		        while (true) {
+		            if (b & 1 === 1) {
+		                y = y.times(x);
+		                --b;
+		            }
+		            if (b === 0) break;
+		            b /= 2;
+		            x = x.square();
+		        }
+		        return y;
+		    };
+		    SmallInteger.prototype.pow = BigInteger.prototype.pow;
+
+		    BigInteger.prototype.modPow = function (exp, mod) {
+		        exp = parseValue(exp);
+		        mod = parseValue(mod);
+		        if (mod.isZero()) throw new Error("Cannot take modPow with modulus 0");
+		        var r = Integer[1],
+		            base = this.mod(mod);
+		        while (exp.isPositive()) {
+		            if (base.isZero()) return Integer[0];
+		            if (exp.isOdd()) r = r.multiply(base).mod(mod);
+		            exp = exp.divide(2);
+		            base = base.square().mod(mod);
+		        }
+		        return r;
+		    };
+		    SmallInteger.prototype.modPow = BigInteger.prototype.modPow;
+
+		    function compareAbs(a, b) {
+		        if (a.length !== b.length) {
+		            return a.length > b.length ? 1 : -1;
+		        }
+		        for (var i = a.length - 1; i >= 0; i--) {
+		            if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;
+		        }
+		        return 0;
+		    }
+
+		    BigInteger.prototype.compareAbs = function (v) {
+		        var n = parseValue(v),
+		            a = this.value,
+		            b = n.value;
+		        if (n.isSmall) return 1;
+		        return compareAbs(a, b);
+		    };
+		    SmallInteger.prototype.compareAbs = function (v) {
+		        var n = parseValue(v),
+		            a = Math.abs(this.value),
+		            b = n.value;
+		        if (n.isSmall) {
+		            b = Math.abs(b);
+		            return a === b ? 0 : a > b ? 1 : -1;
+		        }
+		        return -1;
+		    };
+
+		    BigInteger.prototype.compare = function (v) {
+		        // See discussion about comparison with Infinity:
+		        // https://github.com/peterolson/BigInteger.js/issues/61
+		        if (v === Infinity) {
+		            return -1;
+		        }
+		        if (v === -Infinity) {
+		            return 1;
+		        }
+
+		        var n = parseValue(v),
+		            a = this.value,
+		            b = n.value;
+		        if (this.sign !== n.sign) {
+		            return n.sign ? 1 : -1;
+		        }
+		        if (n.isSmall) {
+		            return this.sign ? -1 : 1;
+		        }
+		        return compareAbs(a, b) * (this.sign ? -1 : 1);
+		    };
+		    BigInteger.prototype.compareTo = BigInteger.prototype.compare;
+
+		    SmallInteger.prototype.compare = function (v) {
+		        if (v === Infinity) {
+		            return -1;
+		        }
+		        if (v === -Infinity) {
+		            return 1;
+		        }
+
+		        var n = parseValue(v),
+		            a = this.value,
+		            b = n.value;
+		        if (n.isSmall) {
+		            return a == b ? 0 : a > b ? 1 : -1;
+		        }
+		        if (a < 0 !== n.sign) {
+		            return a < 0 ? -1 : 1;
+		        }
+		        return a < 0 ? 1 : -1;
+		    };
+		    SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;
+
+		    BigInteger.prototype.equals = function (v) {
+		        return this.compare(v) === 0;
+		    };
+		    SmallInteger.prototype.eq = SmallInteger.prototype.equals = BigInteger.prototype.eq = BigInteger.prototype.equals;
+
+		    BigInteger.prototype.notEquals = function (v) {
+		        return this.compare(v) !== 0;
+		    };
+		    SmallInteger.prototype.neq = SmallInteger.prototype.notEquals = BigInteger.prototype.neq = BigInteger.prototype.notEquals;
+
+		    BigInteger.prototype.greater = function (v) {
+		        return this.compare(v) > 0;
+		    };
+		    SmallInteger.prototype.gt = SmallInteger.prototype.greater = BigInteger.prototype.gt = BigInteger.prototype.greater;
+
+		    BigInteger.prototype.lesser = function (v) {
+		        return this.compare(v) < 0;
+		    };
+		    SmallInteger.prototype.lt = SmallInteger.prototype.lesser = BigInteger.prototype.lt = BigInteger.prototype.lesser;
+
+		    BigInteger.prototype.greaterOrEquals = function (v) {
+		        return this.compare(v) >= 0;
+		    };
+		    SmallInteger.prototype.geq = SmallInteger.prototype.greaterOrEquals = BigInteger.prototype.geq = BigInteger.prototype.greaterOrEquals;
+
+		    BigInteger.prototype.lesserOrEquals = function (v) {
+		        return this.compare(v) <= 0;
+		    };
+		    SmallInteger.prototype.leq = SmallInteger.prototype.lesserOrEquals = BigInteger.prototype.leq = BigInteger.prototype.lesserOrEquals;
+
+		    BigInteger.prototype.isEven = function () {
+		        return (this.value[0] & 1) === 0;
+		    };
+		    SmallInteger.prototype.isEven = function () {
+		        return (this.value & 1) === 0;
+		    };
+
+		    BigInteger.prototype.isOdd = function () {
+		        return (this.value[0] & 1) === 1;
+		    };
+		    SmallInteger.prototype.isOdd = function () {
+		        return (this.value & 1) === 1;
+		    };
+
+		    BigInteger.prototype.isPositive = function () {
+		        return !this.sign;
+		    };
+		    SmallInteger.prototype.isPositive = function () {
+		        return this.value > 0;
+		    };
+
+		    BigInteger.prototype.isNegative = function () {
+		        return this.sign;
+		    };
+		    SmallInteger.prototype.isNegative = function () {
+		        return this.value < 0;
+		    };
+
+		    BigInteger.prototype.isUnit = function () {
+		        return false;
+		    };
+		    SmallInteger.prototype.isUnit = function () {
+		        return Math.abs(this.value) === 1;
+		    };
+
+		    BigInteger.prototype.isZero = function () {
+		        return false;
+		    };
+		    SmallInteger.prototype.isZero = function () {
+		        return this.value === 0;
+		    };
+		    BigInteger.prototype.isDivisibleBy = function (v) {
+		        var n = parseValue(v);
+		        var value = n.value;
+		        if (value === 0) return false;
+		        if (value === 1) return true;
+		        if (value === 2) return this.isEven();
+		        return this.mod(n).equals(Integer[0]);
+		    };
+		    SmallInteger.prototype.isDivisibleBy = BigInteger.prototype.isDivisibleBy;
+
+		    function isBasicPrime(v) {
+		        var n = v.abs();
+		        if (n.isUnit()) return false;
+		        if (n.equals(2) || n.equals(3) || n.equals(5)) return true;
+		        if (n.isEven() || n.isDivisibleBy(3) || n.isDivisibleBy(5)) return false;
+		        if (n.lesser(49)) return true;
+		        // we don't know if it's prime: let the other functions figure it out
+		    }
+		    
+		    function millerRabinTest(n, a) {
+		        var nPrev = n.prev(),
+		            b = nPrev,
+		            r = 0,
+		            d, i, x;
+		        while (b.isEven()) b = b.divide(2), r++;
+		        next : for (i = 0; i < a.length; i++) {
+		            if (n.lesser(a[i])) continue;
+		            x = bigInt(a[i]).modPow(b, n);
+		            if (x.equals(Integer[1]) || x.equals(nPrev)) continue;
+		            for (d = r - 1; d != 0; d--) {
+		                x = x.square().mod(n);
+		                if (x.isUnit()) return false;    
+		                if (x.equals(nPrev)) continue next;
+		            }
+		            return false;
+		        }
+		        return true;
+		    }
+		    
+		// Set "strict" to true to force GRH-supported lower bound of 2*log(N)^2
+		    BigInteger.prototype.isPrime = function (strict) {
+		        var isPrime = isBasicPrime(this);
+		        if (isPrime !== undefined$1) return isPrime;
+		        var n = this.abs();
+		        var bits = n.bitLength();
+		        if(bits <= 64)
+		            return millerRabinTest(n, [2, 325, 9375, 28178, 450775, 9780504, 1795265022]);
+		        var logN = Math.log(2) * bits;
+		        var t = Math.ceil((strict === true) ? (2 * Math.pow(logN, 2)) : logN);
+		        for (var a = [], i = 0; i < t; i++) {
+		            a.push(bigInt(i + 2));
+		        }
+		        return millerRabinTest(n, a);
+		    };
+		    SmallInteger.prototype.isPrime = BigInteger.prototype.isPrime;
+
+		    BigInteger.prototype.isProbablePrime = function (iterations) {
+		        var isPrime = isBasicPrime(this);
+		        if (isPrime !== undefined$1) return isPrime;
+		        var n = this.abs();
+		        var t = iterations === undefined$1 ? 5 : iterations;
+		        for (var a = [], i = 0; i < t; i++) {
+		            a.push(bigInt.randBetween(2, n.minus(2)));
+		        }
+		        return millerRabinTest(n, a);
+		    };
+		    SmallInteger.prototype.isProbablePrime = BigInteger.prototype.isProbablePrime;
+
+		    BigInteger.prototype.modInv = function (n) {
+		        var t = bigInt.zero, newT = bigInt.one, r = parseValue(n), newR = this.abs(), q, lastT, lastR;
+		        while (!newR.equals(bigInt.zero)) {
+		            q = r.divide(newR);
+		            lastT = t;
+		            lastR = r;
+		            t = newT;
+		            r = newR;
+		            newT = lastT.subtract(q.multiply(newT));
+		            newR = lastR.subtract(q.multiply(newR));
+		        }
+		        if (!r.equals(1)) throw new Error(this.toString() + " and " + n.toString() + " are not co-prime");
+		        if (t.compare(0) === -1) {
+		            t = t.add(n);
+		        }
+		        if (this.isNegative()) {
+		            return t.negate();
+		        }
+		        return t;
+		    };
+
+		    SmallInteger.prototype.modInv = BigInteger.prototype.modInv;
+
+		    BigInteger.prototype.next = function () {
+		        var value = this.value;
+		        if (this.sign) {
+		            return subtractSmall(value, 1, this.sign);
+		        }
+		        return new BigInteger(addSmall(value, 1), this.sign);
+		    };
+		    SmallInteger.prototype.next = function () {
+		        var value = this.value;
+		        if (value + 1 < MAX_INT) return new SmallInteger(value + 1);
+		        return new BigInteger(MAX_INT_ARR, false);
+		    };
+
+		    BigInteger.prototype.prev = function () {
+		        var value = this.value;
+		        if (this.sign) {
+		            return new BigInteger(addSmall(value, 1), true);
+		        }
+		        return subtractSmall(value, 1, this.sign);
+		    };
+		    SmallInteger.prototype.prev = function () {
+		        var value = this.value;
+		        if (value - 1 > -MAX_INT) return new SmallInteger(value - 1);
+		        return new BigInteger(MAX_INT_ARR, true);
+		    };
+
+		    var powersOfTwo = [1];
+		    while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE) powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);
+		    var powers2Length = powersOfTwo.length, highestPower2 = powersOfTwo[powers2Length - 1];
+
+		    function shift_isSmall(n) {
+		        return ((typeof n === "number" || typeof n === "string") && +Math.abs(n) <= BASE) ||
+		            (n instanceof BigInteger && n.value.length <= 1);
+		    }
+
+		    BigInteger.prototype.shiftLeft = function (n) {
+		        if (!shift_isSmall(n)) {
+		            throw new Error(String(n) + " is too large for shifting.");
+		        }
+		        n = +n;
+		        if (n < 0) return this.shiftRight(-n);
+		        var result = this;
+		        if (result.isZero()) return result;
+		        while (n >= powers2Length) {
+		            result = result.multiply(highestPower2);
+		            n -= powers2Length - 1;
+		        }
+		        return result.multiply(powersOfTwo[n]);
+		    };
+		    SmallInteger.prototype.shiftLeft = BigInteger.prototype.shiftLeft;
+
+		    BigInteger.prototype.shiftRight = function (n) {
+		        var remQuo;
+		        if (!shift_isSmall(n)) {
+		            throw new Error(String(n) + " is too large for shifting.");
+		        }
+		        n = +n;
+		        if (n < 0) return this.shiftLeft(-n);
+		        var result = this;
+		        while (n >= powers2Length) {
+		            if (result.isZero() || (result.isNegative() && result.isUnit())) return result;
+		            remQuo = divModAny(result, highestPower2);
+		            result = remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];
+		            n -= powers2Length - 1;
+		        }
+		        remQuo = divModAny(result, powersOfTwo[n]);
+		        return remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];
+		    };
+		    SmallInteger.prototype.shiftRight = BigInteger.prototype.shiftRight;
+
+		    function bitwise(x, y, fn) {
+		        y = parseValue(y);
+		        var xSign = x.isNegative(), ySign = y.isNegative();
+		        var xRem = xSign ? x.not() : x,
+		            yRem = ySign ? y.not() : y;
+		        var xDigit = 0, yDigit = 0;
+		        var xDivMod = null, yDivMod = null;
+		        var result = [];
+		        while (!xRem.isZero() || !yRem.isZero()) {
+		            xDivMod = divModAny(xRem, highestPower2);
+		            xDigit = xDivMod[1].toJSNumber();
+		            if (xSign) {
+		                xDigit = highestPower2 - 1 - xDigit; // two's complement for negative numbers
+		            }
+
+		            yDivMod = divModAny(yRem, highestPower2);
+		            yDigit = yDivMod[1].toJSNumber();
+		            if (ySign) {
+		                yDigit = highestPower2 - 1 - yDigit; // two's complement for negative numbers
+		            }
+
+		            xRem = xDivMod[0];
+		            yRem = yDivMod[0];
+		            result.push(fn(xDigit, yDigit));
+		        }
+		        var sum = fn(xSign ? 1 : 0, ySign ? 1 : 0) !== 0 ? bigInt(-1) : bigInt(0);
+		        for (var i = result.length - 1; i >= 0; i -= 1) {
+		            sum = sum.multiply(highestPower2).add(bigInt(result[i]));
+		        }
+		        return sum;
+		    }
+
+		    BigInteger.prototype.not = function () {
+		        return this.negate().prev();
+		    };
+		    SmallInteger.prototype.not = BigInteger.prototype.not;
+
+		    BigInteger.prototype.and = function (n) {
+		        return bitwise(this, n, function (a, b) { return a & b; });
+		    };
+		    SmallInteger.prototype.and = BigInteger.prototype.and;
+
+		    BigInteger.prototype.or = function (n) {
+		        return bitwise(this, n, function (a, b) { return a | b; });
+		    };
+		    SmallInteger.prototype.or = BigInteger.prototype.or;
+
+		    BigInteger.prototype.xor = function (n) {
+		        return bitwise(this, n, function (a, b) { return a ^ b; });
+		    };
+		    SmallInteger.prototype.xor = BigInteger.prototype.xor;
+
+		    var LOBMASK_I = 1 << 30, LOBMASK_BI = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I;
+		    function roughLOB(n) { // get lowestOneBit (rough)
+		        // SmallInteger: return Min(lowestOneBit(n), 1 << 30)
+		        // BigInteger: return Min(lowestOneBit(n), 1 << 14) [BASE=1e7]
+		        var v = n.value, x = typeof v === "number" ? v | LOBMASK_I : v[0] + v[1] * BASE | LOBMASK_BI;
+		        return x & -x;
+		    }
+
+		    function integerLogarithm(value, base) {
+		        if (base.compareTo(value) <= 0) {
+		            var tmp = integerLogarithm(value, base.square(base));
+		            var p = tmp.p;
+		            var e = tmp.e;
+		            var t = p.multiply(base);
+		            return t.compareTo(value) <= 0 ? { p: t, e: e * 2 + 1 } : { p: p, e: e * 2 };
+		        }
+		        return { p: bigInt(1), e: 0 };
+		    }
+
+		    BigInteger.prototype.bitLength = function () {
+		        var n = this;
+		        if (n.compareTo(bigInt(0)) < 0) {
+		            n = n.negate().subtract(bigInt(1));
+		        }
+		        if (n.compareTo(bigInt(0)) === 0) {
+		            return bigInt(0);
+		        }
+		        return bigInt(integerLogarithm(n, bigInt(2)).e).add(bigInt(1));
+		    };
+		    SmallInteger.prototype.bitLength = BigInteger.prototype.bitLength;
+
+		    function max(a, b) {
+		        a = parseValue(a);
+		        b = parseValue(b);
+		        return a.greater(b) ? a : b;
+		    }
+		    function min(a, b) {
+		        a = parseValue(a);
+		        b = parseValue(b);
+		        return a.lesser(b) ? a : b;
+		    }
+		    function gcd(a, b) {
+		        a = parseValue(a).abs();
+		        b = parseValue(b).abs();
+		        if (a.equals(b)) return a;
+		        if (a.isZero()) return b;
+		        if (b.isZero()) return a;
+		        var c = Integer[1], d, t;
+		        while (a.isEven() && b.isEven()) {
+		            d = Math.min(roughLOB(a), roughLOB(b));
+		            a = a.divide(d);
+		            b = b.divide(d);
+		            c = c.multiply(d);
+		        }
+		        while (a.isEven()) {
+		            a = a.divide(roughLOB(a));
+		        }
+		        do {
+		            while (b.isEven()) {
+		                b = b.divide(roughLOB(b));
+		            }
+		            if (a.greater(b)) {
+		                t = b; b = a; a = t;
+		            }
+		            b = b.subtract(a);
+		        } while (!b.isZero());
+		        return c.isUnit() ? a : a.multiply(c);
+		    }
+		    function lcm(a, b) {
+		        a = parseValue(a).abs();
+		        b = parseValue(b).abs();
+		        return a.divide(gcd(a, b)).multiply(b);
+		    }
+		    function randBetween(a, b) {
+		        a = parseValue(a);
+		        b = parseValue(b);
+		        var low = min(a, b), high = max(a, b);
+		        var range = high.subtract(low).add(1);
+		        if (range.isSmall) return low.add(Math.floor(Math.random() * range));
+		        var length = range.value.length - 1;
+		        var result = [], restricted = true;
+		        for (var i = length; i >= 0; i--) {
+		            var top = restricted ? range.value[i] : BASE;
+		            var digit = truncate(Math.random() * top);
+		            result.unshift(digit);
+		            if (digit < top) restricted = false;
+		        }
+		        result = arrayToSmall(result);
+		        return low.add(typeof result === "number" ? new SmallInteger(result) : new BigInteger(result, false));
+		    }
+		    var parseBase = function (text, base) {
+		        var length = text.length;
+		        var i;
+		        var absBase = Math.abs(base);
+		        for (var i = 0; i < length; i++) {
+		            var c = text[i].toLowerCase();
+		            if (c === "-") continue;
+		            if (/[a-z0-9]/.test(c)) {
+		                if (/[0-9]/.test(c) && +c >= absBase) {
+		                    if (c === "1" && absBase === 1) continue;
+		                    throw new Error(c + " is not a valid digit in base " + base + ".");
+		                } else if (c.charCodeAt(0) - 87 >= absBase) {
+		                    throw new Error(c + " is not a valid digit in base " + base + ".");
+		                }
+		            }
+		        }
+		        if (2 <= base && base <= 36) {
+		            if (length <= LOG_MAX_INT / Math.log(base)) {
+		                var result = parseInt(text, base);
+		                if (isNaN(result)) {
+		                    throw new Error(c + " is not a valid digit in base " + base + ".");
+		                }
+		                return new SmallInteger(parseInt(text, base));
+		            }
+		        }
+		        base = parseValue(base);
+		        var digits = [];
+		        var isNegative = text[0] === "-";
+		        for (i = isNegative ? 1 : 0; i < text.length; i++) {
+		            var c = text[i].toLowerCase(),
+		                charCode = c.charCodeAt(0);
+		            if (48 <= charCode && charCode <= 57) digits.push(parseValue(c));
+		            else if (97 <= charCode && charCode <= 122) digits.push(parseValue(c.charCodeAt(0) - 87));
+		            else if (c === "<") {
+		                var start = i;
+		                do { i++; } while (text[i] !== ">");
+		                digits.push(parseValue(text.slice(start + 1, i)));
+		            }
+		            else throw new Error(c + " is not a valid character");
+		        }
+		        return parseBaseFromArray(digits, base, isNegative);
+		    };
+
+		    function parseBaseFromArray(digits, base, isNegative) {
+		        var val = Integer[0], pow = Integer[1], i;
+		        for (i = digits.length - 1; i >= 0; i--) {
+		            val = val.add(digits[i].times(pow));
+		            pow = pow.times(base);
+		        }
+		        return isNegative ? val.negate() : val;
+		    }
+
+		    function stringify(digit) {
+		        if (digit <= 35) {
+		            return "0123456789abcdefghijklmnopqrstuvwxyz".charAt(digit);
+		        }
+		        return "<" + digit + ">";
+		    }
+
+		    function toBase(n, base) {
+		        base = bigInt(base);
+		        if (base.isZero()) {
+		            if (n.isZero()) return { value: [0], isNegative: false };
+		            throw new Error("Cannot convert nonzero numbers to base 0.");
+		        }
+		        if (base.equals(-1)) {
+		            if (n.isZero()) return { value: [0], isNegative: false };
+		            if (n.isNegative())
+		                return {
+		                    value: [].concat.apply([], Array.apply(null, Array(-n))
+		                        .map(Array.prototype.valueOf, [1, 0])
+		                    ),
+		                    isNegative: false
+		                };
+
+		            var arr = Array.apply(null, Array(+n - 1))
+		                .map(Array.prototype.valueOf, [0, 1]);
+		            arr.unshift([1]);
+		            return {
+		                value: [].concat.apply([], arr),
+		                isNegative: false
+		            };
+		        }
+
+		        var neg = false;
+		        if (n.isNegative() && base.isPositive()) {
+		            neg = true;
+		            n = n.abs();
+		        }
+		        if (base.equals(1)) {
+		            if (n.isZero()) return { value: [0], isNegative: false };
+
+		            return {
+		                value: Array.apply(null, Array(+n))
+		                    .map(Number.prototype.valueOf, 1),
+		                isNegative: neg
+		            };
+		        }
+		        var out = [];
+		        var left = n, divmod;
+		        while (left.isNegative() || left.compareAbs(base) >= 0) {
+		            divmod = left.divmod(base);
+		            left = divmod.quotient;
+		            var digit = divmod.remainder;
+		            if (digit.isNegative()) {
+		                digit = base.minus(digit).abs();
+		                left = left.next();
+		            }
+		            out.push(digit.toJSNumber());
+		        }
+		        out.push(left.toJSNumber());
+		        return { value: out.reverse(), isNegative: neg };
+		    }
+
+		    function toBaseString(n, base) {
+		        var arr = toBase(n, base);
+		        return (arr.isNegative ? "-" : "") + arr.value.map(stringify).join('');
+		    }
+
+		    BigInteger.prototype.toArray = function (radix) {
+		        return toBase(this, radix);
+		    };
+
+		    SmallInteger.prototype.toArray = function (radix) {
+		        return toBase(this, radix);
+		    };
+
+		    BigInteger.prototype.toString = function (radix) {
+		        if (radix === undefined$1) radix = 10;
+		        if (radix !== 10) return toBaseString(this, radix);
+		        var v = this.value, l = v.length, str = String(v[--l]), zeros = "0000000", digit;
+		        while (--l >= 0) {
+		            digit = String(v[l]);
+		            str += zeros.slice(digit.length) + digit;
+		        }
+		        var sign = this.sign ? "-" : "";
+		        return sign + str;
+		    };
+
+		    SmallInteger.prototype.toString = function (radix) {
+		        if (radix === undefined$1) radix = 10;
+		        if (radix != 10) return toBaseString(this, radix);
+		        return String(this.value);
+		    };
+		    BigInteger.prototype.toJSON = SmallInteger.prototype.toJSON = function () { return this.toString(); };
+
+		    BigInteger.prototype.valueOf = function () {
+		        return parseInt(this.toString(), 10);
+		    };
+		    BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;
+
+		    SmallInteger.prototype.valueOf = function () {
+		        return this.value;
+		    };
+		    SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;
+
+		    function parseStringValue(v) {
+		        if (isPrecise(+v)) {
+		            var x = +v;
+		            if (x === truncate(x))
+		                return new SmallInteger(x);
+		            throw new Error("Invalid integer: " + v);
+		        }
+		        var sign = v[0] === "-";
+		        if (sign) v = v.slice(1);
+		        var split = v.split(/e/i);
+		        if (split.length > 2) throw new Error("Invalid integer: " + split.join("e"));
+		        if (split.length === 2) {
+		            var exp = split[1];
+		            if (exp[0] === "+") exp = exp.slice(1);
+		            exp = +exp;
+		            if (exp !== truncate(exp) || !isPrecise(exp)) throw new Error("Invalid integer: " + exp + " is not a valid exponent.");
+		            var text = split[0];
+		            var decimalPlace = text.indexOf(".");
+		            if (decimalPlace >= 0) {
+		                exp -= text.length - decimalPlace - 1;
+		                text = text.slice(0, decimalPlace) + text.slice(decimalPlace + 1);
+		            }
+		            if (exp < 0) throw new Error("Cannot include negative exponent part for integers");
+		            text += (new Array(exp + 1)).join("0");
+		            v = text;
+		        }
+		        var isValid = /^([0-9][0-9]*)$/.test(v);
+		        if (!isValid) throw new Error("Invalid integer: " + v);
+		        var r = [], max = v.length, l = LOG_BASE, min = max - l;
+		        while (max > 0) {
+		            r.push(+v.slice(min, max));
+		            min -= l;
+		            if (min < 0) min = 0;
+		            max -= l;
+		        }
+		        trim(r);
+		        return new BigInteger(r, sign);
+		    }
+
+		    function parseNumberValue(v) {
+		        if (isPrecise(v)) {
+		            if (v !== truncate(v)) throw new Error(v + " is not an integer.");
+		            return new SmallInteger(v);
+		        }
+		        return parseStringValue(v.toString());
+		    }
+
+		    function parseValue(v) {
+		        if (typeof v === "number") {
+		            return parseNumberValue(v);
+		        }
+		        if (typeof v === "string") {
+		            return parseStringValue(v);
+		        }
+		        return v;
+		    }
+		    // Pre-define numbers in range [-999,999]
+		    for (var i = 0; i < 1000; i++) {
+		        Integer[i] = new SmallInteger(i);
+		        if (i > 0) Integer[-i] = new SmallInteger(-i);
+		    }
+		    // Backwards compatibility
+		    Integer.one = Integer[1];
+		    Integer.zero = Integer[0];
+		    Integer.minusOne = Integer[-1];
+		    Integer.max = max;
+		    Integer.min = min;
+		    Integer.gcd = gcd;
+		    Integer.lcm = lcm;
+		    Integer.isInstance = function (x) { return x instanceof BigInteger || x instanceof SmallInteger; };
+		    Integer.randBetween = randBetween;
+
+		    Integer.fromArray = function (digits, base, isNegative) {
+		        return parseBaseFromArray(digits.map(parseValue), parseValue(base || 10), isNegative);
+		    };
+
+		    return Integer;
+		})();
+
+		// Node.js check
+		if (module.hasOwnProperty("exports")) {
+		    module.exports = bigInt;
+		}
+	} (BigInteger));
+	return BigInteger.exports;
+}
+
+var convertBits;
+var hasRequiredConvertBits;
+
+function requireConvertBits () {
+	if (hasRequiredConvertBits) return convertBits;
+	hasRequiredConvertBits = 1;
+
+	var validate = requireValidation().validate;
+
+	/**
+	 * Converts an array of integers made up of 'from' bits into an
+	 * array of integers made up of 'to' bits. The output array is
+	 * zero-padded if necessary, unless strict mode is true.
+	 * Throws a {@link ValidationError} if input is invalid.
+	 * Original by Pieter Wuille: https://github.com/sipa/bech32.
+	 *
+	 * @param {Uint8Array} data Array of integers made up of 'from' bits.
+	 * @param {number} from Length in bits of elements in the input array.
+	 * @param {number} to Length in bits of elements in the output array.
+	 * @param {bool} strictMode Require the conversion to be completed without padding.
+	 * @returns {Uint8Array}
+	 */
+	convertBits = function(data, from, to, strictMode) {
+	  var length = strictMode
+	    ? Math.floor(data.length * from / to)
+	    : Math.ceil(data.length * from / to);
+	  var mask = (1 << to) - 1;
+	  var result = new Uint8Array(length);
+	  var index = 0;
+	  var accumulator = 0;
+	  var bits = 0;
+	  for (var i = 0; i < data.length; ++i) {
+	    var value = data[i];
+	    validate(0 <= value && (value >> from) === 0, 'Invalid value: ' + value + '.');
+	    accumulator = (accumulator << from) | value;
+	    bits += from;
+	    while (bits >= to) {
+	      bits -= to;
+	      result[index] = (accumulator >> bits) & mask;
+	      ++index;
+	    }
+	  }
+	  if (!strictMode) {
+	    if (bits > 0) {
+	      result[index] = (accumulator << (to - bits)) & mask;
+	      ++index;
+	    }
+	  } else {
+	    validate(
+	      bits < from && ((accumulator << (to - bits)) & mask) === 0,
+	      'Input cannot be converted to ' + to + ' bits without padding, but strict mode was used.'
+	    );
+	  }
+	  return result;
+	};
+	return convertBits;
+}
+
+/**
+ * @license
+ * https://github.com/ealmansi/cashaddrjs
+ * Copyright (c) 2017-2020 Emilio Almansi
+ * Distributed under the MIT software license, see the accompanying
+ * file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+ */
+
+var cashaddr;
+var hasRequiredCashaddr;
+
+function requireCashaddr () {
+	if (hasRequiredCashaddr) return cashaddr;
+	hasRequiredCashaddr = 1;
+
+	var base32 = requireBase32();
+	var bigInt = requireBigInteger();
+	var convertBits = requireConvertBits();
+	var validation = requireValidation();
+	var validate = validation.validate;
+
+	/**
+	 * Encoding and decoding of the new Cash Address format for Bitcoin Cash. <br />
+	 * Compliant with the original cashaddr specification:
+	 * {@link https://github.com/bitcoincashorg/bitcoincash.org/blob/master/spec/cashaddr.md}
+	 * @module cashaddr
+	 */
+
+	/**
+	 * Encodes a hash from a given type into a Bitcoin Cash address with the given prefix.
+	 * 
+	 * @static
+	 * @param {string} prefix Network prefix. E.g.: 'bitcoincash'.
+	 * @param {string} type Type of address to generate. Either 'P2PKH' or 'P2SH'.
+	 * @param {Uint8Array} hash Hash to encode represented as an array of 8-bit integers.
+	 * @returns {string}
+	 * @throws {ValidationError}
+	 */
+	function encode(prefix, type, hash) {
+	  validate(typeof prefix === 'string' && isValidPrefix(prefix), 'Invalid prefix: ' + prefix + '.');
+	  validate(typeof type === 'string', 'Invalid type: ' + type + '.');
+	  validate(hash instanceof Uint8Array, 'Invalid hash: ' + hash + '.');
+	  var prefixData = concat(prefixToUint5Array(prefix), new Uint8Array(1));
+	  var versionByte = getTypeBits(type) + getHashSizeBits(hash);
+	  var payloadData = toUint5Array(concat(new Uint8Array([versionByte]), hash));
+	  var checksumData = concat(concat(prefixData, payloadData), new Uint8Array(8));
+	  var payload = concat(payloadData, checksumToUint5Array(polymod(checksumData)));
+	  return prefix + ':' + base32.encode(payload);
+	}
+
+	/**
+	 * Decodes the given address into its constituting prefix, type and hash. See [#encode()]{@link encode}.
+	 * 
+	 * @static
+	 * @param {string} address Address to decode. E.g.: 'bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a'.
+	 * @returns {object}
+	 * @throws {ValidationError}
+	 */
+	function decode(address) {
+	  validate(typeof address === 'string' && hasSingleCase(address), 'Invalid address: ' + address + '.');
+	  var pieces = address.toLowerCase().split(':');
+	  validate(pieces.length === 2, 'Missing prefix: ' + address + '.');
+	  var prefix = pieces[0];
+	  var payload = base32.decode(pieces[1]);
+	  validate(validChecksum(prefix, payload), 'Invalid checksum: ' + address + '.');
+	  var payloadData = fromUint5Array(payload.subarray(0, -8));
+	  var versionByte = payloadData[0];
+	  var hash = payloadData.subarray(1);
+	  validate(getHashSize(versionByte) === hash.length * 8, 'Invalid hash size: ' + address + '.');
+	  var type = getType(versionByte);
+	  return {
+	    prefix: prefix,
+	    type: type,
+	    hash: hash,
+	  };
+	}
+
+	/**
+	 * Error thrown when encoding or decoding fail due to invalid input.
+	 *
+	 * @constructor ValidationError
+	 * @param {string} message Error description.
+	 */
+	var ValidationError = validation.ValidationError;
+
+	/**
+	 * Valid address prefixes.
+	 *
+	 * @private
+	 */
+	var VALID_PREFIXES = ['bitcoincash', 'bchtest', 'bchreg'];
+
+	/**
+	 * Checks whether a string is a valid prefix; ie., it has a single letter case
+	 * and is one of 'bitcoincash', 'bchtest', or 'bchreg'.
+	 *
+	 * @private
+	 * @param {string} prefix 
+	 * @returns {boolean}
+	 */
+	function isValidPrefix(prefix) {
+	  return hasSingleCase(prefix) && VALID_PREFIXES.indexOf(prefix.toLowerCase()) !== -1;
+	}
+
+	/**
+	 * Derives an array from the given prefix to be used in the computation
+	 * of the address' checksum.
+	 *
+	 * @private
+	 * @param {string} prefix Network prefix. E.g.: 'bitcoincash'. 
+	 * @returns {Uint8Array}
+	 */
+	function prefixToUint5Array(prefix) {
+	  var result = new Uint8Array(prefix.length);
+	  for (var i = 0; i < prefix.length; ++i) {
+	    result[i] = prefix[i].charCodeAt(0) & 31;
+	  }
+	  return result;
+	}
+
+	/**
+	 * Returns an array representation of the given checksum to be encoded
+	 * within the address' payload.
+	 *
+	 * @private
+	 * @param {BigInteger} checksum Computed checksum.
+	 * @returns {Uint8Array}
+	 */
+	function checksumToUint5Array(checksum) {
+	  var result = new Uint8Array(8);
+	  for (var i = 0; i < 8; ++i) {
+	    result[7 - i] = checksum.and(31).toJSNumber();
+	    checksum = checksum.shiftRight(5);
+	  }
+	  return result;
+	}
+
+	/**
+	 * Returns the bit representation of the given type within the version
+	 * byte.
+	 *
+	 * @private
+	 * @param {string} type Address type. Either 'P2PKH' or 'P2SH'.
+	 * @returns {number}
+	 * @throws {ValidationError}
+	 */
+	function getTypeBits(type) {
+	  switch (type) {
+	  case 'P2PKH':
+	    return 0;
+	  case 'P2SH':
+	    return 8;
+	  default:
+	    throw new ValidationError('Invalid type: ' + type + '.');
+	  }
+	}
+
+	/**
+	 * Retrieves the address type from its bit representation within the
+	 * version byte.
+	 *
+	 * @private
+	 * @param {number} versionByte
+	 * @returns {string}
+	 * @throws {ValidationError}
+	 */
+	function getType(versionByte) {
+	  switch (versionByte & 120) {
+	  case 0:
+	    return 'P2PKH';
+	  case 8:
+	    return 'P2SH';
+	  default:
+	    throw new ValidationError('Invalid address type in version byte: ' + versionByte + '.');
+	  }
+	}
+
+	/**
+	 * Returns the bit representation of the length in bits of the given
+	 * hash within the version byte.
+	 *
+	 * @private
+	 * @param {Uint8Array} hash Hash to encode represented as an array of 8-bit integers.
+	 * @returns {number}
+	 * @throws {ValidationError}
+	 */
+	function getHashSizeBits(hash) {
+	  switch (hash.length * 8) {
+	  case 160:
+	    return 0;
+	  case 192:
+	    return 1;
+	  case 224:
+	    return 2;
+	  case 256:
+	    return 3;
+	  case 320:
+	    return 4;
+	  case 384:
+	    return 5;
+	  case 448:
+	    return 6;
+	  case 512:
+	    return 7;
+	  default:
+	    throw new ValidationError('Invalid hash size: ' + hash.length + '.');
+	  }
+	}
+
+	/**
+	 * Retrieves the the length in bits of the encoded hash from its bit
+	 * representation within the version byte.
+	 *
+	 * @private
+	 * @param {number} versionByte
+	 * @returns {number}
+	 */
+	function getHashSize(versionByte) {
+	  switch (versionByte & 7) {
+	  case 0:
+	    return 160;
+	  case 1:
+	    return 192;
+	  case 2:
+	    return 224;
+	  case 3:
+	    return 256;
+	  case 4:
+	    return 320;
+	  case 5:
+	    return 384;
+	  case 6:
+	    return 448;
+	  case 7:
+	    return 512;
+	  }
+	}
+
+	/**
+	 * Converts an array of 8-bit integers into an array of 5-bit integers,
+	 * right-padding with zeroes if necessary.
+	 *
+	 * @private
+	 * @param {Uint8Array} data
+	 * @returns {Uint8Array}
+	 */
+	function toUint5Array(data) {
+	  return convertBits(data, 8, 5);
+	}
+
+	/**
+	 * Converts an array of 5-bit integers back into an array of 8-bit integers,
+	 * removing extra zeroes left from padding if necessary.
+	 * Throws a {@link ValidationError} if input is not a zero-padded array of 8-bit integers.
+	 *
+	 * @private
+	 * @param {Uint8Array} data
+	 * @returns {Uint8Array}
+	 * @throws {ValidationError}
+	 */
+	function fromUint5Array(data) {
+	  return convertBits(data, 5, 8, true);
+	}
+
+	/**
+	 * Returns the concatenation a and b.
+	 *
+	 * @private
+	 * @param {Uint8Array} a 
+	 * @param {Uint8Array} b 
+	 * @returns {Uint8Array}
+	 * @throws {ValidationError}
+	 */
+	function concat(a, b) {
+	  var ab = new Uint8Array(a.length + b.length);
+	  ab.set(a);
+	  ab.set(b, a.length);
+	  return ab;
+	}
+
+	/**
+	 * Computes a checksum from the given input data as specified for the CashAddr
+	 * format: https://github.com/Bitcoin-UAHF/spec/blob/master/cashaddr.md.
+	 *
+	 * @private
+	 * @param {Uint8Array} data Array of 5-bit integers over which the checksum is to be computed.
+	 * @returns {BigInteger}
+	 */
+	function polymod(data) {
+	  var GENERATOR = [0x98f2bc8e61, 0x79b76d99e2, 0xf33e5fb3c4, 0xae2eabe2a8, 0x1e4f43e470];
+	  var checksum = bigInt(1);
+	  for (var i = 0; i < data.length; ++i) {
+	    var value = data[i];
+	    var topBits = checksum.shiftRight(35);
+	    checksum = checksum.and(0x07ffffffff).shiftLeft(5).xor(value);
+	    for (var j = 0; j < GENERATOR.length; ++j) {
+	      if (topBits.shiftRight(j).and(1).equals(1)) {
+	        checksum = checksum.xor(GENERATOR[j]);
+	      }
+	    }
+	  }
+	  return checksum.xor(1);
+	}
+
+	/**
+	 * Verify that the payload has not been corrupted by checking that the
+	 * checksum is valid.
+	 * 
+	 * @private
+	 * @param {string} prefix Network prefix. E.g.: 'bitcoincash'.
+	 * @param {Uint8Array} payload Array of 5-bit integers containing the address' payload.
+	 * @returns {boolean}
+	 */
+	function validChecksum(prefix, payload) {
+	  var prefixData = concat(prefixToUint5Array(prefix), new Uint8Array(1));
+	  var checksumData = concat(prefixData, payload);
+	  return polymod(checksumData).equals(0);
+	}
+
+	/**
+	 * Returns true if, and only if, the given string contains either uppercase
+	 * or lowercase letters, but not both.
+	 *
+	 * @private
+	 * @param {string} string Input string.
+	 * @returns {boolean}
+	 */
+	function hasSingleCase(string) {
+	  return string === string.toLowerCase() || string === string.toUpperCase();
+	}
+
+	cashaddr = {
+	  encode: encode,
+	  decode: decode,
+	  ValidationError: ValidationError,
+	};
+	return cashaddr;
+}
+
+/***
+ * @license
+ * https://github.com/ealmansi/bchaddrjs
+ * Copyright (c) 2018-2020 Emilio Almansi
+ * Distributed under the MIT software license, see the accompanying
+ * file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+ */
+
+var bchaddr;
+var hasRequiredBchaddr;
+
+function requireBchaddr () {
+	if (hasRequiredBchaddr) return bchaddr;
+	hasRequiredBchaddr = 1;
+	var bs58check = requireBs58check();
+	var cashaddr = requireCashaddr();
+	var Buffer = requireDist().Buffer;
+
+	/**
+	 * General purpose Bitcoin Cash address detection and translation.<br />
+	 * Supports all major Bitcoin Cash address formats.<br />
+	 * Currently:
+	 * <ul>
+	 *    <li> Legacy format </li>
+	 *    <li> Bitpay format </li>
+	 *    <li> Cashaddr format </li>
+	 * </ul>
+	 * @module bchaddr
+	 */
+
+	/**
+	 * @static
+	 * Supported Bitcoin Cash address formats.
+	 */
+	var Format = {};
+	Format.Legacy = 'legacy';
+	Format.Bitpay = 'bitpay';
+	Format.Cashaddr = 'cashaddr';
+
+	/**
+	 * @static
+	 * Supported networks.
+	 */
+	var Network = {};
+	Network.Mainnet = 'mainnet';
+	Network.Testnet = 'testnet';
+
+	/**
+	 * @static
+	 * Supported address types.
+	 */
+	var Type = {};
+	Type.P2PKH = 'p2pkh';
+	Type.P2SH = 'p2sh';
+
+	/**
+	 * Returns a boolean indicating whether the given input is a valid Bitcoin Cash address.
+	 * @static
+	 * @param {*} input - Any input to check for validity.
+	 * @returns {boolean}
+	 */
+	function isValidAddress (input) {
+	  try {
+	    decodeAddress(input);
+	    return true
+	  } catch (error) {
+	    return false
+	  }
+	}
+
+	/**
+	 * Detects what is the given address' format.
+	 * @static
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @return {string}
+	 * @throws {InvalidAddressError}
+	 */
+	function detectAddressFormat (address) {
+	  return decodeAddress(address).format
+	}
+
+	/**
+	 * Detects what is the given address' network.
+	 * @static
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @return {string}
+	 * @throws {InvalidAddressError}
+	 */
+	function detectAddressNetwork (address) {
+	  return decodeAddress(address).network
+	}
+
+	/**
+	 * Detects what is the given address' type.
+	 * @static
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @return {string}
+	 * @throws {InvalidAddressError}
+	 */
+	function detectAddressType (address) {
+	  return decodeAddress(address).type
+	}
+
+	/**
+	 * Translates the given address into legacy format.
+	 * @static
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @return {string}
+	 * @throws {InvalidAddressError}
+	 */
+	function toLegacyAddress (address) {
+	  var decoded = decodeAddress(address);
+	  if (decoded.format === Format.Legacy) {
+	    return address
+	  }
+	  return encodeAsLegacy(decoded)
+	}
+
+	/**
+	 * Translates the given address into bitpay format.
+	 * @static
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @return {string}
+	 * @throws {InvalidAddressError}
+	 */
+	function toBitpayAddress (address) {
+	  var decoded = decodeAddress(address);
+	  if (decoded.format === Format.Bitpay) {
+	    return address
+	  }
+	  return encodeAsBitpay(decoded)
+	}
+
+	/**
+	 * Translates the given address into cashaddr format.
+	 * @static
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @return {string}
+	 * @throws {InvalidAddressError}
+	 */
+	function toCashAddress (address) {
+	  var decoded = decodeAddress(address);
+	  return encodeAsCashaddr(decoded)
+	}
+
+	/**
+	 * Version byte table for base58 formats.
+	 * @private
+	 */
+	var VERSION_BYTE = {};
+	VERSION_BYTE[Format.Legacy] = {};
+	VERSION_BYTE[Format.Legacy][Network.Mainnet] = {};
+	VERSION_BYTE[Format.Legacy][Network.Mainnet][Type.P2PKH] = 0;
+	VERSION_BYTE[Format.Legacy][Network.Mainnet][Type.P2SH] = 5;
+	VERSION_BYTE[Format.Legacy][Network.Testnet] = {};
+	VERSION_BYTE[Format.Legacy][Network.Testnet][Type.P2PKH] = 111;
+	VERSION_BYTE[Format.Legacy][Network.Testnet][Type.P2SH] = 196;
+	VERSION_BYTE[Format.Bitpay] = {};
+	VERSION_BYTE[Format.Bitpay][Network.Mainnet] = {};
+	VERSION_BYTE[Format.Bitpay][Network.Mainnet][Type.P2PKH] = 28;
+	VERSION_BYTE[Format.Bitpay][Network.Mainnet][Type.P2SH] = 40;
+	VERSION_BYTE[Format.Bitpay][Network.Testnet] = {};
+	VERSION_BYTE[Format.Bitpay][Network.Testnet][Type.P2PKH] = 111;
+	VERSION_BYTE[Format.Bitpay][Network.Testnet][Type.P2SH] = 196;
+
+	/**
+	 * Decodes the given address into its constituting hash, format, network and type.
+	 * @private
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @return {object}
+	 * @throws {InvalidAddressError}
+	 */
+	function decodeAddress (address) {
+	  try {
+	    return decodeBase58Address(address)
+	  } catch (error) {
+	  }
+	  try {
+	    return decodeCashAddress(address)
+	  } catch (error) {
+	  }
+	  throw new InvalidAddressError()
+	}
+
+	/**
+	 * Length of a valid base58check encoding payload: 1 byte for
+	 * the version byte plus 20 bytes for a RIPEMD-160 hash.
+	 * @private
+	 */
+	var BASE_58_CHECK_PAYLOAD_LENGTH = 21;
+
+	/**
+	 * Attempts to decode the given address assuming it is a base58 address.
+	 * @private
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @return {object}
+	 * @throws {InvalidAddressError}
+	 */
+	function decodeBase58Address (address) {
+	  try {
+	    var payload = bs58check.decode(address);
+	    if (payload.length !== BASE_58_CHECK_PAYLOAD_LENGTH) {
+	      throw new InvalidAddressError()
+	    }
+	    var versionByte = payload[0];
+	    var hash = Array.prototype.slice.call(payload, 1);
+	    switch (versionByte) {
+	      case VERSION_BYTE[Format.Legacy][Network.Mainnet][Type.P2PKH]:
+	        return {
+	          hash: hash,
+	          format: Format.Legacy,
+	          network: Network.Mainnet,
+	          type: Type.P2PKH
+	        }
+	      case VERSION_BYTE[Format.Legacy][Network.Mainnet][Type.P2SH]:
+	        return {
+	          hash: hash,
+	          format: Format.Legacy,
+	          network: Network.Mainnet,
+	          type: Type.P2SH
+	        }
+	      case VERSION_BYTE[Format.Legacy][Network.Testnet][Type.P2PKH]:
+	        return {
+	          hash: hash,
+	          format: Format.Legacy,
+	          network: Network.Testnet,
+	          type: Type.P2PKH
+	        }
+	      case VERSION_BYTE[Format.Legacy][Network.Testnet][Type.P2SH]:
+	        return {
+	          hash: hash,
+	          format: Format.Legacy,
+	          network: Network.Testnet,
+	          type: Type.P2SH
+	        }
+	      case VERSION_BYTE[Format.Bitpay][Network.Mainnet][Type.P2PKH]:
+	        return {
+	          hash: hash,
+	          format: Format.Bitpay,
+	          network: Network.Mainnet,
+	          type: Type.P2PKH
+	        }
+	      case VERSION_BYTE[Format.Bitpay][Network.Mainnet][Type.P2SH]:
+	        return {
+	          hash: hash,
+	          format: Format.Bitpay,
+	          network: Network.Mainnet,
+	          type: Type.P2SH
+	        }
+	    }
+	  } catch (error) {
+	  }
+	  throw new InvalidAddressError()
+	}
+
+	/**
+	 * Attempts to decode the given address assuming it is a cashaddr address.
+	 * @private
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @return {object}
+	 * @throws {InvalidAddressError}
+	 */
+	function decodeCashAddress (address) {
+	  if (address.indexOf(':') !== -1) {
+	    try {
+	      return decodeCashAddressWithPrefix(address)
+	    } catch (error) {
+	    }
+	  } else {
+	    var prefixes = ['bitcoincash', 'bchtest', 'bchreg'];
+	    for (var i = 0; i < prefixes.length; ++i) {
+	      try {
+	        var prefix = prefixes[i];
+	        return decodeCashAddressWithPrefix(prefix + ':' + address)
+	      } catch (error) {
+	      }
+	    }
+	  }
+	  throw new InvalidAddressError()
+	}
+
+	/**
+	 * Attempts to decode the given address assuming it is a cashaddr address with explicit prefix.
+	 * @private
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @return {object}
+	 * @throws {InvalidAddressError}
+	 */
+	function decodeCashAddressWithPrefix (address) {
+	  try {
+	    var decoded = cashaddr.decode(address);
+	    var hash = Array.prototype.slice.call(decoded.hash, 0);
+	    var type = decoded.type === 'P2PKH' ? Type.P2PKH : Type.P2SH;
+	    switch (decoded.prefix) {
+	      case 'bitcoincash':
+	        return {
+	          hash: hash,
+	          format: Format.Cashaddr,
+	          network: Network.Mainnet,
+	          type: type
+	        }
+	      case 'bchtest':
+	      case 'bchreg':
+	        return {
+	          hash: hash,
+	          format: Format.Cashaddr,
+	          network: Network.Testnet,
+	          type: type
+	        }
+	    }
+	  } catch (error) {
+	  }
+	  throw new InvalidAddressError()
+	}
+
+	/**
+	 * Encodes the given decoded address into legacy format.
+	 * @private
+	 * @param {object} decoded
+	 * @returns {string}
+	 */
+	function encodeAsLegacy (decoded) {
+	  var versionByte = VERSION_BYTE[Format.Legacy][decoded.network][decoded.type];
+	  var buffer = Buffer.alloc(1 + decoded.hash.length);
+	  buffer[0] = versionByte;
+	  buffer.set(decoded.hash, 1);
+	  return bs58check.encode(buffer)
+	}
+
+	/**
+	 * Encodes the given decoded address into bitpay format.
+	 * @private
+	 * @param {object} decoded
+	 * @returns {string}
+	 */
+	function encodeAsBitpay (decoded) {
+	  var versionByte = VERSION_BYTE[Format.Bitpay][decoded.network][decoded.type];
+	  var buffer = Buffer.alloc(1 + decoded.hash.length);
+	  buffer[0] = versionByte;
+	  buffer.set(decoded.hash, 1);
+	  return bs58check.encode(buffer)
+	}
+
+	/**
+	 * Encodes the given decoded address into cashaddr format.
+	 * @private
+	 * @param {object} decoded
+	 * @returns {string}
+	 */
+	function encodeAsCashaddr (decoded) {
+	  var prefix = decoded.network === Network.Mainnet ? 'bitcoincash' : 'bchtest';
+	  var type = decoded.type === Type.P2PKH ? 'P2PKH' : 'P2SH';
+	  var hash = new Uint8Array(decoded.hash);
+	  return cashaddr.encode(prefix, type, hash)
+	}
+
+	/**
+	 * Returns a boolean indicating whether the address is in legacy format.
+	 * @static
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @returns {boolean}
+	 * @throws {InvalidAddressError}
+	 */
+	function isLegacyAddress (address) {
+	  return detectAddressFormat(address) === Format.Legacy
+	}
+
+	/**
+	 * Returns a boolean indicating whether the address is in bitpay format.
+	 * @static
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @returns {boolean}
+	 * @throws {InvalidAddressError}
+	 */
+	function isBitpayAddress (address) {
+	  return detectAddressFormat(address) === Format.Bitpay
+	}
+
+	/**
+	 * Returns a boolean indicating whether the address is in cashaddr format.
+	 * @static
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @returns {boolean}
+	 * @throws {InvalidAddressError}
+	 */
+	function isCashAddress (address) {
+	  return detectAddressFormat(address) === Format.Cashaddr
+	}
+
+	/**
+	 * Returns a boolean indicating whether the address is a mainnet address.
+	 * @static
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @returns {boolean}
+	 * @throws {InvalidAddressError}
+	 */
+	function isMainnetAddress (address) {
+	  return detectAddressNetwork(address) === Network.Mainnet
+	}
+
+	/**
+	 * Returns a boolean indicating whether the address is a testnet address.
+	 * @static
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @returns {boolean}
+	 * @throws {InvalidAddressError}
+	 */
+	function isTestnetAddress (address) {
+	  return detectAddressNetwork(address) === Network.Testnet
+	}
+
+	/**
+	 * Returns a boolean indicating whether the address is a p2pkh address.
+	 * @static
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @returns {boolean}
+	 * @throws {InvalidAddressError}
+	 */
+	function isP2PKHAddress (address) {
+	  return detectAddressType(address) === Type.P2PKH
+	}
+
+	/**
+	 * Returns a boolean indicating whether the address is a p2sh address.
+	 * @static
+	 * @param {string} address - A valid Bitcoin Cash address in any format.
+	 * @returns {boolean}
+	 * @throws {InvalidAddressError}
+	 */
+	function isP2SHAddress (address) {
+	  return detectAddressType(address) === Type.P2SH
+	}
+
+	/**
+	 * Error thrown when the address given as input is not a valid Bitcoin Cash address.
+	 * @constructor
+	 * InvalidAddressError
+	 */
+	function InvalidAddressError () {
+	  var error = new Error();
+	  this.name = error.name = 'InvalidAddressError';
+	  this.message = error.message = 'Received an invalid Bitcoin Cash address as input.';
+	  this.stack = error.stack;
+	}
+
+	InvalidAddressError.prototype = Object.create(Error.prototype);
+
+	bchaddr = {
+	  Format: Format,
+	  Network: Network,
+	  Type: Type,
+	  isValidAddress: isValidAddress,
+	  detectAddressFormat: detectAddressFormat,
+	  detectAddressNetwork: detectAddressNetwork,
+	  detectAddressType: detectAddressType,
+	  toLegacyAddress: toLegacyAddress,
+	  toBitpayAddress: toBitpayAddress,
+	  toCashAddress: toCashAddress,
+	  isLegacyAddress: isLegacyAddress,
+	  isBitpayAddress: isBitpayAddress,
+	  isCashAddress: isCashAddress,
+	  isMainnetAddress: isMainnetAddress,
+	  isTestnetAddress: isTestnetAddress,
+	  isP2PKHAddress: isP2PKHAddress,
+	  isP2SHAddress: isP2SHAddress,
+	  InvalidAddressError: InvalidAddressError
+	};
+	return bchaddr;
+}
+
+var bchaddrExports = requireBchaddr();
+
+export { bchaddrExports as b };