@protontech/openpgp 6.0.0-beta.0.patch.0 → 6.0.0-beta.1

package/dist/lightweight/interface.min.mjs

@@ -1,3 +0,0 @@
-/*! OpenPGP.js v6.0.0-beta.0.patch.0 - 2024-04-19 - this is LGPL licensed code, see LICENSE/our website https://openpgpjs.org/ for more information. */
-"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self&&self;class e{static setImplementation(t,n=!1){if(e.Implementation&&!n)throw Error("Implementation already set");e.Implementation=t}static new(t){return new e.Implementation(t)}}export{e as B};
-//# sourceMappingURL=interface.min.mjs.map

package/dist/lightweight/interface.min.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"interface.min.mjs","sources":["../../node_modules/@openpgp/noble-hashes/esm/biginteger/interface.js"],"sourcesContent":["class BigInteger {\n    static setImplementation(Implementation, replace = false) {\n        if (BigInteger.Implementation && !replace) {\n            throw new Error('Implementation already set');\n        }\n        BigInteger.Implementation = Implementation;\n    }\n    static new(n) {\n        return new BigInteger.Implementation(n);\n    }\n}\nexport { BigInteger, BigInteger as default };\n//# sourceMappingURL=interface.js.map"],"names":["BigInteger","setImplementation","Implementation","replace","Error","n"],"mappings":";mGAAA,MAAMA,EACF,wBAAOC,CAAkBC,EAAgBC,GAAU,GAC/C,GAAIH,EAAWE,iBAAmBC,EAC9B,MAAUC,MAAM,8BAEpBJ,EAAWE,eAAiBA,CAC/B,CACD,UAAO,CAAIG,GACP,OAAO,IAAIL,EAAWE,eAAeG,EACxC","x_google_ignoreList":[0]}

package/dist/lightweight/interface.mjs

@@ -1,16 +0,0 @@
-/*! OpenPGP.js v6.0.0-beta.0.patch.0 - 2024-04-19 - this is LGPL licensed code, see LICENSE/our website https://openpgpjs.org/ for more information. */
-const globalThis = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-class BigInteger {
-    static setImplementation(Implementation, replace = false) {
-        if (BigInteger.Implementation && !replace) {
-            throw new Error('Implementation already set');
-        }
-        BigInteger.Implementation = Implementation;
-    }
-    static new(n) {
-        return new BigInteger.Implementation(n);
-    }
-}
-
-export { BigInteger as B };

package/dist/lightweight/native.interface.min.mjs

@@ -1,3 +0,0 @@
-/*! OpenPGP.js v6.0.0-beta.0.patch.0 - 2024-04-19 - this is LGPL licensed code, see LICENSE/our website https://openpgpjs.org/ for more information. */
-"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self&&self;import{B as e}from"./interface.min.mjs";class t extends e{constructor(e){if(super(),void 0===e)throw Error("Invalid BigInteger input");if(e instanceof Uint8Array){const t="0123456789ABCDEF";let i="";e.forEach((e=>{i+=t[e>>4]+t[15&e]})),this.value=BigInt("0x0"+i)}else this.value=BigInt(e)}clone(){return new t(this.value)}iinc(){return this.value++,this}inc(){return this.clone().iinc()}idec(){return this.value--,this}dec(){return this.clone().idec()}iadd(e){return this.value+=e.value,this}add(e){return this.clone().iadd(e)}isub(e){return this.value-=e.value,this}sub(e){return this.clone().isub(e)}imul(e){return this.value*=e.value,this}mul(e){return this.clone().imul(e)}imod(e){return this.value%=e.value,this.isNegative()&&this.iadd(e),this}mod(e){return this.clone().imod(e)}modExp(e,i){if(i.isZero())throw Error("Modulo cannot be zero");if(i.isOne())return new t(0);if(e.isNegative())throw Error("Unsopported negative exponent");let n=e.value,r=this.value;r%=i.value;let s=BigInt(1);for(;n>BigInt(0);){const e=n&BigInt(1);n>>=BigInt(1);const t=s*r%i.value;s=e?t:s,r=r*r%i.value}return new t(s)}modInv(e){const{gcd:t,x:i}=this._egcd(e);if(!t.isOne())throw Error("Inverse does not exist");return i.add(e).mod(e)}idiv(e){return this.value/=e.value,this}div(e){return this.clone().idiv(e)}_egcd(e){let i=BigInt(0),n=BigInt(1),r=BigInt(1),s=BigInt(0),u=this.abs().value,l=e.abs().value;const a=this.isNegative(),o=e.isNegative();for(;l!==BigInt(0);){const e=u/l;let t=i;i=r-e*i,r=t,t=n,n=s-e*n,s=t,t=l,l=u%l,u=t}return{x:new t(a?-r:r),y:new t(o?-s:s),gcd:new t(u)}}gcd(e){let i=this.value,n=e.value;for(;n!==BigInt(0);){const e=n;n=i%n,i=e}return new t(i)}ileftShift(e){return this.value<<=e.value,this}leftShift(e){return this.clone().ileftShift(e)}irightShift(e){return this.value>>=e.value,this}rightShift(e){return this.clone().irightShift(e)}ixor(e){return this.value^=e.value,this}xor(e){return this.clone().ixor(e)}ibitwiseAnd(e){return this.value&=e.value,this}bitwiseAnd(e){return this.clone().ibitwiseAnd(e)}ibitwiseOr(e){return this.value|=e.value,this}equal(e){return this.value===e.value}lt(e){return this.value<e.value}lte(e){return this.value<=e.value}gt(e){return this.value>e.value}gte(e){return this.value>=e.value}isZero(){return this.value===BigInt(0)}isOne(){return this.value===BigInt(1)}isNegative(){return this.value<BigInt(0)}isEven(){return!(this.value&BigInt(1))}abs(){const e=this.clone();return this.isNegative()&&(e.value=-e.value),e}negate(){const e=this.clone();return e.value=-e.value,e}toString(){return this.value.toString()}toNumber(){const e=Number(this.value);if(e>Number.MAX_SAFE_INTEGER)throw Error("Number can only safely store up to 53 bits");return e}getBit(e){return(this.value>>BigInt(e)&BigInt(1))===BigInt(0)?0:1}bitLength(){const e=new t(0),i=new t(1),n=new t(-1),r=this.isNegative()?n:e;let s=1;const u=this.clone();for(;!u.irightShift(i).equal(r);)s++;return s}byteLength(){const e=new t(0),i=new t(-1),n=this.isNegative()?i:e,r=new t(8);let s=1;const u=this.clone();for(;!u.irightShift(r).equal(n);)s++;return s}toUint8Array(e="be",t){let i=this.value.toString(16);i.length%2==1&&(i="0"+i);const n=i.length/2,r=new Uint8Array(t||n),s=t?t-n:0;let u=0;for(;u<n;)r[u+s]=parseInt(i.slice(2*u,2*u+2),16),u++;return"be"!==e&&r.reverse(),r}}export{t as default};
-//# sourceMappingURL=native.interface.min.mjs.map

package/dist/lightweight/native.interface.min.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"native.interface.min.mjs","sources":["../../node_modules/@openpgp/noble-hashes/esm/biginteger/native.interface.js"],"sourcesContent":["/**\n * @fileoverview\n * BigInteger implementation of basic operations\n * that wraps the native BigInt library.\n * Operations are not constant time,\n * but we try and limit timing leakage where we can\n * @module biginteger/native\n * @private\n */\nimport AbstractBigInteger from './interface.js';\n/**\n * @private\n */\nexport default class NativeBigInteger extends AbstractBigInteger {\n    /**\n     * Get a BigInteger (input must be big endian for strings and arrays)\n     * @param {Number|String|Uint8Array} n - Value to convert\n     * @throws {Error} on null or undefined input\n     */\n    constructor(n) {\n        super(); // noop, needed for TS checks only\n        if (n === undefined) {\n            throw new Error('Invalid BigInteger input');\n        }\n        if (n instanceof Uint8Array) {\n            const bytes = n;\n            const hexAlphabet = '0123456789ABCDEF';\n            let s = '';\n            bytes.forEach((v) => {\n                s += hexAlphabet[v >> 4] + hexAlphabet[v & 15];\n            });\n            this.value = BigInt('0x0' + s);\n        }\n        else {\n            this.value = BigInt(n);\n        }\n    }\n    clone() {\n        return new NativeBigInteger(this.value);\n    }\n    /**\n     * BigInteger increment in place\n     */\n    iinc() {\n        this.value++;\n        return this;\n    }\n    /**\n     * BigInteger increment\n     * @returns {BigInteger} this + 1.\n     */\n    inc() {\n        return this.clone().iinc();\n    }\n    /**\n     * BigInteger decrement in place\n     */\n    idec() {\n        this.value--;\n        return this;\n    }\n    /**\n     * BigInteger decrement\n     * @returns {BigInteger} this - 1.\n     */\n    dec() {\n        return this.clone().idec();\n    }\n    /**\n     * BigInteger addition in place\n     * @param {BigInteger} x - Value to add\n     */\n    iadd(x) {\n        this.value += x.value;\n        return this;\n    }\n    /**\n     * BigInteger addition\n     * @param {BigInteger} x - Value to add\n     * @returns {BigInteger} this + x.\n     */\n    add(x) {\n        return this.clone().iadd(x);\n    }\n    /**\n     * BigInteger subtraction in place\n     * @param {BigInteger} x - Value to subtract\n     */\n    isub(x) {\n        this.value -= x.value;\n        return this;\n    }\n    /**\n     * BigInteger subtraction\n     * @param {BigInteger} x - Value to subtract\n     * @returns {BigInteger} this - x.\n     */\n    sub(x) {\n        return this.clone().isub(x);\n    }\n    /**\n     * BigInteger multiplication in place\n     * @param {BigInteger} x - Value to multiply\n     */\n    imul(x) {\n        this.value *= x.value;\n        return this;\n    }\n    /**\n     * BigInteger multiplication\n     * @param {BigInteger} x - Value to multiply\n     * @returns {BigInteger} this * x.\n     */\n    mul(x) {\n        return this.clone().imul(x);\n    }\n    /**\n     * Compute value modulo m, in place\n     * @param {BigInteger} m - Modulo\n     */\n    imod(m) {\n        this.value %= m.value;\n        if (this.isNegative()) {\n            this.iadd(m);\n        }\n        return this;\n    }\n    /**\n     * Compute value modulo m\n     * @param {BigInteger} m - Modulo\n     * @returns {BigInteger} this mod m.\n     */\n    mod(m) {\n        return this.clone().imod(m);\n    }\n    /**\n     * Compute modular exponentiation using square and multiply\n     * @param {BigInteger} e - Exponent\n     * @param {BigInteger} n - Modulo\n     * @returns {BigInteger} this ** e mod n.\n     */\n    modExp(e, n) {\n        if (n.isZero())\n            throw Error('Modulo cannot be zero');\n        if (n.isOne())\n            return new NativeBigInteger(0);\n        if (e.isNegative())\n            throw Error('Unsopported negative exponent');\n        let exp = e.value;\n        let x = this.value;\n        x %= n.value;\n        let r = BigInt(1);\n        while (exp > BigInt(0)) {\n            const lsb = exp & BigInt(1);\n            exp >>= BigInt(1); // e / 2\n            // Always compute multiplication step, to reduce timing leakage\n            const rx = (r * x) % n.value;\n            // Update r only if lsb is 1 (odd exponent)\n            r = lsb ? rx : r;\n            x = (x * x) % n.value; // Square\n        }\n        return new NativeBigInteger(r);\n    }\n    /**\n     * Compute the inverse of this value modulo n\n     * Note: this and and n must be relatively prime\n     * @param {BigInteger} n - Modulo\n     * @returns {BigInteger} x such that this*x = 1 mod n\n     * @throws {Error} if the inverse does not exist\n     */\n    modInv(n) {\n        const { gcd, x } = this._egcd(n);\n        if (!gcd.isOne()) {\n            throw new Error('Inverse does not exist');\n        }\n        return x.add(n).mod(n);\n    }\n    /**\n     * BigInteger division, in place\n     * @param {BigInteger} n - Value to divide\n     */\n    idiv(n) {\n        this.value /= n.value;\n        return this;\n    }\n    /**\n     * BigInteger division\n     * @param {BigInteger} n - Value to divide\n     * @returns {BigInteger} this divded by n.\n     */\n    div(n) {\n        return this.clone().idiv(n);\n    }\n    /**\n     * Extended Eucleadian algorithm (http://anh.cs.luc.edu/331/notes/xgcd.pdf)\n     * Given a = this and b, compute (x, y) such that ax + by = gdc(a, b).\n     * Negative numbers are also supported.\n     * @param {BigInteger} b - Second operand\n     * @returns {{ gcd, x, y: BigInteger }}\n     */\n    _egcd(bInput) {\n        let x = BigInt(0);\n        let y = BigInt(1);\n        let xPrev = BigInt(1);\n        let yPrev = BigInt(0);\n        // Deal with negative numbers: run algo over absolute values,\n        // and \"move\" the sign to the returned x and/or y.\n        // See https://math.stackexchange.com/questions/37806/extended-euclidean-algorithm-with-negative-numbers\n        let a = this.abs().value;\n        let b = bInput.abs().value;\n        const aNegated = this.isNegative();\n        const bNegated = bInput.isNegative();\n        while (b !== BigInt(0)) {\n            const q = a / b;\n            let tmp = x;\n            x = xPrev - q * x;\n            xPrev = tmp;\n            tmp = y;\n            y = yPrev - q * y;\n            yPrev = tmp;\n            tmp = b;\n            b = a % b;\n            a = tmp;\n        }\n        return {\n            x: new NativeBigInteger(aNegated ? -xPrev : xPrev),\n            y: new NativeBigInteger(bNegated ? -yPrev : yPrev),\n            gcd: new NativeBigInteger(a),\n        };\n    }\n    /**\n     * Compute greatest common divisor between this and n\n     * @param {BigInteger} b - Operand\n     * @returns {BigInteger} gcd\n     */\n    gcd(bInput) {\n        let a = this.value;\n        let b = bInput.value;\n        while (b !== BigInt(0)) {\n            const tmp = b;\n            b = a % b;\n            a = tmp;\n        }\n        return new NativeBigInteger(a);\n    }\n    /**\n     * Shift this to the left by x, in place\n     * @param {BigInteger} x - Shift value\n     */\n    ileftShift(x) {\n        this.value <<= x.value;\n        return this;\n    }\n    /**\n     * Shift this to the left by x\n     * @param {BigInteger} x - Shift value\n     * @returns {BigInteger} this << x.\n     */\n    leftShift(x) {\n        return this.clone().ileftShift(x);\n    }\n    /**\n     * Shift this to the right by x, in place\n     * @param {BigInteger} x - Shift value\n     */\n    irightShift(x) {\n        this.value >>= x.value;\n        return this;\n    }\n    /**\n     * Shift this to the right by x\n     * @param {BigInteger} x - Shift value\n     * @returns {BigInteger} this >> x.\n     */\n    rightShift(x) {\n        return this.clone().irightShift(x);\n    }\n    ixor(x) {\n        this.value ^= x.value;\n        return this;\n    }\n    xor(x) {\n        return this.clone().ixor(x);\n    }\n    ibitwiseAnd(x) {\n        this.value &= x.value;\n        return this;\n    }\n    bitwiseAnd(x) {\n        return this.clone().ibitwiseAnd(x);\n    }\n    ibitwiseOr(x) {\n        this.value |= x.value;\n        return this;\n    }\n    /**\n     * Whether this value is equal to x\n     * @param {BigInteger} x\n     * @returns {Boolean}\n     */\n    equal(x) {\n        return this.value === x.value;\n    }\n    /**\n     * Whether this value is less than x\n     * @param {BigInteger} x\n     * @returns {Boolean}\n     */\n    lt(x) {\n        return this.value < x.value;\n    }\n    /**\n     * Whether this value is less than or equal to x\n     * @param {BigInteger} x\n     * @returns {Boolean}\n     */\n    lte(x) {\n        return this.value <= x.value;\n    }\n    /**\n     * Whether this value is greater than x\n     * @param {BigInteger} x\n     * @returns {Boolean}\n     */\n    gt(x) {\n        return this.value > x.value;\n    }\n    /**\n     * Whether this value is greater than or equal to x\n     * @param {BigInteger} x\n     * @returns {Boolean}\n     */\n    gte(x) {\n        return this.value >= x.value;\n    }\n    isZero() {\n        return this.value === BigInt(0);\n    }\n    isOne() {\n        return this.value === BigInt(1);\n    }\n    isNegative() {\n        return this.value < BigInt(0);\n    }\n    isEven() {\n        return !(this.value & BigInt(1));\n    }\n    abs() {\n        const res = this.clone();\n        if (this.isNegative()) {\n            res.value = -res.value;\n        }\n        return res;\n    }\n    negate() {\n        const res = this.clone();\n        res.value = -res.value;\n        return res;\n    }\n    /**\n     * Get this value as a string\n     * @returns {String} this value.\n     */\n    toString() {\n        return this.value.toString();\n    }\n    /**\n     * Get this value as an exact Number (max 53 bits)\n     * Fails if this value is too large\n     * @returns {Number}\n     */\n    toNumber() {\n        const number = Number(this.value);\n        if (number > Number.MAX_SAFE_INTEGER) {\n            // We throw and error to conform with the bn.js implementation\n            throw new Error('Number can only safely store up to 53 bits');\n        }\n        return number;\n    }\n    /**\n     * Get value of i-th bit\n     * @param {Number} i - Bit index\n     * @returns {Number} Bit value.\n     */\n    getBit(i) {\n        const bit = (this.value >> BigInt(i)) & BigInt(1);\n        return bit === BigInt(0) ? 0 : 1;\n    }\n    /**\n     * Compute bit length\n     * @returns {Number} Bit length.\n     */\n    bitLength() {\n        const zero = new NativeBigInteger(0);\n        const one = new NativeBigInteger(1);\n        const negOne = new NativeBigInteger(-1);\n        // -1n >> -1n is -1n\n        // 1n >> 1n is 0n\n        const target = this.isNegative() ? negOne : zero;\n        let bitlen = 1;\n        const tmp = this.clone();\n        while (!tmp.irightShift(one).equal(target)) {\n            bitlen++;\n        }\n        return bitlen;\n    }\n    /**\n     * Compute byte length\n     * @returns {Number} Byte length.\n     */\n    byteLength() {\n        const zero = new NativeBigInteger(0);\n        const negOne = new NativeBigInteger(-1);\n        const target = this.isNegative() ? negOne : zero;\n        const eight = new NativeBigInteger(8);\n        let len = 1;\n        const tmp = this.clone();\n        while (!tmp.irightShift(eight).equal(target)) {\n            len++;\n        }\n        return len;\n    }\n    /**\n     * Get Uint8Array representation of this number\n     * @param {String} endian - Endianess of output array (defaults to 'be')\n     * @param {Number} length - Of output array\n     * @returns {Uint8Array}\n     */\n    toUint8Array(endian = 'be', length) {\n        // we get and parse the hex string (https://coolaj86.com/articles/convert-js-bigints-to-typedarrays/)\n        // this is faster than shift+mod iterations\n        let hex = this.value.toString(16);\n        if (hex.length % 2 === 1) {\n            hex = '0' + hex;\n        }\n        const rawLength = hex.length / 2;\n        const bytes = new Uint8Array(length || rawLength);\n        // parse hex\n        const offset = length ? length - rawLength : 0;\n        let i = 0;\n        while (i < rawLength) {\n            bytes[i + offset] = parseInt(hex.slice(2 * i, 2 * i + 2), 16);\n            i++;\n        }\n        if (endian !== 'be') {\n            bytes.reverse();\n        }\n        return bytes;\n    }\n}\n//# sourceMappingURL=native.interface.js.map"],"names":["NativeBigInteger","AbstractBigInteger","constructor","n","super","undefined","Error","Uint8Array","hexAlphabet","s","forEach","v","this","value","BigInt","clone","iinc","inc","idec","dec","iadd","x","add","isub","sub","imul","mul","imod","m","isNegative","mod","modExp","e","isZero","isOne","exp","r","lsb","rx","modInv","gcd","_egcd","idiv","div","bInput","y","xPrev","yPrev","a","abs","b","aNegated","bNegated","q","tmp","ileftShift","leftShift","irightShift","rightShift","ixor","xor","ibitwiseAnd","bitwiseAnd","ibitwiseOr","equal","lt","lte","gt","gte","isEven","res","negate","toString","toNumber","number","Number","MAX_SAFE_INTEGER","getBit","i","bitLength","zero","one","negOne","target","bitlen","byteLength","eight","len","toUint8Array","endian","length","hex","rawLength","bytes","offset","parseInt","slice","reverse"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/lightweight/native.interface.mjs

@@ -1,456 +0,0 @@
-/*! OpenPGP.js v6.0.0-beta.0.patch.0 - 2024-04-19 - this is LGPL licensed code, see LICENSE/our website https://openpgpjs.org/ for more information. */
-const globalThis = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-import { B as BigInteger } from './interface.mjs';
-
-/**
- * @fileoverview
- * BigInteger implementation of basic operations
- * that wraps the native BigInt library.
- * Operations are not constant time,
- * but we try and limit timing leakage where we can
- * @module biginteger/native
- * @private
- */
-/**
- * @private
- */
-class NativeBigInteger extends BigInteger {
-    /**
-     * Get a BigInteger (input must be big endian for strings and arrays)
-     * @param {Number|String|Uint8Array} n - Value to convert
-     * @throws {Error} on null or undefined input
-     */
-    constructor(n) {
-        super(); // noop, needed for TS checks only
-        if (n === undefined) {
-            throw new Error('Invalid BigInteger input');
-        }
-        if (n instanceof Uint8Array) {
-            const bytes = n;
-            const hexAlphabet = '0123456789ABCDEF';
-            let s = '';
-            bytes.forEach((v) => {
-                s += hexAlphabet[v >> 4] + hexAlphabet[v & 15];
-            });
-            this.value = BigInt('0x0' + s);
-        }
-        else {
-            this.value = BigInt(n);
-        }
-    }
-    clone() {
-        return new NativeBigInteger(this.value);
-    }
-    /**
-     * BigInteger increment in place
-     */
-    iinc() {
-        this.value++;
-        return this;
-    }
-    /**
-     * BigInteger increment
-     * @returns {BigInteger} this + 1.
-     */
-    inc() {
-        return this.clone().iinc();
-    }
-    /**
-     * BigInteger decrement in place
-     */
-    idec() {
-        this.value--;
-        return this;
-    }
-    /**
-     * BigInteger decrement
-     * @returns {BigInteger} this - 1.
-     */
-    dec() {
-        return this.clone().idec();
-    }
-    /**
-     * BigInteger addition in place
-     * @param {BigInteger} x - Value to add
-     */
-    iadd(x) {
-        this.value += x.value;
-        return this;
-    }
-    /**
-     * BigInteger addition
-     * @param {BigInteger} x - Value to add
-     * @returns {BigInteger} this + x.
-     */
-    add(x) {
-        return this.clone().iadd(x);
-    }
-    /**
-     * BigInteger subtraction in place
-     * @param {BigInteger} x - Value to subtract
-     */
-    isub(x) {
-        this.value -= x.value;
-        return this;
-    }
-    /**
-     * BigInteger subtraction
-     * @param {BigInteger} x - Value to subtract
-     * @returns {BigInteger} this - x.
-     */
-    sub(x) {
-        return this.clone().isub(x);
-    }
-    /**
-     * BigInteger multiplication in place
-     * @param {BigInteger} x - Value to multiply
-     */
-    imul(x) {
-        this.value *= x.value;
-        return this;
-    }
-    /**
-     * BigInteger multiplication
-     * @param {BigInteger} x - Value to multiply
-     * @returns {BigInteger} this * x.
-     */
-    mul(x) {
-        return this.clone().imul(x);
-    }
-    /**
-     * Compute value modulo m, in place
-     * @param {BigInteger} m - Modulo
-     */
-    imod(m) {
-        this.value %= m.value;
-        if (this.isNegative()) {
-            this.iadd(m);
-        }
-        return this;
-    }
-    /**
-     * Compute value modulo m
-     * @param {BigInteger} m - Modulo
-     * @returns {BigInteger} this mod m.
-     */
-    mod(m) {
-        return this.clone().imod(m);
-    }
-    /**
-     * Compute modular exponentiation using square and multiply
-     * @param {BigInteger} e - Exponent
-     * @param {BigInteger} n - Modulo
-     * @returns {BigInteger} this ** e mod n.
-     */
-    modExp(e, n) {
-        if (n.isZero())
-            throw Error('Modulo cannot be zero');
-        if (n.isOne())
-            return new NativeBigInteger(0);
-        if (e.isNegative())
-            throw Error('Unsopported negative exponent');
-        let exp = e.value;
-        let x = this.value;
-        x %= n.value;
-        let r = BigInt(1);
-        while (exp > BigInt(0)) {
-            const lsb = exp & BigInt(1);
-            exp >>= BigInt(1); // e / 2
-            // Always compute multiplication step, to reduce timing leakage
-            const rx = (r * x) % n.value;
-            // Update r only if lsb is 1 (odd exponent)
-            r = lsb ? rx : r;
-            x = (x * x) % n.value; // Square
-        }
-        return new NativeBigInteger(r);
-    }
-    /**
-     * Compute the inverse of this value modulo n
-     * Note: this and and n must be relatively prime
-     * @param {BigInteger} n - Modulo
-     * @returns {BigInteger} x such that this*x = 1 mod n
-     * @throws {Error} if the inverse does not exist
-     */
-    modInv(n) {
-        const { gcd, x } = this._egcd(n);
-        if (!gcd.isOne()) {
-            throw new Error('Inverse does not exist');
-        }
-        return x.add(n).mod(n);
-    }
-    /**
-     * BigInteger division, in place
-     * @param {BigInteger} n - Value to divide
-     */
-    idiv(n) {
-        this.value /= n.value;
-        return this;
-    }
-    /**
-     * BigInteger division
-     * @param {BigInteger} n - Value to divide
-     * @returns {BigInteger} this divded by n.
-     */
-    div(n) {
-        return this.clone().idiv(n);
-    }
-    /**
-     * Extended Eucleadian algorithm (http://anh.cs.luc.edu/331/notes/xgcd.pdf)
-     * Given a = this and b, compute (x, y) such that ax + by = gdc(a, b).
-     * Negative numbers are also supported.
-     * @param {BigInteger} b - Second operand
-     * @returns {{ gcd, x, y: BigInteger }}
-     */
-    _egcd(bInput) {
-        let x = BigInt(0);
-        let y = BigInt(1);
-        let xPrev = BigInt(1);
-        let yPrev = BigInt(0);
-        // Deal with negative numbers: run algo over absolute values,
-        // and "move" the sign to the returned x and/or y.
-        // See https://math.stackexchange.com/questions/37806/extended-euclidean-algorithm-with-negative-numbers
-        let a = this.abs().value;
-        let b = bInput.abs().value;
-        const aNegated = this.isNegative();
-        const bNegated = bInput.isNegative();
-        while (b !== BigInt(0)) {
-            const q = a / b;
-            let tmp = x;
-            x = xPrev - q * x;
-            xPrev = tmp;
-            tmp = y;
-            y = yPrev - q * y;
-            yPrev = tmp;
-            tmp = b;
-            b = a % b;
-            a = tmp;
-        }
-        return {
-            x: new NativeBigInteger(aNegated ? -xPrev : xPrev),
-            y: new NativeBigInteger(bNegated ? -yPrev : yPrev),
-            gcd: new NativeBigInteger(a),
-        };
-    }
-    /**
-     * Compute greatest common divisor between this and n
-     * @param {BigInteger} b - Operand
-     * @returns {BigInteger} gcd
-     */
-    gcd(bInput) {
-        let a = this.value;
-        let b = bInput.value;
-        while (b !== BigInt(0)) {
-            const tmp = b;
-            b = a % b;
-            a = tmp;
-        }
-        return new NativeBigInteger(a);
-    }
-    /**
-     * Shift this to the left by x, in place
-     * @param {BigInteger} x - Shift value
-     */
-    ileftShift(x) {
-        this.value <<= x.value;
-        return this;
-    }
-    /**
-     * Shift this to the left by x
-     * @param {BigInteger} x - Shift value
-     * @returns {BigInteger} this << x.
-     */
-    leftShift(x) {
-        return this.clone().ileftShift(x);
-    }
-    /**
-     * Shift this to the right by x, in place
-     * @param {BigInteger} x - Shift value
-     */
-    irightShift(x) {
-        this.value >>= x.value;
-        return this;
-    }
-    /**
-     * Shift this to the right by x
-     * @param {BigInteger} x - Shift value
-     * @returns {BigInteger} this >> x.
-     */
-    rightShift(x) {
-        return this.clone().irightShift(x);
-    }
-    ixor(x) {
-        this.value ^= x.value;
-        return this;
-    }
-    xor(x) {
-        return this.clone().ixor(x);
-    }
-    ibitwiseAnd(x) {
-        this.value &= x.value;
-        return this;
-    }
-    bitwiseAnd(x) {
-        return this.clone().ibitwiseAnd(x);
-    }
-    ibitwiseOr(x) {
-        this.value |= x.value;
-        return this;
-    }
-    /**
-     * Whether this value is equal to x
-     * @param {BigInteger} x
-     * @returns {Boolean}
-     */
-    equal(x) {
-        return this.value === x.value;
-    }
-    /**
-     * Whether this value is less than x
-     * @param {BigInteger} x
-     * @returns {Boolean}
-     */
-    lt(x) {
-        return this.value < x.value;
-    }
-    /**
-     * Whether this value is less than or equal to x
-     * @param {BigInteger} x
-     * @returns {Boolean}
-     */
-    lte(x) {
-        return this.value <= x.value;
-    }
-    /**
-     * Whether this value is greater than x
-     * @param {BigInteger} x
-     * @returns {Boolean}
-     */
-    gt(x) {
-        return this.value > x.value;
-    }
-    /**
-     * Whether this value is greater than or equal to x
-     * @param {BigInteger} x
-     * @returns {Boolean}
-     */
-    gte(x) {
-        return this.value >= x.value;
-    }
-    isZero() {
-        return this.value === BigInt(0);
-    }
-    isOne() {
-        return this.value === BigInt(1);
-    }
-    isNegative() {
-        return this.value < BigInt(0);
-    }
-    isEven() {
-        return !(this.value & BigInt(1));
-    }
-    abs() {
-        const res = this.clone();
-        if (this.isNegative()) {
-            res.value = -res.value;
-        }
-        return res;
-    }
-    negate() {
-        const res = this.clone();
-        res.value = -res.value;
-        return res;
-    }
-    /**
-     * Get this value as a string
-     * @returns {String} this value.
-     */
-    toString() {
-        return this.value.toString();
-    }
-    /**
-     * Get this value as an exact Number (max 53 bits)
-     * Fails if this value is too large
-     * @returns {Number}
-     */
-    toNumber() {
-        const number = Number(this.value);
-        if (number > Number.MAX_SAFE_INTEGER) {
-            // We throw and error to conform with the bn.js implementation
-            throw new Error('Number can only safely store up to 53 bits');
-        }
-        return number;
-    }
-    /**
-     * Get value of i-th bit
-     * @param {Number} i - Bit index
-     * @returns {Number} Bit value.
-     */
-    getBit(i) {
-        const bit = (this.value >> BigInt(i)) & BigInt(1);
-        return bit === BigInt(0) ? 0 : 1;
-    }
-    /**
-     * Compute bit length
-     * @returns {Number} Bit length.
-     */
-    bitLength() {
-        const zero = new NativeBigInteger(0);
-        const one = new NativeBigInteger(1);
-        const negOne = new NativeBigInteger(-1);
-        // -1n >> -1n is -1n
-        // 1n >> 1n is 0n
-        const target = this.isNegative() ? negOne : zero;
-        let bitlen = 1;
-        const tmp = this.clone();
-        while (!tmp.irightShift(one).equal(target)) {
-            bitlen++;
-        }
-        return bitlen;
-    }
-    /**
-     * Compute byte length
-     * @returns {Number} Byte length.
-     */
-    byteLength() {
-        const zero = new NativeBigInteger(0);
-        const negOne = new NativeBigInteger(-1);
-        const target = this.isNegative() ? negOne : zero;
-        const eight = new NativeBigInteger(8);
-        let len = 1;
-        const tmp = this.clone();
-        while (!tmp.irightShift(eight).equal(target)) {
-            len++;
-        }
-        return len;
-    }
-    /**
-     * Get Uint8Array representation of this number
-     * @param {String} endian - Endianess of output array (defaults to 'be')
-     * @param {Number} length - Of output array
-     * @returns {Uint8Array}
-     */
-    toUint8Array(endian = 'be', length) {
-        // we get and parse the hex string (https://coolaj86.com/articles/convert-js-bigints-to-typedarrays/)
-        // this is faster than shift+mod iterations
-        let hex = this.value.toString(16);
-        if (hex.length % 2 === 1) {
-            hex = '0' + hex;
-        }
-        const rawLength = hex.length / 2;
-        const bytes = new Uint8Array(length || rawLength);
-        // parse hex
-        const offset = length ? length - rawLength : 0;
-        let i = 0;
-        while (i < rawLength) {
-            bytes[i + offset] = parseInt(hex.slice(2 * i, 2 * i + 2), 16);
-            i++;
-        }
-        if (endian !== 'be') {
-            bytes.reverse();
-        }
-        return bytes;
-    }
-}
-
-export { NativeBigInteger as default };