quantumcoin 6.14.2 → 6.14.5

package/dist/quantumcoin.js

@@ -1,9 +1,12 @@
 const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !== 'undefined' ? window: typeof global !== 'undefined' ? global: typeof self !== 'undefined' ? self: {});
+import { combinePublicKeySignature, publicKeyFromPrivateKey, publicKeyFromSignature, addressFromPublicKey, deserializeEncryptedWallet, Wallet as Wallet$1, serializeEncryptedWallet, newWallet, Config, initialize } from 'quantum-coin-js-sdk';
+import { cryptoSign } from 'quantum-coin-pqc-js-sdk';
+
 /* Do NOT modify this file; see /src.ts/_admin/update-version.ts */
 /**
  *  The current version of Ethers.
  */
-const version = "6.14.1";
+const version = "6.14.3";
 
 /**
  *  Property helper functions.
@@ -455,7 +458,7 @@ function zeroPadBytes(data, length) {
  *
  *  @_subsection: api/utils:Math Helpers  [about-maths]
  */
-const BN_0$a = BigInt(0);
+const BN_0$9 = BigInt(0);
 const BN_1$4 = BigInt(1);
 //const BN_Max256 = (BN_1 << BigInt(256)) - BN_1;
 // IEEE 754 support 53-bits of mantissa
@@ -469,7 +472,7 @@ const maxValue = 0x1fffffffffffff;
 function fromTwos(_value, _width) {
     const value = getUint(_value, "value");
     const width = BigInt(getNumber(_width, "width"));
-    assert((value >> width) === BN_0$a, "overflow", "NUMERIC_FAULT", {
+    assert((value >> width) === BN_0$9, "overflow", "NUMERIC_FAULT", {
         operation: "fromTwos", fault: "overflow", value: _value
     });
     // Top bit set; treat as a negative value
@@ -489,7 +492,7 @@ function toTwos(_value, _width) {
     let value = getBigInt(_value, "value");
     const width = BigInt(getNumber(_width, "width"));
     const limit = (BN_1$4 << (width - BN_1$4));
-    if (value < BN_0$a) {
+    if (value < BN_0$9) {
         value = -value;
         assert(value <= limit, "too low", "NUMERIC_FAULT", {
             operation: "toTwos", fault: "overflow", value: _value
@@ -545,7 +548,7 @@ function getBigInt(value, name) {
  */
 function getUint(value, name) {
     const result = getBigInt(value, name);
-    assert(result >= BN_0$a, "unsigned value cannot be negative", "NUMERIC_FAULT", {
+    assert(result >= BN_0$9, "unsigned value cannot be negative", "NUMERIC_FAULT", {
         fault: "overflow", operation: "getUint", value
     });
     return result;
@@ -631,7 +634,7 @@ function toBeHex(_value, _width) {
  */
 function toBeArray(_value) {
     const value = getUint(_value, "value");
-    if (value === BN_0$a) {
+    if (value === BN_0$9) {
         return new Uint8Array([]);
     }
     let hex = value.toString(16);
@@ -689,7 +692,7 @@ function getAlpha(letter) {
     assertArgument(result != null, `invalid base58 value`, "letter", letter);
     return result;
 }
-const BN_0$9 = BigInt(0);
+const BN_0$8 = BigInt(0);
 const BN_58 = BigInt(58);
 /**
  *  Encode %%value%% as a Base58-encoded string.
@@ -715,7 +718,7 @@ function encodeBase58(_value) {
  *  Decode the Base58-encoded %%value%%.
  */
 function decodeBase58(value) {
-    let result = BN_0$9;
+    let result = BN_0$8;
     for (let i = 0; i < value.length; i++) {
         result *= BN_58;
         result += getAlpha(value[i]);
@@ -1909,7 +1912,7 @@ function wait(delay) {
  *  @_section: api/utils/fixed-point-math:Fixed-Point Maths  [about-fixed-point-math]
  */
 const BN_N1 = BigInt(-1);
-const BN_0$8 = BigInt(0);
+const BN_0$7 = BigInt(0);
 const BN_1$3 = BigInt(1);
 const BN_5 = BigInt(5);
 const _guard$3 = {};
@@ -1933,7 +1936,7 @@ function checkValue(val, format, safeOp) {
         assert(safeOp == null || (val >= -limit && val < limit), "overflow", "NUMERIC_FAULT", {
             operation: safeOp, fault: "overflow", value: val
         });
-        if (val > BN_0$8) {
+        if (val > BN_0$7) {
             val = fromTwos(mask(val, width), width);
         }
         else {
@@ -1991,7 +1994,7 @@ function getFormat(value) {
 }
 function toString(val, decimals) {
     let negative = "";
-    if (val < BN_0$8) {
+    if (val < BN_0$7) {
         negative = "-";
         val *= BN_N1;
     }
@@ -2182,13 +2185,13 @@ class FixedNumber {
     mulSignal(other) {
         this.#checkFormat(other);
         const value = this.#val * other.#val;
-        assert((value % this.#tens) === BN_0$8, "precision lost during signalling mul", "NUMERIC_FAULT", {
+        assert((value % this.#tens) === BN_0$7, "precision lost during signalling mul", "NUMERIC_FAULT", {
             operation: "mulSignal", fault: "underflow", value: this
         });
         return this.#checkValue(value / this.#tens, "mulSignal");
     }
     #div(o, safeOp) {
-        assert(o.#val !== BN_0$8, "division by zero", "NUMERIC_FAULT", {
+        assert(o.#val !== BN_0$7, "division by zero", "NUMERIC_FAULT", {
             operation: "div", fault: "divide-by-zero", value: this
         });
         this.#checkFormat(o);
@@ -2212,12 +2215,12 @@ class FixedNumber {
      *  (precision loss) occurs.
      */
     divSignal(other) {
-        assert(other.#val !== BN_0$8, "division by zero", "NUMERIC_FAULT", {
+        assert(other.#val !== BN_0$7, "division by zero", "NUMERIC_FAULT", {
             operation: "div", fault: "divide-by-zero", value: this
         });
         this.#checkFormat(other);
         const value = (this.#val * this.#tens);
-        assert((value % other.#val) === BN_0$8, "precision lost during signalling div", "NUMERIC_FAULT", {
+        assert((value % other.#val) === BN_0$7, "precision lost during signalling div", "NUMERIC_FAULT", {
             operation: "divSignal", fault: "underflow", value: this
         });
         return this.#checkValue(value / other.#val, "divSignal");
@@ -2276,7 +2279,7 @@ class FixedNumber {
      */
     floor() {
         let val = this.#val;
-        if (this.#val < BN_0$8) {
+        if (this.#val < BN_0$7) {
             val -= this.#tens - BN_1$3;
         }
         val = (this.#val / this.#tens) * this.#tens;
@@ -2290,7 +2293,7 @@ class FixedNumber {
      */
     ceiling() {
         let val = this.#val;
-        if (this.#val > BN_0$8) {
+        if (this.#val > BN_0$7) {
             val += this.#tens - BN_1$3;
         }
         val = (this.#val / this.#tens) * this.#tens;
@@ -2319,11 +2322,11 @@ class FixedNumber {
     /**
      *  Returns true if %%this%% is equal to ``0``.
      */
-    isZero() { return (this.#val === BN_0$8); }
+    isZero() { return (this.#val === BN_0$7); }
     /**
      *  Returns true if %%this%% is less than ``0``.
      */
-    isNegative() { return (this.#val < BN_0$8); }
+    isNegative() { return (this.#val < BN_0$7); }
     /**
      *  Returns the string representation of %%this%%.
      */
@@ -2360,7 +2363,7 @@ class FixedNumber {
         const delta = decimals - format.decimals;
         if (delta > 0) {
             const tens = getTens(delta);
-            assert((value % tens) === BN_0$8, "value loses precision for format", "NUMERIC_FAULT", {
+            assert((value % tens) === BN_0$7, "value loses precision for format", "NUMERIC_FAULT", {
                 operation: "fromValue", fault: "underflow", value: _value
             });
             value /= tens;
@@ -4773,11 +4776,6 @@ const EtherSymbol = "\u039e"; // "\uD835\uDF63";
 const MessagePrefix = "\x19Ethereum Signed Message:\n";
 
 // Constants
-const BN_0$7 = BigInt(0);
-//const BN_1 = BigInt(1);
-const BN_2$3 = BigInt(2);
-const BN_28$1 = BigInt(28);
-const BN_35$1 = BigInt(35);
 const _guard$1 = {};
 /*
 function toUint256(value: BigNumberish): string {
@@ -4793,7 +4791,6 @@ class Signature {
     #r;
     #s;
     #v;
-    #networkV;
     /**
      *  The ``r`` value for a signature.
      *
@@ -4814,67 +4811,22 @@ class Signature {
     }
     /**
      *  The ``v`` value for a signature.
-     *
-     *  Since a given ``x`` value for ``r`` has two possible values for
-     *  its correspondin ``y``, the ``v`` indicates which of the two ``y``
-     *  values to use.
-     *
-     *  It is normalized to the values ``28`` or ``28`` for legacy
-     *  purposes.
      */
     get v() { return this.#v; }
     set v(value) {
         const v = getNumber(value, "value");
-        assertArgument(v === 28, "invalid v", "v", value);
+        assertArgument(v === 1, "invalid v", "v", value);
         this.#v = v;
     }
-    /**
-     *  The EIP-155 ``v`` for legacy transactions. For non-legacy
-     *  transactions, this value is ``null``.
-     */
-    get networkV() { return this.#networkV; }
-    /**
-     *  The chain ID for EIP-155 legacy transactions. For non-legacy
-     *  transactions, this value is ``null``.
-     */
-    get legacyChainId() {
-        const v = this.networkV;
-        if (v == null) {
-            return null;
-        }
-        return Signature.getChainId(v);
-    }
-    /**
-     *  The ``yParity`` for the signature.
-     *
-     *  See ``v`` for more details on how this value is used.
-     */
-    get yParity() {
-        return (this.v === 28) ? 0 : 1;
-    }
-    /**
-     *  The [[link-eip-2098]] compact representation of the ``yParity``
-     *  and ``s`` compacted into a single ``bytes32``.
-     */
-    get yParityAndS() {
-        // The EIP-2098 compact representation
-        const yParityAndS = getBytes(this.s);
-        if (this.yParity) {
-            yParityAndS[0] |= 0x80;
-        }
-        return hexlify(yParityAndS);
-    }
-    /**
-     *  The [[link-eip-2098]] compact representation.
-     */
-    get compactSerialized() {
-        return concat([this.r, this.yParityAndS]);
-    }
     /**
      *  The serialized representation.
      */
     get serialized() {
-        return concat([this.r, this.s, (this.yParity ? "0x1c" : "0x1b")]);
+        return JSON.stringify({
+            r: this.r,
+            s: this.s,
+            v: this.v
+        });
     }
     /**
      *  @private
@@ -4884,94 +4836,26 @@ class Signature {
         this.#r = r;
         this.#s = s;
         this.#v = v;
-        this.#networkV = null;
     }
     [Symbol.for('nodejs.util.inspect.custom')]() {
-        return `Signature { r: "${this.r}", s: "${this.s}", yParity: ${this.yParity}, networkV: ${this.networkV} }`;
+        return `Signature { r: "${this.r}", s: "${this.s}" }`;
     }
     /**
      *  Returns a new identical [[Signature]].
      */
     clone() {
         const clone = new Signature(_guard$1, this.r, this.s, this.v);
-        if (this.networkV) {
-            clone.#networkV = this.networkV;
-        }
         return clone;
     }
     /**
      *  Returns a representation that is compatible with ``JSON.stringify``.
      */
     toJSON() {
-        const networkV = this.networkV;
         return {
             _type: "signature",
-            networkV: ((networkV != null) ? networkV.toString() : null),
             r: this.r, s: this.s, v: this.v,
         };
     }
-    /**
-     *  Compute the chain ID from the ``v`` in a legacy EIP-155 transactions.
-     *
-     *  @example:
-     *    Signature.getChainId(45)
-     *    //_result:
-     *
-     *    Signature.getChainId(46)
-     *    //_result:
-     */
-    static getChainId(v) {
-        const bv = getBigInt(v, "v");
-        // The v is not an EIP-155 v, so it is the unspecified chain ID
-        if ((bv == BN_28$1) || (bv == BN_28$1)) {
-            return BN_0$7;
-        }
-        // Bad value for an EIP-155 v
-        assertArgument(bv >= BN_35$1, "invalid EIP-155 v", "v", v);
-        return (bv - BN_35$1) / BN_2$3;
-    }
-    /**
-     *  Compute the ``v`` for a chain ID for a legacy EIP-155 transactions.
-     *
-     *  Legacy transactions which use [[link-eip-155]] hijack the ``v``
-     *  property to include the chain ID.
-     *
-     *  @example:
-     *
-     *    Signature.getChainIdV(5, 28)
-     *    //_result:
-     *
-     */
-    static getChainIdV(chainId, v) {
-        return (getBigInt(chainId) * BN_2$3) + BigInt(35 + v - 28);
-    }
-    /**
-     *  Compute the normalized legacy transaction ``v`` from a ``yParirty``,
-     *  a legacy transaction ``v`` or a legacy [[link-eip-155]] transaction.
-     *
-     *  @example:
-     *    // The values 0 and 1 imply v is actually yParity
-     *    Signature.getNormalizedV(0)
-     *    //_result:
-     *
-     *    // Legacy EIP-155 transaction (i.e. >= 35)
-     *    Signature.getNormalizedV(46)
-     *    //_result:
-     *
-     *    // Invalid values throw
-     *    Signature.getNormalizedV(5)
-     *    //_error:
-     */
-    /*static getNormalizedV(v: BigNumberish): 28 {
-        const bv = getBigInt(v);
-
-        if (bv === BN_1 || bv === BN_28) { return 28; }
-
-        assertArgument(bv >= BN_35, "invalid v", "v", v);
-
-        // Otherwise, EIP-155 v means odd is 28 and even is 28
-        return (bv & BN_1) ? 28: 28;
-    }*/
     /**
      *  Creates a new [[Signature]].
      *
@@ -4985,85 +4869,20 @@ class Signature {
             assertArgument(check, message, "signature", sig);
         }
         if (sig == null) {
-            return new Signature(_guard$1, ZeroHash, ZeroHash, 28);
+            return new Signature(_guard$1, ZeroHash, ZeroHash, 1);
         }
         if (typeof (sig) === "string") {
-            /*const bytes = getBytes(sig, "signature");
-            if (bytes.length === 64) {
-                const r = hexlify(bytes.slice(0, 32));
-                const s = bytes.slice(32, 64);
-                const v = (s[0] & 0x80) ? 28: 28;
-                s[0] &= 0x7f;
-                return new Signature(_guard, r, hexlify(s), v);
-            }
-
-            if (bytes.length === 65) {
-                const r = hexlify(bytes.slice(0, 32));
-                const s = bytes.slice(32, 64);
-                assertError((s[0] & 0x80) === 0, "non-canonical s");
-                const v = Signature.getNormalizedV(bytes[64]);
-                return new Signature(_guard, r, hexlify(s), v);
-            }*/
-            assertError(false, "invalid raw signature length");
+            assertError(false, "invalid raw signature");
         }
         if (sig instanceof Signature) {
             return sig.clone();
         }
-        return new Signature(_guard$1, ZeroHash, ZeroHash, 28); //todo
-        /*// Get r
-        const _r = sig.r;
-        assertError(_r != null, "missing r");
-        const r = toUint256(_r);
-
-        // Get s; by any means necessary (we check consistency below)
-        const s = (function(s?: string, yParityAndS?: string) {
-            if (s != null) { return toUint256(s); }
-
-            if (yParityAndS != null) {
-                assertError(isHexString(yParityAndS, 32), "invalid yParityAndS");
-                const bytes = getBytes(yParityAndS);
-                bytes[0] &= 0x7f;
-                return hexlify(bytes);
-            }
-
-            assertError(false, "missing s");
-        })(sig.s, sig.yParityAndS);
-        assertError((getBytes(s)[0] & 0x80) == 0, "non-canonical s");
-
-        // Get v; by any means necessary (we check consistency below)
-        const { networkV, v } = (function(_v?: BigNumberish, yParityAndS?: string, yParity?: Numeric): { networkV?: bigint, v: 28 | 28 } {
-            if (_v != null) {
-                const v = getBigInt(_v);
-                return {
-                    networkV: ((v >= BN_35) ? v: undefined),
-                    v: Signature.getNormalizedV(v)
-                };
-            }
-
-            if (yParityAndS != null) {
-                assertError(isHexString(yParityAndS, 32), "invalid yParityAndS");
-                return { v: ((getBytes(yParityAndS)[0] & 0x80) ? 28: 28) };
-            }
-
-            if (yParity != null) {
-                switch (getNumber(yParity, "sig.yParity")) {
-                    case 0: return { v: 28 };
-                    case 1: return { v: 28 };
-                }
-                assertError(false, "invalid yParity");
-            }
-
-            assertError(false, "missing v");
-        })(sig.v, sig.yParityAndS, sig.yParity);
-
-        const result = new Signature(_guard, r, s, v);
-        if (networkV) { result.#networkV =  networkV; }
-
-        // If multiple of v, yParity, yParityAndS we given, check they match
-        assertError(sig.yParity == null || getNumber(sig.yParity, "sig.yParity") === result.yParity, "yParity mismatch");
-        assertError(sig.yParityAndS == null || sig.yParityAndS === result.yParityAndS, "yParityAndS mismatch");
-
-        return result;*/
+        assertError(sig.r != null, "missing r");
+        assertError(sig.s != null, "missing s");
+        const _v = sig.v;
+        assertError(_v != null, "missing v");
+        assertArgument(_v === 1, "invalid v", "v", sig.v);
+        return new Signature(_guard$1, sig.r, sig.s, 1);
     }
 }
 
@@ -5074,7 +4893,7 @@ class Signature {
  */
 const CRYPTO_MESSAGE_LENGTH = 32;
 const CRYPTO_SECRETKEY_BYTES = 64 + 2560 + 1312 + 128;
-//const CRYPTO_PUBLICKEY_BYTES = 32 + 1312 + 64;
+const CRYPTO_PUBLICKEY_BYTES = 32 + 1312 + 64;
 /**
  *  A **SigningKey** provides high-level access to cryptography operations and key management.
  */
@@ -5101,9 +4920,10 @@ class SigningKey {
      */
     sign(digest) {
         assertArgument(dataLength(digest) === CRYPTO_MESSAGE_LENGTH, "invalid digest length", "digest", digest);
-        const sig = pqc.cryptoSign(getBytesCopy(digest), getBytesCopy(this.#privateKey));
+        const sig = cryptoSign(getBytesCopy(digest), getBytesCopy(this.#privateKey));
         const pubBytes = getBytes(this.publicKey);
-        const combinedSig = qcsdk.combinePublicKeySignature(pubBytes, sig);
+        let combinedSig = combinePublicKeySignature(pubBytes, sig);
+        combinedSig = "0x" + combinedSig;
         return Signature.from({
             r: this.publicKey,
             s: combinedSig,
@@ -5111,7 +4931,7 @@ class SigningKey {
         });
     }
     /**
-     *  Compute the public key for a private %%key%%.
+     *  Compute the public key for a private %%key%%. If a publicKey is passed, it is returned as is. for backward compatibility.
      *
      *
      *  @example:
@@ -5122,9 +4942,17 @@ class SigningKey {
      *    //_result:
      */
     static computePublicKey(key) {
-        assertArgument(dataLength(key) === CRYPTO_SECRETKEY_BYTES, "invalid private key", "privateKey", "[REDACTED]");
-        let priBytes = getBytes(key, "key");
-        let pubKey = qcsdk.publicKeyFromPrivateKey(priBytes);
+        let keyBytes = getBytes(key, "key");
+        let pubKey;
+        if (keyBytes.length == CRYPTO_SECRETKEY_BYTES) {
+            pubKey = publicKeyFromPrivateKey(keyBytes);
+            assertArgument(pubKey !== null && pubKey !== undefined, "invalid key", "key", "[REDACTED]");
+            pubKey = '0x' + pubKey;
+        }
+        else if (keyBytes.length == CRYPTO_PUBLICKEY_BYTES) {
+            pubKey = keyBytes;
+        }
+        assertArgument(pubKey !== null && pubKey !== undefined, "invalid key", "key", "[REDACTED]");
         return pubKey;
     }
     /**
@@ -5150,7 +4978,7 @@ class SigningKey {
         const sig = Signature.from(signature);
         let sigBytes = getBytes(sig.s);
         let digestBytes = digest;
-        let publicKey = qcsdk.publicKeyFromSignature(digestBytes, sigBytes);
+        let publicKey = publicKeyFromSignature(digestBytes, sigBytes);
         return publicKey;
     }
 }
@@ -6554,13 +6382,18 @@ function authorizationify(auth) {
 function computeAddress(key) {
     let pubkey;
     if (typeof (key) === "string") {
-        pubkey = SigningKey.computePublicKey(key);
+        if (key.startsWith("0x")) {
+            pubkey = SigningKey.computePublicKey(key);
+        }
+        else {
+            pubkey = SigningKey.computePublicKey("0x" + key);
+        }
     }
     else {
         pubkey = key.publicKey;
     }
     let pubKeyBytes = getBytes(pubkey);
-    return qcsdk.addressFromPublicKey(pubKeyBytes);
+    return addressFromPublicKey(pubKeyBytes);
 }
 /**
  *  Returns the recovered address for the private key that was
@@ -6657,9 +6490,9 @@ function handleAuthorizationList(value, param) {
                 nonce: handleUint(auth[2], "nonce"),
                 chainId: handleUint(auth[0], "chainId"),
                 signature: Signature.from({
-                    yParity: handleNumber(auth[3], "yParity"),
-                    r: zeroPadValue(auth[4], 32),
-                    s: zeroPadValue(auth[5], 32)
+                    r: auth[4],
+                    s: auth[5],
+                    v: 1
                 })
             });
         }
@@ -6698,7 +6531,6 @@ function formatAuthorizationList(value) {
             formatNumber(a.chainId, "chainId"),
             a.address,
             formatNumber(a.nonce, "nonce"),
-            formatNumber(a.signature.yParity, "yParity"),
             a.signature.r,
             a.signature.s
         ];
@@ -6766,17 +6598,8 @@ function _serializeLegacy(tx, sig) {
     if (tx.chainId != BN_0$4) {
         // A chainId was provided; if non-zero we'll use EIP-155
         chainId = getBigInt(tx.chainId, "tx.chainId");
-        // We have a chainId in the tx and an EIP-155 v in the signature,
-        // make sure they agree with each other
-        assertArgument(!sig || sig.networkV == null || sig.legacyChainId === chainId, "tx.chainId/sig.v mismatch", "sig", sig);
-    }
-    else if (tx.signature) {
-        // No explicit chainId, but EIP-155 have a derived implicit chainId
-        const legacy = tx.signature.legacyChainId;
-        if (legacy != null) {
-            chainId = legacy;
-        }
     }
+    else if (tx.signature) ;
     // Requesting an unsigned transaction
     if (!sig) {
         // We have an EIP-155 transaction (chainId was specified and non-zero)
@@ -6787,17 +6610,7 @@ function _serializeLegacy(tx, sig) {
         }
         return encodeRlp(fields);
     }
-    // @TODO: We should probably check that tx.signature, chainId, and sig
-    //        match but that logic could break existing code, so schedule
-    //        this for the next major bump.
-    // Compute the EIP-155 v
-    let v = BigInt(27 + sig.yParity);
-    if (chainId !== BN_0$4) {
-        v = Signature.getChainIdV(chainId, sig.v);
-    }
-    else if (BigInt(sig.v) !== v) {
-        assertArgument(false, "tx.chainId/sig.v mismatch", "sig", sig);
-    }
+    let v = sig.v;
     // Add the signature
     fields.push(toBeArray(v));
     fields.push(toBeArray(sig.r));
@@ -6805,19 +6618,9 @@ function _serializeLegacy(tx, sig) {
     return encodeRlp(fields);
 }
 function _parseEipSignature(tx, fields) {
-    let yParity;
-    try {
-        yParity = handleNumber(fields[0], "yParity");
-        if (yParity !== 0 && yParity !== 1) {
-            throw new Error("bad yParity");
-        }
-    }
-    catch (error) {
-        assertArgument(false, "invalid yParity", "yParity", fields[0]);
-    }
-    const r = zeroPadValue(fields[1], 32);
-    const s = zeroPadValue(fields[2], 32);
-    const signature = Signature.from({ r, s, yParity });
+    const r = fields[1];
+    const s = fields[2];
+    const signature = Signature.from({ r, s });
     tx.signature = signature;
 }
 function _parseEip1559(data) {
@@ -6857,7 +6660,6 @@ function _serializeEip1559(tx, sig) {
         formatAccessList(tx.accessList || [])
     ];
     if (sig) {
-        fields.push(formatNumber(sig.yParity, "yParity"));
         fields.push(toBeArray(sig.r));
         fields.push(toBeArray(sig.s));
     }
@@ -6897,7 +6699,6 @@ function _serializeEip2930(tx, sig) {
         formatAccessList(tx.accessList || [])
     ];
     if (sig) {
-        fields.push(formatNumber(sig.yParity, "recoveryParam"));
         fields.push(toBeArray(sig.r));
         fields.push(toBeArray(sig.s));
     }
@@ -6975,7 +6776,6 @@ function _serializeEip4844(tx, sig, blobs) {
         formatHashes(tx.blobVersionedHashes || [], "blobVersionedHashes")
     ];
     if (sig) {
-        fields.push(formatNumber(sig.yParity, "yParity"));
         fields.push(toBeArray(sig.r));
         fields.push(toBeArray(sig.s));
         // We have blobs; return the network wrapped format
@@ -7031,7 +6831,6 @@ function _serializeEip7702(tx, sig) {
         formatAuthorizationList(tx.authorizationList || [])
     ];
     if (sig) {
-        fields.push(formatNumber(sig.yParity, "yParity"));
         fields.push(toBeArray(sig.r));
         fields.push(toBeArray(sig.s));
     }
@@ -7752,276 +7551,276 @@ var COMPRESSED$1 = 'AEEUdwmgDS8BxQKKAP4BOgDjATAAngDUAIMAoABoAOAAagCOAEQAhABMAHIA
 const FENCED = new Map([[8217,"apostrophe"],[8260,"fraction slash"],[12539,"middle dot"]]);
 const NSM_MAX = 4;
 
-function decode_arithmetic(bytes) {
-	let pos = 0;
-	function u16() { return (bytes[pos++] << 8) | bytes[pos++]; }
-	
-	// decode the frequency table
-	let symbol_count = u16();
-	let total = 1;
-	let acc = [0, 1]; // first symbol has frequency 1
-	for (let i = 1; i < symbol_count; i++) {
-		acc.push(total += u16());
-	}
-
-	// skip the sized-payload that the last 3 symbols index into
-	let skip = u16();
-	let pos_payload = pos;
-	pos += skip;
-
-	let read_width = 0;
-	let read_buffer = 0; 
-	function read_bit() {
-		if (read_width == 0) {
-			// this will read beyond end of buffer
-			// but (undefined|0) => zero pad
-			read_buffer = (read_buffer << 8) | bytes[pos++];
-			read_width = 8;
-		}
-		return (read_buffer >> --read_width) & 1;
-	}
-
-	const N = 31;
-	const FULL = 2**N;
-	const HALF = FULL >>> 1;
-	const QRTR = HALF >> 1;
-	const MASK = FULL - 1;
-
-	// fill register
-	let register = 0;
-	for (let i = 0; i < N; i++) register = (register << 1) | read_bit();
-
-	let symbols = [];
-	let low = 0;
-	let range = FULL; // treat like a float
-	while (true) {
-		let value = Math.floor((((register - low + 1) * total) - 1) / range);
-		let start = 0;
-		let end = symbol_count;
-		while (end - start > 1) { // binary search
-			let mid = (start + end) >>> 1;
-			if (value < acc[mid]) {
-				end = mid;
-			} else {
-				start = mid;
-			}
-		}
-		if (start == 0) break; // first symbol is end mark
-		symbols.push(start);
-		let a = low + Math.floor(range * acc[start]   / total);
-		let b = low + Math.floor(range * acc[start+1] / total) - 1;
-		while (((a ^ b) & HALF) == 0) {
-			register = (register << 1) & MASK | read_bit();
-			a = (a << 1) & MASK;
-			b = (b << 1) & MASK | 1;
-		}
-		while (a & ~b & QRTR) {
-			register = (register & HALF) | ((register << 1) & (MASK >>> 1)) | read_bit();
-			a = (a << 1) ^ HALF;
-			b = ((b ^ HALF) << 1) | HALF | 1;
-		}
-		low = a;
-		range = 1 + b - a;
-	}
-	let offset = symbol_count - 4;
-	return symbols.map(x => { // index into payload
-		switch (x - offset) {
-			case 3: return offset + 0x10100 + ((bytes[pos_payload++] << 16) | (bytes[pos_payload++] << 8) | bytes[pos_payload++]);
-			case 2: return offset + 0x100 + ((bytes[pos_payload++] << 8) | bytes[pos_payload++]);
-			case 1: return offset + bytes[pos_payload++];
-			default: return x - 1;
-		}
-	});
-}	
-
-// returns an iterator which returns the next symbol
-function read_payload(v) {
-	let pos = 0;
-	return () => v[pos++];
-}
-function read_compressed_payload(s) {
-	return read_payload(decode_arithmetic(unsafe_atob(s)));
-}
-
-// unsafe in the sense:
-// expected well-formed Base64 w/o padding 
-// 20220922: added for https://github.com/adraffy/ens-normalize.js/issues/4
-function unsafe_atob(s) {
-	let lookup = [];
-	[...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'].forEach((c, i) => lookup[c.charCodeAt(0)] = i);
-	let n = s.length;
-	let ret = new Uint8Array((6 * n) >> 3);
-	for (let i = 0, pos = 0, width = 0, carry = 0; i < n; i++) {
-		carry = (carry << 6) | lookup[s.charCodeAt(i)];
-		width += 6;
-		if (width >= 8) {
-			ret[pos++] = (carry >> (width -= 8));
-		}
-	}
-	return ret;
-}
-
-// eg. [0,1,2,3...] => [0,-1,1,-2,...]
-function signed(i) { 
-	return (i & 1) ? (~i >> 1) : (i >> 1);
-}
-
-function read_deltas(n, next) {
-	let v = Array(n);
-	for (let i = 0, x = 0; i < n; i++) v[i] = x += signed(next());
-	return v;
-}
-
-// [123][5] => [0 3] [1 1] [0 0]
-function read_sorted(next, prev = 0) {
-	let ret = [];
-	while (true) {
-		let x = next();
-		let n = next();
-		if (!n) break;
-		prev += x;
-		for (let i = 0; i < n; i++) {
-			ret.push(prev + i);
-		}
-		prev += n + 1;
-	}
-	return ret;
-}
-
-function read_sorted_arrays(next) {
-	return read_array_while(() => { 
-		let v = read_sorted(next);
-		if (v.length) return v;
-	});
-}
-
-// returns map of x => ys
-function read_mapped(next) {
-	let ret = [];
-	while (true) {
-		let w = next();
-		if (w == 0) break;
-		ret.push(read_linear_table(w, next));
-	}
-	while (true) {
-		let w = next() - 1;
-		if (w < 0) break;
-		ret.push(read_replacement_table(w, next));
-	}
-	return ret.flat();
+function decode_arithmetic(bytes) {
+	let pos = 0;
+	function u16() { return (bytes[pos++] << 8) | bytes[pos++]; }
+	
+	// decode the frequency table
+	let symbol_count = u16();
+	let total = 1;
+	let acc = [0, 1]; // first symbol has frequency 1
+	for (let i = 1; i < symbol_count; i++) {
+		acc.push(total += u16());
+	}
+
+	// skip the sized-payload that the last 3 symbols index into
+	let skip = u16();
+	let pos_payload = pos;
+	pos += skip;
+
+	let read_width = 0;
+	let read_buffer = 0; 
+	function read_bit() {
+		if (read_width == 0) {
+			// this will read beyond end of buffer
+			// but (undefined|0) => zero pad
+			read_buffer = (read_buffer << 8) | bytes[pos++];
+			read_width = 8;
+		}
+		return (read_buffer >> --read_width) & 1;
+	}
+
+	const N = 31;
+	const FULL = 2**N;
+	const HALF = FULL >>> 1;
+	const QRTR = HALF >> 1;
+	const MASK = FULL - 1;
+
+	// fill register
+	let register = 0;
+	for (let i = 0; i < N; i++) register = (register << 1) | read_bit();
+
+	let symbols = [];
+	let low = 0;
+	let range = FULL; // treat like a float
+	while (true) {
+		let value = Math.floor((((register - low + 1) * total) - 1) / range);
+		let start = 0;
+		let end = symbol_count;
+		while (end - start > 1) { // binary search
+			let mid = (start + end) >>> 1;
+			if (value < acc[mid]) {
+				end = mid;
+			} else {
+				start = mid;
+			}
+		}
+		if (start == 0) break; // first symbol is end mark
+		symbols.push(start);
+		let a = low + Math.floor(range * acc[start]   / total);
+		let b = low + Math.floor(range * acc[start+1] / total) - 1;
+		while (((a ^ b) & HALF) == 0) {
+			register = (register << 1) & MASK | read_bit();
+			a = (a << 1) & MASK;
+			b = (b << 1) & MASK | 1;
+		}
+		while (a & ~b & QRTR) {
+			register = (register & HALF) | ((register << 1) & (MASK >>> 1)) | read_bit();
+			a = (a << 1) ^ HALF;
+			b = ((b ^ HALF) << 1) | HALF | 1;
+		}
+		low = a;
+		range = 1 + b - a;
+	}
+	let offset = symbol_count - 4;
+	return symbols.map(x => { // index into payload
+		switch (x - offset) {
+			case 3: return offset + 0x10100 + ((bytes[pos_payload++] << 16) | (bytes[pos_payload++] << 8) | bytes[pos_payload++]);
+			case 2: return offset + 0x100 + ((bytes[pos_payload++] << 8) | bytes[pos_payload++]);
+			case 1: return offset + bytes[pos_payload++];
+			default: return x - 1;
+		}
+	});
+}	
+
+// returns an iterator which returns the next symbol
+function read_payload(v) {
+	let pos = 0;
+	return () => v[pos++];
+}
+function read_compressed_payload(s) {
+	return read_payload(decode_arithmetic(unsafe_atob(s)));
+}
+
+// unsafe in the sense:
+// expected well-formed Base64 w/o padding 
+// 20220922: added for https://github.com/adraffy/ens-normalize.js/issues/4
+function unsafe_atob(s) {
+	let lookup = [];
+	[...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'].forEach((c, i) => lookup[c.charCodeAt(0)] = i);
+	let n = s.length;
+	let ret = new Uint8Array((6 * n) >> 3);
+	for (let i = 0, pos = 0, width = 0, carry = 0; i < n; i++) {
+		carry = (carry << 6) | lookup[s.charCodeAt(i)];
+		width += 6;
+		if (width >= 8) {
+			ret[pos++] = (carry >> (width -= 8));
+		}
+	}
+	return ret;
+}
+
+// eg. [0,1,2,3...] => [0,-1,1,-2,...]
+function signed(i) { 
+	return (i & 1) ? (~i >> 1) : (i >> 1);
+}
+
+function read_deltas(n, next) {
+	let v = Array(n);
+	for (let i = 0, x = 0; i < n; i++) v[i] = x += signed(next());
+	return v;
+}
+
+// [123][5] => [0 3] [1 1] [0 0]
+function read_sorted(next, prev = 0) {
+	let ret = [];
+	while (true) {
+		let x = next();
+		let n = next();
+		if (!n) break;
+		prev += x;
+		for (let i = 0; i < n; i++) {
+			ret.push(prev + i);
+		}
+		prev += n + 1;
+	}
+	return ret;
+}
+
+function read_sorted_arrays(next) {
+	return read_array_while(() => { 
+		let v = read_sorted(next);
+		if (v.length) return v;
+	});
+}
+
+// returns map of x => ys
+function read_mapped(next) {
+	let ret = [];
+	while (true) {
+		let w = next();
+		if (w == 0) break;
+		ret.push(read_linear_table(w, next));
+	}
+	while (true) {
+		let w = next() - 1;
+		if (w < 0) break;
+		ret.push(read_replacement_table(w, next));
+	}
+	return ret.flat();
+}
+
+// read until next is falsy
+// return array of read values
+function read_array_while(next) {
+	let v = [];
+	while (true) {
+		let x = next(v.length);
+		if (!x) break;
+		v.push(x);
+	}
+	return v;
+}
+
+// read w columns of length n
+// return as n rows of length w
+function read_transposed(n, w, next) {
+	let m = Array(n).fill().map(() => []);
+	for (let i = 0; i < w; i++) {
+		read_deltas(n, next).forEach((x, j) => m[j].push(x));
+	}
+	return m;
+}
+ 
+// returns [[x, ys], [x+dx, ys+dy], [x+2*dx, ys+2*dy], ...]
+// where dx/dy = steps, n = run size, w = length of y
+function read_linear_table(w, next) {
+	let dx = 1 + next();
+	let dy = next();
+	let vN = read_array_while(next);
+	let m = read_transposed(vN.length, 1+w, next);
+	return m.flatMap((v, i) => {
+		let [x, ...ys] = v;
+		return Array(vN[i]).fill().map((_, j) => {
+			let j_dy = j * dy;
+			return [x + j * dx, ys.map(y => y + j_dy)];
+		});
+	});
+}
+
+// return [[x, ys...], ...]
+// where w = length of y
+function read_replacement_table(w, next) { 
+	let n = 1 + next();
+	let m = read_transposed(n, 1+w, next);
+	return m.map(v => [v[0], v.slice(1)]);
+}
+
+
+function read_trie(next) {
+	let ret = [];
+	let sorted = read_sorted(next); 
+	expand(decode([]), []);
+	return ret; // not sorted
+	function decode(Q) { // characters that lead into this node
+		let S = next(); // state: valid, save, check
+		let B = read_array_while(() => { // buckets leading to new nodes
+			let cps = read_sorted(next).map(i => sorted[i]);
+			if (cps.length) return decode(cps);
+		});
+		return {S, B, Q};
+	}
+	function expand({S, B}, cps, saved) {
+		if (S & 4 && saved === cps[cps.length-1]) return;
+		if (S & 2) saved = cps[cps.length-1];
+		if (S & 1) ret.push(cps); 
+		for (let br of B) {
+			for (let cp of br.Q) {
+				expand(br, [...cps, cp], saved);
+			}
+		}
+	}
 }
 
-// read until next is falsy
-// return array of read values
-function read_array_while(next) {
-	let v = [];
-	while (true) {
-		let x = next(v.length);
-		if (!x) break;
-		v.push(x);
-	}
-	return v;
-}
-
-// read w columns of length n
-// return as n rows of length w
-function read_transposed(n, w, next) {
-	let m = Array(n).fill().map(() => []);
-	for (let i = 0; i < w; i++) {
-		read_deltas(n, next).forEach((x, j) => m[j].push(x));
-	}
-	return m;
-}
- 
-// returns [[x, ys], [x+dx, ys+dy], [x+2*dx, ys+2*dy], ...]
-// where dx/dy = steps, n = run size, w = length of y
-function read_linear_table(w, next) {
-	let dx = 1 + next();
-	let dy = next();
-	let vN = read_array_while(next);
-	let m = read_transposed(vN.length, 1+w, next);
-	return m.flatMap((v, i) => {
-		let [x, ...ys] = v;
-		return Array(vN[i]).fill().map((_, j) => {
-			let j_dy = j * dy;
-			return [x + j * dx, ys.map(y => y + j_dy)];
-		});
-	});
-}
-
-// return [[x, ys...], ...]
-// where w = length of y
-function read_replacement_table(w, next) { 
-	let n = 1 + next();
-	let m = read_transposed(n, 1+w, next);
-	return m.map(v => [v[0], v.slice(1)]);
-}
-
-
-function read_trie(next) {
-	let ret = [];
-	let sorted = read_sorted(next); 
-	expand(decode([]), []);
-	return ret; // not sorted
-	function decode(Q) { // characters that lead into this node
-		let S = next(); // state: valid, save, check
-		let B = read_array_while(() => { // buckets leading to new nodes
-			let cps = read_sorted(next).map(i => sorted[i]);
-			if (cps.length) return decode(cps);
-		});
-		return {S, B, Q};
-	}
-	function expand({S, B}, cps, saved) {
-		if (S & 4 && saved === cps[cps.length-1]) return;
-		if (S & 2) saved = cps[cps.length-1];
-		if (S & 1) ret.push(cps); 
-		for (let br of B) {
-			for (let cp of br.Q) {
-				expand(br, [...cps, cp], saved);
-			}
-		}
-	}
-}
-
-function hex_cp(cp) {
-	return cp.toString(16).toUpperCase().padStart(2, '0');
-}
-
-function quote_cp(cp) {
-	return `{${hex_cp(cp)}}`; // raffy convention: like "\u{X}" w/o the "\u"
-}
-
-/*
-export function explode_cp(s) {
-	return [...s].map(c => c.codePointAt(0));
-}
-*/
-function explode_cp(s) { // this is about 2x faster
-	let cps = [];
-	for (let pos = 0, len = s.length; pos < len; ) {
-		let cp = s.codePointAt(pos);
-		pos += cp < 0x10000 ? 1 : 2;
-		cps.push(cp);
-	}
-	return cps;
-}
-
-function str_from_cps(cps) {
-	const chunk = 4096;
-	let len = cps.length;
-	if (len < chunk) return String.fromCodePoint(...cps);
-	let buf = [];
-	for (let i = 0; i < len; ) {
-		buf.push(String.fromCodePoint(...cps.slice(i, i += chunk)));
-	}
-	return buf.join('');
-}
-
-function compare_arrays(a, b) {
-	let n = a.length;
-	let c = n - b.length;
-	for (let i = 0; c == 0 && i < n; i++) c = a[i] - b[i];
-	return c;
+function hex_cp(cp) {
+	return cp.toString(16).toUpperCase().padStart(2, '0');
+}
+
+function quote_cp(cp) {
+	return `{${hex_cp(cp)}}`; // raffy convention: like "\u{X}" w/o the "\u"
+}
+
+/*
+export function explode_cp(s) {
+	return [...s].map(c => c.codePointAt(0));
+}
+*/
+function explode_cp(s) { // this is about 2x faster
+	let cps = [];
+	for (let pos = 0, len = s.length; pos < len; ) {
+		let cp = s.codePointAt(pos);
+		pos += cp < 0x10000 ? 1 : 2;
+		cps.push(cp);
+	}
+	return cps;
+}
+
+function str_from_cps(cps) {
+	const chunk = 4096;
+	let len = cps.length;
+	if (len < chunk) return String.fromCodePoint(...cps);
+	let buf = [];
+	for (let i = 0; i < len; ) {
+		buf.push(String.fromCodePoint(...cps.slice(i, i += chunk)));
+	}
+	return buf.join('');
+}
+
+function compare_arrays(a, b) {
+	let n = a.length;
+	let c = n - b.length;
+	for (let i = 0; c == 0 && i < n; i++) c = a[i] - b[i];
+	return c;
 }
 
 // created 2023-09-25T01:01:55.148Z
@@ -8031,786 +7830,786 @@ function compare_arrays(a, b) {
 // SHA-256: a974b6f8541fc29d919bc85118af0a44015851fab5343f8679cb31be2bdb209e
 var COMPRESSED = 'AEUDTAHBCFQATQDRADAAcgAgADQAFAAsABQAHwAOACQADQARAAoAFwAHABIACAAPAAUACwAFAAwABAAQAAMABwAEAAoABQAIAAIACgABAAQAFAALAAIACwABAAIAAQAHAAMAAwAEAAsADAAMAAwACgANAA0AAwAKAAkABAAdAAYAZwDSAdsDJgC0CkMB8xhZAqfoC190UGcThgBurwf7PT09Pb09AjgJum8OjDllxHYUKXAPxzq6tABAxgK8ysUvWAgMPT09PT09PSs6LT2HcgWXWwFLoSMEEEl5RFVMKvO0XQ8ExDdJMnIgsj26PTQyy8FfEQ8AY8IPAGcEbwRwBHEEcgRzBHQEdQR2BHcEeAR6BHsEfAR+BIAEgfndBQoBYgULAWIFDAFiBNcE2ATZBRAFEQUvBdALFAsVDPcNBw13DYcOMA4xDjMB4BllHI0B2grbAMDpHLkQ7QHVAPRNQQFnGRUEg0yEB2uaJF8AJpIBpob5AERSMAKNoAXqaQLUBMCzEiACnwRZEkkVsS7tANAsBG0RuAQLEPABv9HICTUBXigPZwRBApMDOwAamhtaABqEAY8KvKx3LQ4ArAB8UhwEBAVSagD8AEFZADkBIadVj2UMUgx5Il4ANQC9AxIB1BlbEPMAs30CGxlXAhwZKQIECBc6EbsCoxngzv7UzRQA8M0BawL6ZwkN7wABAD33OQRcsgLJCjMCjqUChtw/km+NAsXPAoP2BT84PwURAK0RAvptb6cApQS/OMMey5HJS84UdxpxTPkCogVFITaTOwERAK5pAvkNBOVyA7q3BKlOJSALAgUIBRcEdASpBXqzABXFSWZOawLCOqw//AolCZdvv3dSBkEQGyelEPcMMwG1ATsN7UvYBPEGOwTJH30ZGQ/NlZwIpS3dDO0m4y6hgFoj9SqDBe1L9DzdC01RaA9ZC2UJ4zpjgU4DIQENIosK3Q05CG0Q8wrJaw3lEUUHOQPVSZoApQcBCxEdNRW1JhBirAsJOXcG+xr2C48mrxMpevwF0xohBk0BKRr/AM8u54WwWjFcHE9fBgMLJSPHFKhQIA0lQLd4SBobBxUlqQKRQ3BKh1E2HpMh9jw9DWYuE1F8B/U8BRlPC4E8nkarRQ4R0j6NPUgiSUwsBDV/LC8niwnPD4UMuXxyAVkJIQmxDHETMREXN8UIOQcZLZckJxUIIUaVYJoE958D8xPRAwsFPwlBBxMDtRwtEy4VKQUNgSTXAvM21S6zAo9WgAEXBcsPJR/fEFBH4A7pCJsCZQODJesALRUhABcimwhDYwBfj9hTBS7LCMdqbCN0A2cU52ERcweRDlcHpxwzFb8c4XDIXguGCCijrwlbAXUJmQFfBOMICTVbjKAgQWdTi1gYmyBhQT9d/AIxDGUVn0S9h3gCiw9rEhsBNQFzBzkNAQJ3Ee0RaxCVCOuGBDW1M/g6JQRPIYMgEQonA09szgsnJvkM+GkBoxJiAww0PXfuZ6tgtiQX/QcZMsVBYCHxC5JPzQycGsEYQlQuGeQHvwPzGvMn6kFXBf8DowMTOk0z7gS9C2kIiwk/AEkOoxcH1xhqCnGM0AExiwG3mQNXkYMCb48GNwcLAGcLhwV55QAdAqcIowAFAM8DVwA5Aq0HnQAZAIVBAT0DJy8BIeUCjwOTCDHLAZUvAfMpBBvDDBUA9zduSgLDsQKAamaiBd1YAo4CSTUBTSUEBU5HUQOvceEA2wBLBhPfRwEVq0rLGuNDAd9vKwDHAPsABTUHBUEBzQHzbQC3AV8LMQmis7UBTekpAIMAFWsB1wKJAN0ANQB/8QFTAE0FWfkF0wJPSQERMRgrV2EBuwMfATMBDQB5BsuNpckHHwRtB9MCEBsV4QLvLge1AQMi3xPNQsUCvd5VoWACZIECYkJbTa9bNyACofcCaJgCZgkCn4Q4GwsCZjsCZiYEbgR/A38TA36SOQY5dxc5gjojIwJsHQIyNjgKAm3HAm2u74ozZ0UrAWcA3gDhAEoFB5gMjQD+C8IADbUCdy8CdqI/AnlLQwJ4uh1c20WuRtcCfD8CesgCfQkCfPAFWQUgSABIfWMkAoFtAoAAAoAFAn+uSVhKWxUXSswC0QEC0MxLJwOITwOH5kTFkTIC8qFdAwMDrkvOTC0lA89NTE2vAos/AorYwRsHHUNnBbcCjjcCjlxAl4ECjtkCjlx4UbRTNQpS1FSFApP7ApMMAOkAHFUeVa9V0AYsGymVhjLheGZFOzkCl58C77JYIagAWSUClo8ClnycAKlZrFoJgU0AOwKWtQKWTlxEXNECmcsCmWRcyl0HGQKcmznCOp0CnBYCn5sCnriKAB0PMSoPAp3xAp6SALU9YTRh7wKe0wKgbgGpAp6fHwKeTqVjyGQnJSsCJ68CJn4CoPsCoEwCot0CocQCpi8Cpc4Cp/8AfQKn8mh8aLEAA0lqHGrRAqzjAqyuAq1nAq0CAlcdAlXcArHh1wMfTmyXArK9DQKy6Bds4G1jbUhfAyXNArZcOz9ukAMpRQK4XgK5RxUCuSp3cDZw4QK9GQK72nCWAzIRAr6IcgIDM3ECvhpzInNPAsPLAsMEc4J0SzVFdOADPKcDPJoDPb8CxXwCxkcCxhCJAshpUQLIRALJTwLJLgJknQLd0nh5YXiueSVL0AMYo2cCAmH0GfOVJHsLXpJeuxECz2sCz2wvS1PS8xOfAMatAs9zASnqA04SfksFAtwnAtuKAtJPA1JcA1NfAQEDVYyAiT8AyxbtYEWCHILTgs6DjQLaxwLZ3oQQhEmnPAOGpQAvA2QOhnFZ+QBVAt9lAt64c3cC4i/tFAHzMCcB9JsB8tKHAuvzAulweQLq+QLq5AD5RwG5Au6JAuuclqqXAwLuPwOF4Jh5cOBxoQLzAwBpA44WmZMC9xMDkW4DkocC95gC+dkC+GaaHJqruzebHgOdgwL++gEbADmfHJ+zAwWNA6ZqA6bZANHFAwZqoYiiBQkDDEkCwAA/AwDhQRdTARHzA2sHl2cFAJMtK7evvdsBiZkUfxEEOQH7KQUhDp0JnwCS/SlXxQL3AZ0AtwW5AG8LbUEuFCaNLgFDAYD8AbUmAHUDDgRtACwCFgyhAAAKAj0CagPdA34EkQEgRQUhfAoABQBEABMANhICdwEABdUDa+8KxQIA9wqfJ7+xt+UBkSFBQgHpFH8RNMCJAAQAGwBaAkUChIsABjpTOpSNbQC4Oo860ACNOME63AClAOgAywE6gTo7Ofw5+Tt2iTpbO56JOm85GAFWATMBbAUvNV01njWtNWY1dTW2NcU1gjWRNdI14TWeNa017jX9NbI1wTYCNhE1xjXVNhY2JzXeNe02LjY9Ni41LSE2OjY9Njw2yTcIBJA8VzY4Nt03IDcPNsogN4k3MAoEsDxnNiQ3GTdsOo03IULUQwdC4EMLHA8PCZsobShRVQYA6X8A6bABFCnXAukBowC9BbcAbwNzBL8MDAMMAQgDAAkKCwsLCQoGBAVVBI/DvwDz9b29kaUCb0QtsRTNLt4eGBcSHAMZFhYZEhYEARAEBUEcQRxBHEEcQRxBHEEaQRxBHEFCSTxBPElISUhBNkM2QTYbNklISVmBVIgBFLWZAu0BhQCjBcEAbykBvwGJAaQcEZ0ePCklMAAhMvAIMAL54gC7Bm8EescjzQMpARQpKgDUABavAj626xQAJP0A3etzuf4NNRA7efy2Z9NQrCnC0OSyANz5BBIbJ5IFDR6miIavYS6tprjjmuKebxm5C74Q225X1pkaYYPb6f1DK4k3xMEBb9S2WMjEibTNWhsRJIA+vwNVEiXTE5iXs/wezV66oFLfp9NZGYW+Gk19J2+bCT6Ye2w6LDYdgzKMUabk595eLBCXANz9HUpWbATq9vqXVx9XDg+Pc9Xp4+bsS005SVM/BJBM4687WUuf+Uj9dEi8aDNaPxtpbDxcG1THTImUMZq4UCaaNYpsVqraNyKLJXDYsFZ/5jl7bLRtO88t7P3xZaAxhb5OdPMXqsSkp1WCieG8jXm1U99+blvLlXzPCS+M93VnJCiK+09LfaSaBAVBomyDgJua8dfUzR7ga34IvR2Nvj+A9heJ6lsl1KG4NkI1032Cnff1m1wof2B9oHJK4bi6JkEdSqeNeiuo6QoZZincoc73/TH9SXF8sCE7XyuYyW8WSgbGFCjPV0ihLKhdPs08Tx82fYAkLLc4I2wdl4apY7GU5lHRFzRWJep7Ww3wbeA3qmd59/86P4xuNaqDpygXt6M85glSBHOCGgJDnt+pN9bK7HApMguX6+06RZNjzVmcZJ+wcUrJ9//bpRNxNuKpNl9uFds+S9tdx7LaM5ZkIrPj6nIU9mnbFtVbs9s/uLgl8MVczAwet+iOEzzBlYW7RCMgE6gyNLeq6+1tIx4dpgZnd0DksJS5f+JNDpwwcPNXaaVspq1fbQajOrJgK0ofKtJ1Ne90L6VO4MOl5S886p7u6xo7OLjG8TGL+HU1JXGJgppg4nNbNJ5nlzSpuPYy21JUEcUA94PoFiZfjZue+QnyQ80ekOuZVkxx4g+cvhJfHgNl4hy1/a6+RKcKlar/J29y//EztlbVPHVUeQ1zX86eQVAjR/M3dA9w4W8LfaXp4EgM85wOWasli837PzVMOnsLzR+k3o75/lRPAJSE1xAKQzEi5v10ke+VBvRt1cwQRMd+U5mLCTGVd6XiZtgBG5cDi0w22GKcVNvHiu5LQbZEDVtz0onn7k5+heuKXVsZtSzilkLRAUmjMXEMB3J9YC50XBxPiz53SC+EhnPl9WsKCv92SM/OFFIMJZYfl0WW8tIO3UxYcwdMAj7FSmgrsZ2aAZO03BOhP1bNNZItyXYQFTpC3SG1VuPDqH9GkiCDmE+JwxyIVSO5siDErAOpEXFgjy6PQtOVDj+s6e1r8heWVvmZnTciuf4EiNZzCAd7SOMhXERIOlsHIMG399i9aLTy3m2hRLZjJVDNLS53iGIK11dPqQt0zBDyg6qc7YqkDm2M5Ve6dCWCaCbTXX2rToaIgz6+zh4lYUi/+6nqcFMAkQJKHYLK0wYk5N9szV6xihDbDDFr45lN1K4aCXBq/FitPSud9gLt5ZVn+ZqGX7cwm2z5EGMgfFpIFyhGGuDPmso6TItTMwny+7uPnLCf4W6goFQFV0oQSsc9VfMmVLcLr6ZetDZbaSFTLqnSO/bIPjA3/zAUoqgGFAEQS4IhuMzEp2I3jJzbzkk/IEmyax+rhZTwd6f+CGtwPixu8IvzACquPWPREu9ZvGkUzpRwvRRuaNN6cr0W1wWits9ICdYJ7ltbgMiSL3sTPeufgNcVqMVWFkCPDH4jG2jA0XcVgQj62Cb29v9f/z/+2KbYvIv/zzjpQAPkliaVDzNrW57TZ/ZOyZD0nlfMmAIBIAGAI0D3k/mdN4xr9v85ZbZbbqfH2jGd5hUqNZWwl5SPfoGmfElmazUIeNL1j/mkF7VNAzTq4jNt8JoQ11NQOcmhprXoxSxfRGJ9LDEOAQ+dmxAQH90iti9e2u/MoeuaGcDTHoC+xsmEeWmxEKefQuIzHbpw5Tc5cEocboAD09oipWQhtTO1wivf/O+DRe2rpl/E9wlrzBorjJsOeG1B/XPW4EaJEFdNlECEZga5ZoGRHXgYouGRuVkm8tDESiEyFNo+3s5M5puSdTyUL2llnINVHEt91XUNW4ewdMgJ4boJfEyt/iY5WXqbA+A2Fkt5Z0lutiWhe9nZIyIUjyXDC3UsaG1t+eNx6z4W/OYoTB7A6x+dNSTOi9AInctbESqm5gvOLww7OWXPrmHwVZasrl4eD113pm+JtT7JVOvnCXqdzzdTRHgJ0PiGTFYW5Gvt9R9LD6Lzfs0v/TZZHSmyVNq7viIHE6DBK7Qp07Iz55EM8SYtQvZf/obBniTWi5C2/ovHfw4VndkE5XYdjOhCMRjDeOEfXeN/CwfGduiUIfsoFeUxXeQXba7c7972XNv8w+dTjjUM0QeNAReW+J014dKAD/McQYXT7c0GQPIkn3Ll6R7gGjuiQoZD0TEeEqQpKoZ15g/0OPQI17QiSv9AUROa/V/TQN3dvLArec3RrsYlvBm1b8LWzltdugsC50lNKYLEp2a+ZZYqPejULRlOJh5zj/LVMyTDvwKhMxxwuDkxJ1QpoNI0OTWLom4Z71SNzI9TV1iXJrIu9Wcnd+MCaAw8o1jSXd94YU/1gnkrC9BUEOtQvEIQ7g0i6h+KL2JKk8Ydl7HruvgWMSAmNe+LshGhV4qnWHhO9/RIPQzY1tHRj2VqOyNsDpK0cww+56AdDC4gsWwY0XxoucIWIqs/GcwnWqlaT0KPr8mbK5U94/301i1WLt4YINTVvCFBrFZbIbY8eycOdeJ2teD5IfPLCRg7jjcFTwlMFNl9zdh/o3E/hHPwj7BWg0MU09pPrBLbrCgm54A6H+I6v27+jL5gkjWg/iYdks9jbfVP5y/n0dlgWEMlKasl7JvFZd56LfybW1eeaVO0gxTfXZwD8G4SI116yx7UKVRgui6Ya1YpixqXeNLc8IxtAwCU5IhwQgn+NqHnRaDv61CxKhOq4pOX7M6pkA+Pmpd4j1vn6ACUALoLLc4vpXci8VidLxzm7qFBe7s+quuJs6ETYmnpgS3LwSZxPIltgBDXz8M1k/W2ySNv2f9/NPhxLGK2D21dkHeSGmenRT3Yqcdl0m/h3OYr8V+lXNYGf8aCCpd4bWjE4QIPj7vUKN4Nrfs7ML6Y2OyS830JCnofg/k7lpFpt4SqZc5HGg1HCOrHvOdC8bP6FGDbE/VV0mX4IakzbdS/op+Kt3G24/8QbBV7y86sGSQ/vZzU8FXs7u6jIvwchsEP2BpIhW3G8uWNwa3HmjfH/ZjhhCWvluAcF+nMf14ClKg5hGgtPLJ98ueNAkc5Hs2WZlk2QHvfreCK1CCGO6nMZVSb99VM/ajr8WHTte9JSmkXq/i/U943HEbdzW6Re/S88dKgg8pGOLlAeNiqrcLkUR3/aClFpMXcOUP3rmETcWSfMXZE3TUOi8i+fqRnTYLflVx/Vb/6GJ7eIRZUA6k3RYR3iFSK9c4iDdNwJuZL2FKz/IK5VimcNWEqdXjSoxSgmF0UPlDoUlNrPcM7ftmA8Y9gKiqKEHuWN+AZRIwtVSxye2Kf8rM3lhJ5XcBXU9n4v0Oy1RU2M+4qM8AQPVwse8ErNSob5oFPWxuqZnVzo1qB/IBxkM3EVUKFUUlO3e51259GgNcJbCmlvrdjtoTW7rChm1wyCKzpCTwozUUEOIcWLneRLgMXh+SjGSFkAllzbGS5HK7LlfCMRNRDSvbQPjcXaenNYxCvu2Qyznz6StuxVj66SgI0T8B6/sfHAJYZaZ78thjOSIFumNWLQbeZixDCCC+v0YBtkxiBB3jefHqZ/dFHU+crbj6OvS1x/JDD7vlm7zOVPwpUC01nhxZuY/63E7g';
 
-// https://unicode.org/reports/tr15/
-// for reference implementation
-// see: /derive/nf.js
-
-
-// algorithmic hangul
-// https://www.unicode.org/versions/Unicode15.0.0/ch03.pdf (page 144)
-const S0 = 0xAC00;
-const L0 = 0x1100;
-const V0 = 0x1161;
-const T0 = 0x11A7;
-const L_COUNT = 19;
-const V_COUNT = 21;
-const T_COUNT = 28;
-const N_COUNT = V_COUNT * T_COUNT;
-const S_COUNT = L_COUNT * N_COUNT;
-const S1 = S0 + S_COUNT;
-const L1 = L0 + L_COUNT;
-const V1 = V0 + V_COUNT;
-const T1 = T0 + T_COUNT;
-
-function unpack_cc(packed) {
-	return (packed >> 24) & 0xFF;
-}
-function unpack_cp(packed) {
-	return packed & 0xFFFFFF;
-}
-
-let SHIFTED_RANK, EXCLUSIONS, DECOMP, RECOMP;
-
-function init$1() {
-	//console.time('nf');
-	let r = read_compressed_payload(COMPRESSED);
-	SHIFTED_RANK = new Map(read_sorted_arrays(r).flatMap((v, i) => v.map(x => [x, (i+1) << 24]))); // pre-shifted
-	EXCLUSIONS = new Set(read_sorted(r));
-	DECOMP = new Map();
-	RECOMP = new Map();
-	for (let [cp, cps] of read_mapped(r)) {
-		if (!EXCLUSIONS.has(cp) && cps.length == 2) {
-			let [a, b] = cps;
-			let bucket = RECOMP.get(a);
-			if (!bucket) {
-				bucket = new Map();
-				RECOMP.set(a, bucket);
-			}
-			bucket.set(b, cp);
-		}
-		DECOMP.set(cp, cps.reverse()); // stored reversed
-	}
-	//console.timeEnd('nf');
-	// 20230905: 11ms
-}
-
-function is_hangul(cp) {
-	return cp >= S0 && cp < S1;
-}
-
-function compose_pair(a, b) {
-	if (a >= L0 && a < L1 && b >= V0 && b < V1) {
-		return S0 + (a - L0) * N_COUNT + (b - V0) * T_COUNT;
-	} else if (is_hangul(a) && b > T0 && b < T1 && (a - S0) % T_COUNT == 0) {
-		return a + (b - T0);
-	} else {
-		let recomp = RECOMP.get(a);
-		if (recomp) {
-			recomp = recomp.get(b);
-			if (recomp) {
-				return recomp;
-			}
-		}
-		return -1;
-	}
-}
-
-function decomposed(cps) {
-	if (!SHIFTED_RANK) init$1();
-	let ret = [];
-	let buf = [];
-	let check_order = false;
-	function add(cp) {
-		let cc = SHIFTED_RANK.get(cp);
-		if (cc) {
-			check_order = true;
-			cp |= cc;
-		}
-		ret.push(cp);
-	}
-	for (let cp of cps) {
-		while (true) {
-			if (cp < 0x80) {
-				ret.push(cp);
-			} else if (is_hangul(cp)) {
-				let s_index = cp - S0;
-				let l_index = s_index / N_COUNT | 0;
-				let v_index = (s_index % N_COUNT) / T_COUNT | 0;
-				let t_index = s_index % T_COUNT;
-				add(L0 + l_index);
-				add(V0 + v_index);
-				if (t_index > 0) add(T0 + t_index);
-			} else {
-				let mapped = DECOMP.get(cp);
-				if (mapped) {
-					buf.push(...mapped);
-				} else {
-					add(cp);
-				}
-			}
-			if (!buf.length) break;
-			cp = buf.pop();
-		}
-	}
-	if (check_order && ret.length > 1) {
-		let prev_cc = unpack_cc(ret[0]);
-		for (let i = 1; i < ret.length; i++) {
-			let cc = unpack_cc(ret[i]);
-			if (cc == 0 || prev_cc <= cc) {
-				prev_cc = cc;
-				continue;
-			}
-			let j = i-1;
-			while (true) {
-				let tmp = ret[j+1];
-				ret[j+1] = ret[j];
-				ret[j] = tmp;
-				if (!j) break;
-				prev_cc = unpack_cc(ret[--j]);
-				if (prev_cc <= cc) break;
-			}
-			prev_cc = unpack_cc(ret[i]);
-		}
-	}
-	return ret;
-}
-
-function composed_from_decomposed(v) {
-	let ret = [];
-	let stack = [];
-	let prev_cp = -1;
-	let prev_cc = 0;
-	for (let packed of v) {
-		let cc = unpack_cc(packed);
-		let cp = unpack_cp(packed);
-		if (prev_cp == -1) {
-			if (cc == 0) {
-				prev_cp = cp;
-			} else {
-				ret.push(cp);
-			}
-		} else if (prev_cc > 0 && prev_cc >= cc) {
-			if (cc == 0) {
-				ret.push(prev_cp, ...stack);
-				stack.length = 0;
-				prev_cp = cp;
-			} else {
-				stack.push(cp);
-			}
-			prev_cc = cc;
-		} else {
-			let composed = compose_pair(prev_cp, cp);
-			if (composed >= 0) {
-				prev_cp = composed;
-			} else if (prev_cc == 0 && cc == 0) {
-				ret.push(prev_cp);
-				prev_cp = cp;
-			} else {
-				stack.push(cp);
-				prev_cc = cc;
-			}
-		}
-	}
-	if (prev_cp >= 0) {
-		ret.push(prev_cp, ...stack);	
-	}
-	return ret;
-}
-
-// note: cps can be iterable
-function nfd(cps) {
-	return decomposed(cps).map(unpack_cp);
-}
-function nfc(cps) {
-	return composed_from_decomposed(decomposed(cps));
+// https://unicode.org/reports/tr15/
+// for reference implementation
+// see: /derive/nf.js
+
+
+// algorithmic hangul
+// https://www.unicode.org/versions/Unicode15.0.0/ch03.pdf (page 144)
+const S0 = 0xAC00;
+const L0 = 0x1100;
+const V0 = 0x1161;
+const T0 = 0x11A7;
+const L_COUNT = 19;
+const V_COUNT = 21;
+const T_COUNT = 28;
+const N_COUNT = V_COUNT * T_COUNT;
+const S_COUNT = L_COUNT * N_COUNT;
+const S1 = S0 + S_COUNT;
+const L1 = L0 + L_COUNT;
+const V1 = V0 + V_COUNT;
+const T1 = T0 + T_COUNT;
+
+function unpack_cc(packed) {
+	return (packed >> 24) & 0xFF;
+}
+function unpack_cp(packed) {
+	return packed & 0xFFFFFF;
+}
+
+let SHIFTED_RANK, EXCLUSIONS, DECOMP, RECOMP;
+
+function init$1() {
+	//console.time('nf');
+	let r = read_compressed_payload(COMPRESSED);
+	SHIFTED_RANK = new Map(read_sorted_arrays(r).flatMap((v, i) => v.map(x => [x, (i+1) << 24]))); // pre-shifted
+	EXCLUSIONS = new Set(read_sorted(r));
+	DECOMP = new Map();
+	RECOMP = new Map();
+	for (let [cp, cps] of read_mapped(r)) {
+		if (!EXCLUSIONS.has(cp) && cps.length == 2) {
+			let [a, b] = cps;
+			let bucket = RECOMP.get(a);
+			if (!bucket) {
+				bucket = new Map();
+				RECOMP.set(a, bucket);
+			}
+			bucket.set(b, cp);
+		}
+		DECOMP.set(cp, cps.reverse()); // stored reversed
+	}
+	//console.timeEnd('nf');
+	// 20230905: 11ms
+}
+
+function is_hangul(cp) {
+	return cp >= S0 && cp < S1;
+}
+
+function compose_pair(a, b) {
+	if (a >= L0 && a < L1 && b >= V0 && b < V1) {
+		return S0 + (a - L0) * N_COUNT + (b - V0) * T_COUNT;
+	} else if (is_hangul(a) && b > T0 && b < T1 && (a - S0) % T_COUNT == 0) {
+		return a + (b - T0);
+	} else {
+		let recomp = RECOMP.get(a);
+		if (recomp) {
+			recomp = recomp.get(b);
+			if (recomp) {
+				return recomp;
+			}
+		}
+		return -1;
+	}
+}
+
+function decomposed(cps) {
+	if (!SHIFTED_RANK) init$1();
+	let ret = [];
+	let buf = [];
+	let check_order = false;
+	function add(cp) {
+		let cc = SHIFTED_RANK.get(cp);
+		if (cc) {
+			check_order = true;
+			cp |= cc;
+		}
+		ret.push(cp);
+	}
+	for (let cp of cps) {
+		while (true) {
+			if (cp < 0x80) {
+				ret.push(cp);
+			} else if (is_hangul(cp)) {
+				let s_index = cp - S0;
+				let l_index = s_index / N_COUNT | 0;
+				let v_index = (s_index % N_COUNT) / T_COUNT | 0;
+				let t_index = s_index % T_COUNT;
+				add(L0 + l_index);
+				add(V0 + v_index);
+				if (t_index > 0) add(T0 + t_index);
+			} else {
+				let mapped = DECOMP.get(cp);
+				if (mapped) {
+					buf.push(...mapped);
+				} else {
+					add(cp);
+				}
+			}
+			if (!buf.length) break;
+			cp = buf.pop();
+		}
+	}
+	if (check_order && ret.length > 1) {
+		let prev_cc = unpack_cc(ret[0]);
+		for (let i = 1; i < ret.length; i++) {
+			let cc = unpack_cc(ret[i]);
+			if (cc == 0 || prev_cc <= cc) {
+				prev_cc = cc;
+				continue;
+			}
+			let j = i-1;
+			while (true) {
+				let tmp = ret[j+1];
+				ret[j+1] = ret[j];
+				ret[j] = tmp;
+				if (!j) break;
+				prev_cc = unpack_cc(ret[--j]);
+				if (prev_cc <= cc) break;
+			}
+			prev_cc = unpack_cc(ret[i]);
+		}
+	}
+	return ret;
+}
+
+function composed_from_decomposed(v) {
+	let ret = [];
+	let stack = [];
+	let prev_cp = -1;
+	let prev_cc = 0;
+	for (let packed of v) {
+		let cc = unpack_cc(packed);
+		let cp = unpack_cp(packed);
+		if (prev_cp == -1) {
+			if (cc == 0) {
+				prev_cp = cp;
+			} else {
+				ret.push(cp);
+			}
+		} else if (prev_cc > 0 && prev_cc >= cc) {
+			if (cc == 0) {
+				ret.push(prev_cp, ...stack);
+				stack.length = 0;
+				prev_cp = cp;
+			} else {
+				stack.push(cp);
+			}
+			prev_cc = cc;
+		} else {
+			let composed = compose_pair(prev_cp, cp);
+			if (composed >= 0) {
+				prev_cp = composed;
+			} else if (prev_cc == 0 && cc == 0) {
+				ret.push(prev_cp);
+				prev_cp = cp;
+			} else {
+				stack.push(cp);
+				prev_cc = cc;
+			}
+		}
+	}
+	if (prev_cp >= 0) {
+		ret.push(prev_cp, ...stack);	
+	}
+	return ret;
+}
+
+// note: cps can be iterable
+function nfd(cps) {
+	return decomposed(cps).map(unpack_cp);
+}
+function nfc(cps) {
+	return composed_from_decomposed(decomposed(cps));
 }
 
-const HYPHEN = 0x2D;
-const STOP_CH = '.';
-const FE0F = 0xFE0F;
-const UNIQUE_PH = 1;
-
-// 20230913: replace [...v] with Array_from(v) to avoid large spreads
-const Array_from = x => Array.from(x); // Array.from.bind(Array);
-
-function group_has_cp(g, cp) {
-	// 20230913: keep primary and secondary distinct instead of creating valid union
-	return g.P.has(cp) || g.Q.has(cp);
-}
-
-class Emoji extends Array {
-	get is_emoji() { return true; } // free tagging system
-}
-
-let MAPPED, IGNORED, CM, NSM, ESCAPE, GROUPS, WHOLE_VALID, WHOLE_MAP, VALID, EMOJI_LIST, EMOJI_ROOT;
-
-function init() {
-	if (MAPPED) return;
-	
-	let r = read_compressed_payload(COMPRESSED$1);
-	const read_sorted_array = () => read_sorted(r);
-	const read_sorted_set = () => new Set(read_sorted_array());
-	const set_add_many = (set, v) => v.forEach(x => set.add(x));
-
-	MAPPED = new Map(read_mapped(r)); 
-	IGNORED = read_sorted_set(); // ignored characters are not valid, so just read raw codepoints
-
-	/*
-	// direct include from payload is smaller than the decompression code
-	const FENCED = new Map(read_array_while(() => {
-		let cp = r();
-		if (cp) return [cp, read_str(r())];
-	}));
-	*/
-	// 20230217: we still need all CM for proper error formatting
-	// but norm only needs NSM subset that are potentially-valid
-	CM = read_sorted_array();
-	NSM = new Set(read_sorted_array().map(i => CM[i]));
-	CM = new Set(CM);
-	
-	ESCAPE = read_sorted_set(); // characters that should not be printed
-	read_sorted_set(); // only needed to illustrate ens_tokenize() transformations
-
-	let chunks = read_sorted_arrays(r);
-	let unrestricted = r();
-	//const read_chunked = () => new Set(read_sorted_array().flatMap(i => chunks[i]).concat(read_sorted_array()));
-	const read_chunked = () => {
-		// 20230921: build set in parts, 2x faster
-		let set = new Set();
-		read_sorted_array().forEach(i => set_add_many(set, chunks[i]));
-		set_add_many(set, read_sorted_array());
-		return set; 
-	};
-	GROUPS = read_array_while(i => {
-		// minifier property mangling seems unsafe
-		// so these are manually renamed to single chars
-		let N = read_array_while(r).map(x => x+0x60);
-		if (N.length) {
-			let R = i >= unrestricted; // unrestricted then restricted
-			N[0] -= 32; // capitalize
-			N = str_from_cps(N);
-			if (R) N=`Restricted[${N}]`;
-			let P = read_chunked(); // primary
-			let Q = read_chunked(); // secondary
-			let M = !r(); // not-whitelisted, check for NSM
-			// *** this code currently isn't needed ***
-			/*
-			let V = [...P, ...Q].sort((a, b) => a-b); // derive: sorted valid
-			let M = r()-1; // number of combining mark
-			if (M < 0) { // whitelisted
-				M = new Map(read_array_while(() => {
-					let i = r();
-					if (i) return [V[i-1], read_array_while(() => {
-						let v = read_array_while(r);
-						if (v.length) return v.map(x => x-1);
-					})];
-				}));
-			}*/
-			return {N, P, Q, M, R};
-		}
-	});
-
-	// decode compressed wholes
-	WHOLE_VALID = read_sorted_set();
-	WHOLE_MAP = new Map();
-	let wholes = read_sorted_array().concat(Array_from(WHOLE_VALID)).sort((a, b) => a-b); // must be sorted
-	wholes.forEach((cp, i) => {
-		let d = r(); 
-		let w = wholes[i] = d ? wholes[i-d] : {V: [], M: new Map()};
-		w.V.push(cp); // add to member set
-		if (!WHOLE_VALID.has(cp)) {
-			WHOLE_MAP.set(cp, w);  // register with whole map
-		}
-	});
-
-	// compute confusable-extent complements
-	// usage: WHOLE_MAP.get(cp).M.get(cp) = complement set
-	for (let {V, M} of new Set(WHOLE_MAP.values())) {
-		// connect all groups that have each whole character
-		let recs = [];
-		for (let cp of V) {
-			let gs = GROUPS.filter(g => group_has_cp(g, cp));
-			let rec = recs.find(({G}) => gs.some(g => G.has(g)));
-			if (!rec) {
-				rec = {G: new Set(), V: []};
-				recs.push(rec);
-			}
-			rec.V.push(cp);
-			set_add_many(rec.G, gs);
-		}
-		// per character cache groups which are not a member of the extent
-		let union = recs.flatMap(x => Array_from(x.G)); // all of the groups used by this whole
-		for (let {G, V} of recs) {
-			let complement = new Set(union.filter(g => !G.has(g))); // groups not covered by the extent
-			for (let cp of V) {
-				M.set(cp, complement); // this is the same reference
-			}
-		}
-	}
-
-	// compute valid set
-	// 20230924: VALID was union but can be re-used
-	VALID = new Set(); // exists in 1+ groups
-	let multi = new Set(); // exists in 2+ groups
-	const add_to_union = cp => VALID.has(cp) ? multi.add(cp) : VALID.add(cp);
-	for (let g of GROUPS) {
-		for (let cp of g.P) add_to_union(cp);
-		for (let cp of g.Q) add_to_union(cp);
-	}
-	// dual purpose WHOLE_MAP: return placeholder if unique non-confusable
-	for (let cp of VALID) {
-		if (!WHOLE_MAP.has(cp) && !multi.has(cp)) {
-			WHOLE_MAP.set(cp, UNIQUE_PH);
-		}
-	}
-	// add all decomposed parts
-	// see derive: "Valid is Closed (via Brute-force)"
-	set_add_many(VALID, nfd(VALID));
-	
-	// decode emoji
-	// 20230719: emoji are now fully-expanded to avoid quirk logic 
-	EMOJI_LIST = read_trie(r).map(v => Emoji.from(v)).sort(compare_arrays);
-	EMOJI_ROOT = new Map(); // this has approx 7K nodes (2+ per emoji)
-	for (let cps of EMOJI_LIST) {
-		// 20230719: change to *slightly* stricter algorithm which disallows 
-		// insertion of misplaced FE0F in emoji sequences (matching ENSIP-15)
-		// example: beautified [A B] (eg. flag emoji) 
-		//  before: allow: [A FE0F B], error: [A FE0F FE0F B] 
-		//   after: error: both
-		// note: this code now matches ENSNormalize.{cs,java} logic
-		let prev = [EMOJI_ROOT];
-		for (let cp of cps) {
-			let next = prev.map(node => {
-				let child = node.get(cp);
-				if (!child) {
-					// should this be object? 
-					// (most have 1-2 items, few have many)
-					// 20230719: no, v8 default map is 4?
-					child = new Map();
-					node.set(cp, child);
-				}
-				return child;
-			});
-			if (cp === FE0F) {
-				prev.push(...next); // less than 20 elements
-			} else {
-				prev = next;
-			}
-		}
-		for (let x of prev) {
-			x.V = cps;
-		}
-	}
-}
-
-// if escaped: {HEX}
-//       else: "x" {HEX}
-function quoted_cp(cp) {
-	return (should_escape(cp) ? '' : `${bidi_qq(safe_str_from_cps([cp]))} `) + quote_cp(cp);
-}
-
-// 20230211: some messages can be mixed-directional and result in spillover
-// use 200E after a quoted string to force the remainder of a string from 
-// acquring the direction of the quote
-// https://www.w3.org/International/questions/qa-bidi-unicode-controls#exceptions
-function bidi_qq(s) {
-	return `"${s}"\u200E`; // strong LTR
-}
-
-function check_label_extension(cps) {
-	if (cps.length >= 4 && cps[2] == HYPHEN && cps[3] == HYPHEN) {
-		throw new Error(`invalid label extension: "${str_from_cps(cps.slice(0, 4))}"`); // this can only be ascii so cant be bidi
-	}
-}
-function check_leading_underscore(cps) {
-	const UNDERSCORE = 0x5F;
-	for (let i = cps.lastIndexOf(UNDERSCORE); i > 0; ) {
-		if (cps[--i] !== UNDERSCORE) {
-			throw new Error('underscore allowed only at start');
-		}
-	}
-}
-// check that a fenced cp is not leading, trailing, or touching another fenced cp
-function check_fenced(cps) {
-	let cp = cps[0];
-	let prev = FENCED.get(cp);
-	if (prev) throw error_placement(`leading ${prev}`);
-	let n = cps.length;
-	let last = -1; // prevents trailing from throwing
-	for (let i = 1; i < n; i++) {
-		cp = cps[i];
-		let match = FENCED.get(cp);
-		if (match) {
-			// since cps[0] isn't fenced, cps[1] cannot throw
-			if (last == i) throw error_placement(`${prev} + ${match}`);
-			last = i + 1;
-			prev = match;
-		}
-	}
-	if (last == n) throw error_placement(`trailing ${prev}`);
-}
-
-// create a safe to print string 
-// invisibles are escaped
-// leading cm uses placeholder
-// if cps exceed max, middle truncate with ellipsis
-// quoter(cp) => string, eg. 3000 => "{3000}"
-// note: in html, you'd call this function then replace [<>&] with entities
-function safe_str_from_cps(cps, max = Infinity, quoter = quote_cp) {
-	//if (Number.isInteger(cps)) cps = [cps];
-	//if (!Array.isArray(cps)) throw new TypeError(`expected codepoints`);
-	let buf = [];
-	if (is_combining_mark(cps[0])) buf.push('◌');
-	if (cps.length > max) {
-		max >>= 1;
-		cps = [...cps.slice(0, max), 0x2026, ...cps.slice(-max)];
-	}
-	let prev = 0;
-	let n = cps.length;
-	for (let i = 0; i < n; i++) {
-		let cp = cps[i];
-		if (should_escape(cp)) {
-			buf.push(str_from_cps(cps.slice(prev, i)));
-			buf.push(quoter(cp));
-			prev = i + 1;
-		}
-	}
-	buf.push(str_from_cps(cps.slice(prev, n)));
-	return buf.join('');
-}
-
-// note: set(s) cannot be exposed because they can be modified
-// note: Object.freeze() doesn't work
-function is_combining_mark(cp) {
-	init();
-	return CM.has(cp);
-}
-function should_escape(cp) {
-	init();
-	return ESCAPE.has(cp);
-}
-
-function ens_normalize(name) {
-	return flatten(split(name, nfc, filter_fe0f));
-}
-
-function split(name, nf, ef) {
-	if (!name) return []; // 20230719: empty name allowance
-	init();
-	let offset = 0;
-	// https://unicode.org/reports/tr46/#Validity_Criteria
-	// 4.) "The label must not contain a U+002E ( . ) FULL STOP."
-	return name.split(STOP_CH).map(label => {
-		let input = explode_cp(label);
-		let info = {
-			input,
-			offset, // codepoint, not substring!
-		};
-		offset += input.length + 1; // + stop
-		try {
-			// 1.) "The label must be in Unicode Normalization Form NFC"
-			let tokens = info.tokens = tokens_from_str(input, nf, ef);
-			let token_count = tokens.length;
-			let type;
-			if (!token_count) { // the label was effectively empty (could of had ignored characters)
-				//norm = [];
-				//type = 'None'; // use this instead of next match, "ASCII"
-				// 20230120: change to strict
-				// https://discuss.ens.domains/t/ens-name-normalization-2nd/14564/59
-				throw new Error(`empty label`);
-			} 
-			let norm = info.output = tokens.flat();
-			check_leading_underscore(norm);
-			let emoji = info.emoji = token_count > 1 || tokens[0].is_emoji; // same as: tokens.some(x => x.is_emoji);
-			if (!emoji && norm.every(cp => cp < 0x80)) { // special case for ascii
-				// 20230123: matches matches WHATWG, see note 3.3
-				check_label_extension(norm); // only needed for ascii
-				// cant have fenced
-				// cant have cm
-				// cant have wholes
-				// see derive: "Fastpath ASCII"
-				type = 'ASCII';
-			} else {
-				let chars = tokens.flatMap(x => x.is_emoji ? [] : x); // all of the nfc tokens concat together
-				if (!chars.length) { // theres no text, just emoji
-					type = 'Emoji';
-				} else {
-					// 5.) "The label must not begin with a combining mark, that is: General_Category=Mark."
-					if (CM.has(norm[0])) throw error_placement('leading combining mark');
-					for (let i = 1; i < token_count; i++) { // we've already checked the first token
-						let cps = tokens[i];
-						if (!cps.is_emoji && CM.has(cps[0])) { // every text token has emoji neighbors, eg. EtEEEtEt...
-							// bidi_qq() not needed since emoji is LTR and cps is a CM
-							throw error_placement(`emoji + combining mark: "${str_from_cps(tokens[i-1])} + ${safe_str_from_cps([cps[0]])}"`); 
-						}
-					}
-					check_fenced(norm);
-					let unique = Array_from(new Set(chars));
-					let [g] = determine_group(unique); // take the first match
-					// see derive: "Matching Groups have Same CM Style"
-					// alternative: could form a hybrid type: Latin/Japanese/...	
-					check_group(g, chars); // need text in order
-					check_whole(g, unique); // only need unique text (order would be required for multiple-char confusables)
-					type = g.N;
-					// 20230121: consider exposing restricted flag
-					// it's simpler to just check for 'Restricted'
-					// or even better: type.endsWith(']')
-					//if (g.R) info.restricted = true;
-				}
-			}
-			info.type = type;
-		} catch (err) {
-			info.error = err; // use full error object
-		}
-		return info;
-	});
-}
-
-function check_whole(group, unique) {
-	let maker;
-	let shared = [];
-	for (let cp of unique) {
-		let whole = WHOLE_MAP.get(cp);
-		if (whole === UNIQUE_PH) return; // unique, non-confusable
-		if (whole) {
-			let set = whole.M.get(cp); // groups which have a character that look-like this character
-			maker = maker ? maker.filter(g => set.has(g)) : Array_from(set);
-			if (!maker.length) return; // confusable intersection is empty
-		} else {
-			shared.push(cp); 
-		}
-	}
-	if (maker) {
-		// we have 1+ confusable
-		// check if any of the remaining groups
-		// contain the shared characters too
-		for (let g of maker) {
-			if (shared.every(cp => group_has_cp(g, cp))) {
-				throw new Error(`whole-script confusable: ${group.N}/${g.N}`);
-			}
-		}
-	}
-}
-
-// assumption: unique.size > 0
-// returns list of matching groups
-function determine_group(unique) {
-	let groups = GROUPS;
-	for (let cp of unique) {
-		// note: we need to dodge CM that are whitelisted
-		// but that code isn't currently necessary
-		let gs = groups.filter(g => group_has_cp(g, cp));
-		if (!gs.length) {
-			if (!GROUPS.some(g => group_has_cp(g, cp))) { 
-				// the character was composed of valid parts
-				// but it's NFC form is invalid
-				// 20230716: change to more exact statement, see: ENSNormalize.{cs,java}
-				// note: this doesn't have to be a composition
-				// 20230720: change to full check
-				throw error_disallowed(cp); // this should be rare
-			} else {
-				// there is no group that contains all these characters
-				// throw using the highest priority group that matched
-				// https://www.unicode.org/reports/tr39/#mixed_script_confusables
-				throw error_group_member(groups[0], cp);
-			}
-		}
-		groups = gs;
-		if (gs.length == 1) break; // there is only one group left
-	}
-	// there are at least 1 group(s) with all of these characters
-	return groups;
-}
-
-// throw on first error
-function flatten(split) {
-	return split.map(({input, error, output}) => {
-		if (error) {
-			// don't print label again if just a single label
-			let msg = error.message;
-			// bidi_qq() only necessary if msg is digits
-			throw new Error(split.length == 1 ? msg : `Invalid label ${bidi_qq(safe_str_from_cps(input, 63))}: ${msg}`); 
-		}
-		return str_from_cps(output);
-	}).join(STOP_CH);
-}
-
-function error_disallowed(cp) {
-	// TODO: add cp to error?
-	return new Error(`disallowed character: ${quoted_cp(cp)}`); 
-}
-function error_group_member(g, cp) {
-	let quoted = quoted_cp(cp);
-	let gg = GROUPS.find(g => g.P.has(cp)); // only check primary
-	if (gg) {
-		quoted = `${gg.N} ${quoted}`;
-	}
-	return new Error(`illegal mixture: ${g.N} + ${quoted}`);
-}
-function error_placement(where) {
-	return new Error(`illegal placement: ${where}`);
-}
-
-// assumption: cps.length > 0
-// assumption: cps[0] isn't a CM
-// assumption: the previous character isn't an emoji
-function check_group(g, cps) {
-	for (let cp of cps) {
-		if (!group_has_cp(g, cp)) {
-			// for whitelisted scripts, this will throw illegal mixture on invalid cm, eg. "e{300}{300}"
-			// at the moment, it's unnecessary to introduce an extra error type
-			// until there exists a whitelisted multi-character
-			//   eg. if (M < 0 && is_combining_mark(cp)) { ... }
-			// there are 3 cases:
-			//   1. illegal cm for wrong group => mixture error
-			//   2. illegal cm for same group => cm error
-			//       requires set of whitelist cm per group: 
-			//        eg. new Set([...g.P, ...g.Q].flatMap(nfc).filter(cp => CM.has(cp)))
-			//   3. wrong group => mixture error
-			throw error_group_member(g, cp);
-		}
-	}
-	//if (M >= 0) { // we have a known fixed cm count
-	if (g.M) { // we need to check for NSM
-		let decomposed = nfd(cps);
-		for (let i = 1, e = decomposed.length; i < e; i++) { // see: assumption
-			// 20230210: bugfix: using cps instead of decomposed h/t Carbon225
-			/*
-			if (CM.has(decomposed[i])) {
-				let j = i + 1;
-				while (j < e && CM.has(decomposed[j])) j++;
-				if (j - i > M) {
-					throw new Error(`too many combining marks: ${g.N} ${bidi_qq(str_from_cps(decomposed.slice(i-1, j)))} (${j-i}/${M})`);
-				}
-				i = j;
-			}
-			*/
-			// 20230217: switch to NSM counting
-			// https://www.unicode.org/reports/tr39/#Optional_Detection
-			if (NSM.has(decomposed[i])) {
-				let j = i + 1;
-				for (let cp; j < e && NSM.has(cp = decomposed[j]); j++) {
-					// a. Forbid sequences of the same nonspacing mark.
-					for (let k = i; k < j; k++) { // O(n^2) but n < 100
-						if (decomposed[k] == cp) {
-							throw new Error(`duplicate non-spacing marks: ${quoted_cp(cp)}`);
-						}
-					}
-				}
-				// parse to end so we have full nsm count
-				// b. Forbid sequences of more than 4 nonspacing marks (gc=Mn or gc=Me).
-				if (j - i > NSM_MAX) {
-					// note: this slice starts with a base char or spacing-mark cm
-					throw new Error(`excessive non-spacing marks: ${bidi_qq(safe_str_from_cps(decomposed.slice(i-1, j)))} (${j-i}/${NSM_MAX})`);
-				}
-				i = j;
-			}
-		}
-	}
-	// *** this code currently isn't needed ***
-	/*
-	let cm_whitelist = M instanceof Map;
-	for (let i = 0, e = cps.length; i < e; ) {
-		let cp = cps[i++];
-		let seqs = cm_whitelist && M.get(cp);
-		if (seqs) { 
-			// list of codepoints that can follow
-			// if this exists, this will always be 1+
-			let j = i;
-			while (j < e && CM.has(cps[j])) j++;
-			let cms = cps.slice(i, j);
-			let match = seqs.find(seq => !compare_arrays(seq, cms));
-			if (!match) throw new Error(`disallowed combining mark sequence: "${safe_str_from_cps([cp, ...cms])}"`);
-			i = j;
-		} else if (!V.has(cp)) {
-			// https://www.unicode.org/reports/tr39/#mixed_script_confusables
-			let quoted = quoted_cp(cp);
-			for (let cp of cps) {
-				let u = UNIQUE.get(cp);
-				if (u && u !== g) {
-					// if both scripts are restricted this error is confusing
-					// because we don't differentiate RestrictedA from RestrictedB 
-					if (!u.R) quoted = `${quoted} is ${u.N}`;
-					break;
-				}
-			}
-			throw new Error(`disallowed ${g.N} character: ${quoted}`);
-			//throw new Error(`disallowed character: ${quoted} (expected ${g.N})`);
-			//throw new Error(`${g.N} does not allow: ${quoted}`);
-		}
-	}
-	if (!cm_whitelist) {
-		let decomposed = nfd(cps);
-		for (let i = 1, e = decomposed.length; i < e; i++) { // we know it can't be cm leading
-			if (CM.has(decomposed[i])) {
-				let j = i + 1;
-				while (j < e && CM.has(decomposed[j])) j++;
-				if (j - i > M) {
-					throw new Error(`too many combining marks: "${str_from_cps(decomposed.slice(i-1, j))}" (${j-i}/${M})`);
-				}
-				i = j;
-			}
-		}
-	}
-	*/
-}
-
-// given a list of codepoints
-// returns a list of lists, where emoji are a fully-qualified (as Array subclass)
-// eg. explode_cp("abc💩d") => [[61, 62, 63], Emoji[1F4A9, FE0F], [64]]
-// 20230818: rename for 'process' name collision h/t Javarome
-// https://github.com/adraffy/ens-normalize.js/issues/23
-function tokens_from_str(input, nf, ef) {
-	let ret = [];
-	let chars = [];
-	input = input.slice().reverse(); // flip so we can pop
-	while (input.length) {
-		let emoji = consume_emoji_reversed(input);
-		if (emoji) {
-			if (chars.length) {
-				ret.push(nf(chars));
-				chars = [];
-			}
-			ret.push(ef(emoji));
-		} else {
-			let cp = input.pop();
-			if (VALID.has(cp)) {
-				chars.push(cp);
-			} else {
-				let cps = MAPPED.get(cp);
-				if (cps) {
-					chars.push(...cps); // less than 10 elements
-				} else if (!IGNORED.has(cp)) {
-					// 20230912: unicode 15.1 changed the order of processing such that
-					// disallowed parts are only rejected after NFC
-					// https://unicode.org/reports/tr46/#Validity_Criteria
-					// this doesn't impact normalization as of today
-					// technically, this error can be removed as the group logic will apply similar logic
-					// however the error type might be less clear
-					throw error_disallowed(cp);
-				}
-			}
-		}
-	}
-	if (chars.length) {
-		ret.push(nf(chars));
-	}
-	return ret;
-}
-
-function filter_fe0f(cps) {
-	return cps.filter(cp => cp != FE0F);
-}
-
-// given array of codepoints
-// returns the longest valid emoji sequence (or undefined if no match)
-// *MUTATES* the supplied array
-// disallows interleaved ignored characters
-// fills (optional) eaten array with matched codepoints
-function consume_emoji_reversed(cps, eaten) {
-	let node = EMOJI_ROOT;
-	let emoji;
-	let pos = cps.length;
-	while (pos) {
-		node = node.get(cps[--pos]);
-		if (!node) break;
-		let {V} = node;
-		if (V) { // this is a valid emoji (so far)
-			emoji = V;
-			cps.length = pos; // truncate
-		}
-	}
-	return emoji;
+const HYPHEN = 0x2D;
+const STOP_CH = '.';
+const FE0F = 0xFE0F;
+const UNIQUE_PH = 1;
+
+// 20230913: replace [...v] with Array_from(v) to avoid large spreads
+const Array_from = x => Array.from(x); // Array.from.bind(Array);
+
+function group_has_cp(g, cp) {
+	// 20230913: keep primary and secondary distinct instead of creating valid union
+	return g.P.has(cp) || g.Q.has(cp);
+}
+
+class Emoji extends Array {
+	get is_emoji() { return true; } // free tagging system
+}
+
+let MAPPED, IGNORED, CM, NSM, ESCAPE, GROUPS, WHOLE_VALID, WHOLE_MAP, VALID, EMOJI_LIST, EMOJI_ROOT;
+
+function init() {
+	if (MAPPED) return;
+	
+	let r = read_compressed_payload(COMPRESSED$1);
+	const read_sorted_array = () => read_sorted(r);
+	const read_sorted_set = () => new Set(read_sorted_array());
+	const set_add_many = (set, v) => v.forEach(x => set.add(x));
+
+	MAPPED = new Map(read_mapped(r)); 
+	IGNORED = read_sorted_set(); // ignored characters are not valid, so just read raw codepoints
+
+	/*
+	// direct include from payload is smaller than the decompression code
+	const FENCED = new Map(read_array_while(() => {
+		let cp = r();
+		if (cp) return [cp, read_str(r())];
+	}));
+	*/
+	// 20230217: we still need all CM for proper error formatting
+	// but norm only needs NSM subset that are potentially-valid
+	CM = read_sorted_array();
+	NSM = new Set(read_sorted_array().map(i => CM[i]));
+	CM = new Set(CM);
+	
+	ESCAPE = read_sorted_set(); // characters that should not be printed
+	read_sorted_set(); // only needed to illustrate ens_tokenize() transformations
+
+	let chunks = read_sorted_arrays(r);
+	let unrestricted = r();
+	//const read_chunked = () => new Set(read_sorted_array().flatMap(i => chunks[i]).concat(read_sorted_array()));
+	const read_chunked = () => {
+		// 20230921: build set in parts, 2x faster
+		let set = new Set();
+		read_sorted_array().forEach(i => set_add_many(set, chunks[i]));
+		set_add_many(set, read_sorted_array());
+		return set; 
+	};
+	GROUPS = read_array_while(i => {
+		// minifier property mangling seems unsafe
+		// so these are manually renamed to single chars
+		let N = read_array_while(r).map(x => x+0x60);
+		if (N.length) {
+			let R = i >= unrestricted; // unrestricted then restricted
+			N[0] -= 32; // capitalize
+			N = str_from_cps(N);
+			if (R) N=`Restricted[${N}]`;
+			let P = read_chunked(); // primary
+			let Q = read_chunked(); // secondary
+			let M = !r(); // not-whitelisted, check for NSM
+			// *** this code currently isn't needed ***
+			/*
+			let V = [...P, ...Q].sort((a, b) => a-b); // derive: sorted valid
+			let M = r()-1; // number of combining mark
+			if (M < 0) { // whitelisted
+				M = new Map(read_array_while(() => {
+					let i = r();
+					if (i) return [V[i-1], read_array_while(() => {
+						let v = read_array_while(r);
+						if (v.length) return v.map(x => x-1);
+					})];
+				}));
+			}*/
+			return {N, P, Q, M, R};
+		}
+	});
+
+	// decode compressed wholes
+	WHOLE_VALID = read_sorted_set();
+	WHOLE_MAP = new Map();
+	let wholes = read_sorted_array().concat(Array_from(WHOLE_VALID)).sort((a, b) => a-b); // must be sorted
+	wholes.forEach((cp, i) => {
+		let d = r(); 
+		let w = wholes[i] = d ? wholes[i-d] : {V: [], M: new Map()};
+		w.V.push(cp); // add to member set
+		if (!WHOLE_VALID.has(cp)) {
+			WHOLE_MAP.set(cp, w);  // register with whole map
+		}
+	});
+
+	// compute confusable-extent complements
+	// usage: WHOLE_MAP.get(cp).M.get(cp) = complement set
+	for (let {V, M} of new Set(WHOLE_MAP.values())) {
+		// connect all groups that have each whole character
+		let recs = [];
+		for (let cp of V) {
+			let gs = GROUPS.filter(g => group_has_cp(g, cp));
+			let rec = recs.find(({G}) => gs.some(g => G.has(g)));
+			if (!rec) {
+				rec = {G: new Set(), V: []};
+				recs.push(rec);
+			}
+			rec.V.push(cp);
+			set_add_many(rec.G, gs);
+		}
+		// per character cache groups which are not a member of the extent
+		let union = recs.flatMap(x => Array_from(x.G)); // all of the groups used by this whole
+		for (let {G, V} of recs) {
+			let complement = new Set(union.filter(g => !G.has(g))); // groups not covered by the extent
+			for (let cp of V) {
+				M.set(cp, complement); // this is the same reference
+			}
+		}
+	}
+
+	// compute valid set
+	// 20230924: VALID was union but can be re-used
+	VALID = new Set(); // exists in 1+ groups
+	let multi = new Set(); // exists in 2+ groups
+	const add_to_union = cp => VALID.has(cp) ? multi.add(cp) : VALID.add(cp);
+	for (let g of GROUPS) {
+		for (let cp of g.P) add_to_union(cp);
+		for (let cp of g.Q) add_to_union(cp);
+	}
+	// dual purpose WHOLE_MAP: return placeholder if unique non-confusable
+	for (let cp of VALID) {
+		if (!WHOLE_MAP.has(cp) && !multi.has(cp)) {
+			WHOLE_MAP.set(cp, UNIQUE_PH);
+		}
+	}
+	// add all decomposed parts
+	// see derive: "Valid is Closed (via Brute-force)"
+	set_add_many(VALID, nfd(VALID));
+	
+	// decode emoji
+	// 20230719: emoji are now fully-expanded to avoid quirk logic 
+	EMOJI_LIST = read_trie(r).map(v => Emoji.from(v)).sort(compare_arrays);
+	EMOJI_ROOT = new Map(); // this has approx 7K nodes (2+ per emoji)
+	for (let cps of EMOJI_LIST) {
+		// 20230719: change to *slightly* stricter algorithm which disallows 
+		// insertion of misplaced FE0F in emoji sequences (matching ENSIP-15)
+		// example: beautified [A B] (eg. flag emoji) 
+		//  before: allow: [A FE0F B], error: [A FE0F FE0F B] 
+		//   after: error: both
+		// note: this code now matches ENSNormalize.{cs,java} logic
+		let prev = [EMOJI_ROOT];
+		for (let cp of cps) {
+			let next = prev.map(node => {
+				let child = node.get(cp);
+				if (!child) {
+					// should this be object? 
+					// (most have 1-2 items, few have many)
+					// 20230719: no, v8 default map is 4?
+					child = new Map();
+					node.set(cp, child);
+				}
+				return child;
+			});
+			if (cp === FE0F) {
+				prev.push(...next); // less than 20 elements
+			} else {
+				prev = next;
+			}
+		}
+		for (let x of prev) {
+			x.V = cps;
+		}
+	}
+}
+
+// if escaped: {HEX}
+//       else: "x" {HEX}
+function quoted_cp(cp) {
+	return (should_escape(cp) ? '' : `${bidi_qq(safe_str_from_cps([cp]))} `) + quote_cp(cp);
+}
+
+// 20230211: some messages can be mixed-directional and result in spillover
+// use 200E after a quoted string to force the remainder of a string from 
+// acquring the direction of the quote
+// https://www.w3.org/International/questions/qa-bidi-unicode-controls#exceptions
+function bidi_qq(s) {
+	return `"${s}"\u200E`; // strong LTR
+}
+
+function check_label_extension(cps) {
+	if (cps.length >= 4 && cps[2] == HYPHEN && cps[3] == HYPHEN) {
+		throw new Error(`invalid label extension: "${str_from_cps(cps.slice(0, 4))}"`); // this can only be ascii so cant be bidi
+	}
+}
+function check_leading_underscore(cps) {
+	const UNDERSCORE = 0x5F;
+	for (let i = cps.lastIndexOf(UNDERSCORE); i > 0; ) {
+		if (cps[--i] !== UNDERSCORE) {
+			throw new Error('underscore allowed only at start');
+		}
+	}
+}
+// check that a fenced cp is not leading, trailing, or touching another fenced cp
+function check_fenced(cps) {
+	let cp = cps[0];
+	let prev = FENCED.get(cp);
+	if (prev) throw error_placement(`leading ${prev}`);
+	let n = cps.length;
+	let last = -1; // prevents trailing from throwing
+	for (let i = 1; i < n; i++) {
+		cp = cps[i];
+		let match = FENCED.get(cp);
+		if (match) {
+			// since cps[0] isn't fenced, cps[1] cannot throw
+			if (last == i) throw error_placement(`${prev} + ${match}`);
+			last = i + 1;
+			prev = match;
+		}
+	}
+	if (last == n) throw error_placement(`trailing ${prev}`);
+}
+
+// create a safe to print string 
+// invisibles are escaped
+// leading cm uses placeholder
+// if cps exceed max, middle truncate with ellipsis
+// quoter(cp) => string, eg. 3000 => "{3000}"
+// note: in html, you'd call this function then replace [<>&] with entities
+function safe_str_from_cps(cps, max = Infinity, quoter = quote_cp) {
+	//if (Number.isInteger(cps)) cps = [cps];
+	//if (!Array.isArray(cps)) throw new TypeError(`expected codepoints`);
+	let buf = [];
+	if (is_combining_mark(cps[0])) buf.push('◌');
+	if (cps.length > max) {
+		max >>= 1;
+		cps = [...cps.slice(0, max), 0x2026, ...cps.slice(-max)];
+	}
+	let prev = 0;
+	let n = cps.length;
+	for (let i = 0; i < n; i++) {
+		let cp = cps[i];
+		if (should_escape(cp)) {
+			buf.push(str_from_cps(cps.slice(prev, i)));
+			buf.push(quoter(cp));
+			prev = i + 1;
+		}
+	}
+	buf.push(str_from_cps(cps.slice(prev, n)));
+	return buf.join('');
+}
+
+// note: set(s) cannot be exposed because they can be modified
+// note: Object.freeze() doesn't work
+function is_combining_mark(cp) {
+	init();
+	return CM.has(cp);
+}
+function should_escape(cp) {
+	init();
+	return ESCAPE.has(cp);
+}
+
+function ens_normalize(name) {
+	return flatten(split(name, nfc, filter_fe0f));
+}
+
+function split(name, nf, ef) {
+	if (!name) return []; // 20230719: empty name allowance
+	init();
+	let offset = 0;
+	// https://unicode.org/reports/tr46/#Validity_Criteria
+	// 4.) "The label must not contain a U+002E ( . ) FULL STOP."
+	return name.split(STOP_CH).map(label => {
+		let input = explode_cp(label);
+		let info = {
+			input,
+			offset, // codepoint, not substring!
+		};
+		offset += input.length + 1; // + stop
+		try {
+			// 1.) "The label must be in Unicode Normalization Form NFC"
+			let tokens = info.tokens = tokens_from_str(input, nf, ef);
+			let token_count = tokens.length;
+			let type;
+			if (!token_count) { // the label was effectively empty (could of had ignored characters)
+				//norm = [];
+				//type = 'None'; // use this instead of next match, "ASCII"
+				// 20230120: change to strict
+				// https://discuss.ens.domains/t/ens-name-normalization-2nd/14564/59
+				throw new Error(`empty label`);
+			} 
+			let norm = info.output = tokens.flat();
+			check_leading_underscore(norm);
+			let emoji = info.emoji = token_count > 1 || tokens[0].is_emoji; // same as: tokens.some(x => x.is_emoji);
+			if (!emoji && norm.every(cp => cp < 0x80)) { // special case for ascii
+				// 20230123: matches matches WHATWG, see note 3.3
+				check_label_extension(norm); // only needed for ascii
+				// cant have fenced
+				// cant have cm
+				// cant have wholes
+				// see derive: "Fastpath ASCII"
+				type = 'ASCII';
+			} else {
+				let chars = tokens.flatMap(x => x.is_emoji ? [] : x); // all of the nfc tokens concat together
+				if (!chars.length) { // theres no text, just emoji
+					type = 'Emoji';
+				} else {
+					// 5.) "The label must not begin with a combining mark, that is: General_Category=Mark."
+					if (CM.has(norm[0])) throw error_placement('leading combining mark');
+					for (let i = 1; i < token_count; i++) { // we've already checked the first token
+						let cps = tokens[i];
+						if (!cps.is_emoji && CM.has(cps[0])) { // every text token has emoji neighbors, eg. EtEEEtEt...
+							// bidi_qq() not needed since emoji is LTR and cps is a CM
+							throw error_placement(`emoji + combining mark: "${str_from_cps(tokens[i-1])} + ${safe_str_from_cps([cps[0]])}"`); 
+						}
+					}
+					check_fenced(norm);
+					let unique = Array_from(new Set(chars));
+					let [g] = determine_group(unique); // take the first match
+					// see derive: "Matching Groups have Same CM Style"
+					// alternative: could form a hybrid type: Latin/Japanese/...	
+					check_group(g, chars); // need text in order
+					check_whole(g, unique); // only need unique text (order would be required for multiple-char confusables)
+					type = g.N;
+					// 20230121: consider exposing restricted flag
+					// it's simpler to just check for 'Restricted'
+					// or even better: type.endsWith(']')
+					//if (g.R) info.restricted = true;
+				}
+			}
+			info.type = type;
+		} catch (err) {
+			info.error = err; // use full error object
+		}
+		return info;
+	});
+}
+
+function check_whole(group, unique) {
+	let maker;
+	let shared = [];
+	for (let cp of unique) {
+		let whole = WHOLE_MAP.get(cp);
+		if (whole === UNIQUE_PH) return; // unique, non-confusable
+		if (whole) {
+			let set = whole.M.get(cp); // groups which have a character that look-like this character
+			maker = maker ? maker.filter(g => set.has(g)) : Array_from(set);
+			if (!maker.length) return; // confusable intersection is empty
+		} else {
+			shared.push(cp); 
+		}
+	}
+	if (maker) {
+		// we have 1+ confusable
+		// check if any of the remaining groups
+		// contain the shared characters too
+		for (let g of maker) {
+			if (shared.every(cp => group_has_cp(g, cp))) {
+				throw new Error(`whole-script confusable: ${group.N}/${g.N}`);
+			}
+		}
+	}
+}
+
+// assumption: unique.size > 0
+// returns list of matching groups
+function determine_group(unique) {
+	let groups = GROUPS;
+	for (let cp of unique) {
+		// note: we need to dodge CM that are whitelisted
+		// but that code isn't currently necessary
+		let gs = groups.filter(g => group_has_cp(g, cp));
+		if (!gs.length) {
+			if (!GROUPS.some(g => group_has_cp(g, cp))) { 
+				// the character was composed of valid parts
+				// but it's NFC form is invalid
+				// 20230716: change to more exact statement, see: ENSNormalize.{cs,java}
+				// note: this doesn't have to be a composition
+				// 20230720: change to full check
+				throw error_disallowed(cp); // this should be rare
+			} else {
+				// there is no group that contains all these characters
+				// throw using the highest priority group that matched
+				// https://www.unicode.org/reports/tr39/#mixed_script_confusables
+				throw error_group_member(groups[0], cp);
+			}
+		}
+		groups = gs;
+		if (gs.length == 1) break; // there is only one group left
+	}
+	// there are at least 1 group(s) with all of these characters
+	return groups;
+}
+
+// throw on first error
+function flatten(split) {
+	return split.map(({input, error, output}) => {
+		if (error) {
+			// don't print label again if just a single label
+			let msg = error.message;
+			// bidi_qq() only necessary if msg is digits
+			throw new Error(split.length == 1 ? msg : `Invalid label ${bidi_qq(safe_str_from_cps(input, 63))}: ${msg}`); 
+		}
+		return str_from_cps(output);
+	}).join(STOP_CH);
+}
+
+function error_disallowed(cp) {
+	// TODO: add cp to error?
+	return new Error(`disallowed character: ${quoted_cp(cp)}`); 
+}
+function error_group_member(g, cp) {
+	let quoted = quoted_cp(cp);
+	let gg = GROUPS.find(g => g.P.has(cp)); // only check primary
+	if (gg) {
+		quoted = `${gg.N} ${quoted}`;
+	}
+	return new Error(`illegal mixture: ${g.N} + ${quoted}`);
+}
+function error_placement(where) {
+	return new Error(`illegal placement: ${where}`);
+}
+
+// assumption: cps.length > 0
+// assumption: cps[0] isn't a CM
+// assumption: the previous character isn't an emoji
+function check_group(g, cps) {
+	for (let cp of cps) {
+		if (!group_has_cp(g, cp)) {
+			// for whitelisted scripts, this will throw illegal mixture on invalid cm, eg. "e{300}{300}"
+			// at the moment, it's unnecessary to introduce an extra error type
+			// until there exists a whitelisted multi-character
+			//   eg. if (M < 0 && is_combining_mark(cp)) { ... }
+			// there are 3 cases:
+			//   1. illegal cm for wrong group => mixture error
+			//   2. illegal cm for same group => cm error
+			//       requires set of whitelist cm per group: 
+			//        eg. new Set([...g.P, ...g.Q].flatMap(nfc).filter(cp => CM.has(cp)))
+			//   3. wrong group => mixture error
+			throw error_group_member(g, cp);
+		}
+	}
+	//if (M >= 0) { // we have a known fixed cm count
+	if (g.M) { // we need to check for NSM
+		let decomposed = nfd(cps);
+		for (let i = 1, e = decomposed.length; i < e; i++) { // see: assumption
+			// 20230210: bugfix: using cps instead of decomposed h/t Carbon225
+			/*
+			if (CM.has(decomposed[i])) {
+				let j = i + 1;
+				while (j < e && CM.has(decomposed[j])) j++;
+				if (j - i > M) {
+					throw new Error(`too many combining marks: ${g.N} ${bidi_qq(str_from_cps(decomposed.slice(i-1, j)))} (${j-i}/${M})`);
+				}
+				i = j;
+			}
+			*/
+			// 20230217: switch to NSM counting
+			// https://www.unicode.org/reports/tr39/#Optional_Detection
+			if (NSM.has(decomposed[i])) {
+				let j = i + 1;
+				for (let cp; j < e && NSM.has(cp = decomposed[j]); j++) {
+					// a. Forbid sequences of the same nonspacing mark.
+					for (let k = i; k < j; k++) { // O(n^2) but n < 100
+						if (decomposed[k] == cp) {
+							throw new Error(`duplicate non-spacing marks: ${quoted_cp(cp)}`);
+						}
+					}
+				}
+				// parse to end so we have full nsm count
+				// b. Forbid sequences of more than 4 nonspacing marks (gc=Mn or gc=Me).
+				if (j - i > NSM_MAX) {
+					// note: this slice starts with a base char or spacing-mark cm
+					throw new Error(`excessive non-spacing marks: ${bidi_qq(safe_str_from_cps(decomposed.slice(i-1, j)))} (${j-i}/${NSM_MAX})`);
+				}
+				i = j;
+			}
+		}
+	}
+	// *** this code currently isn't needed ***
+	/*
+	let cm_whitelist = M instanceof Map;
+	for (let i = 0, e = cps.length; i < e; ) {
+		let cp = cps[i++];
+		let seqs = cm_whitelist && M.get(cp);
+		if (seqs) { 
+			// list of codepoints that can follow
+			// if this exists, this will always be 1+
+			let j = i;
+			while (j < e && CM.has(cps[j])) j++;
+			let cms = cps.slice(i, j);
+			let match = seqs.find(seq => !compare_arrays(seq, cms));
+			if (!match) throw new Error(`disallowed combining mark sequence: "${safe_str_from_cps([cp, ...cms])}"`);
+			i = j;
+		} else if (!V.has(cp)) {
+			// https://www.unicode.org/reports/tr39/#mixed_script_confusables
+			let quoted = quoted_cp(cp);
+			for (let cp of cps) {
+				let u = UNIQUE.get(cp);
+				if (u && u !== g) {
+					// if both scripts are restricted this error is confusing
+					// because we don't differentiate RestrictedA from RestrictedB 
+					if (!u.R) quoted = `${quoted} is ${u.N}`;
+					break;
+				}
+			}
+			throw new Error(`disallowed ${g.N} character: ${quoted}`);
+			//throw new Error(`disallowed character: ${quoted} (expected ${g.N})`);
+			//throw new Error(`${g.N} does not allow: ${quoted}`);
+		}
+	}
+	if (!cm_whitelist) {
+		let decomposed = nfd(cps);
+		for (let i = 1, e = decomposed.length; i < e; i++) { // we know it can't be cm leading
+			if (CM.has(decomposed[i])) {
+				let j = i + 1;
+				while (j < e && CM.has(decomposed[j])) j++;
+				if (j - i > M) {
+					throw new Error(`too many combining marks: "${str_from_cps(decomposed.slice(i-1, j))}" (${j-i}/${M})`);
+				}
+				i = j;
+			}
+		}
+	}
+	*/
+}
+
+// given a list of codepoints
+// returns a list of lists, where emoji are a fully-qualified (as Array subclass)
+// eg. explode_cp("abc💩d") => [[61, 62, 63], Emoji[1F4A9, FE0F], [64]]
+// 20230818: rename for 'process' name collision h/t Javarome
+// https://github.com/adraffy/ens-normalize.js/issues/23
+function tokens_from_str(input, nf, ef) {
+	let ret = [];
+	let chars = [];
+	input = input.slice().reverse(); // flip so we can pop
+	while (input.length) {
+		let emoji = consume_emoji_reversed(input);
+		if (emoji) {
+			if (chars.length) {
+				ret.push(nf(chars));
+				chars = [];
+			}
+			ret.push(ef(emoji));
+		} else {
+			let cp = input.pop();
+			if (VALID.has(cp)) {
+				chars.push(cp);
+			} else {
+				let cps = MAPPED.get(cp);
+				if (cps) {
+					chars.push(...cps); // less than 10 elements
+				} else if (!IGNORED.has(cp)) {
+					// 20230912: unicode 15.1 changed the order of processing such that
+					// disallowed parts are only rejected after NFC
+					// https://unicode.org/reports/tr46/#Validity_Criteria
+					// this doesn't impact normalization as of today
+					// technically, this error can be removed as the group logic will apply similar logic
+					// however the error type might be less clear
+					throw error_disallowed(cp);
+				}
+			}
+		}
+	}
+	if (chars.length) {
+		ret.push(nf(chars));
+	}
+	return ret;
+}
+
+function filter_fe0f(cps) {
+	return cps.filter(cp => cp != FE0F);
+}
+
+// given array of codepoints
+// returns the longest valid emoji sequence (or undefined if no match)
+// *MUTATES* the supplied array
+// disallows interleaved ignored characters
+// fills (optional) eaten array with matched codepoints
+function consume_emoji_reversed(cps, eaten) {
+	let node = EMOJI_ROOT;
+	let emoji;
+	let pos = cps.length;
+	while (pos) {
+		node = node.get(cps[--pos]);
+		if (!node) break;
+		let {V} = node;
+		if (V) { // this is a valid emoji (so far)
+			emoji = V;
+			cps.length = pos; // truncate
+		}
+	}
+	return emoji;
 }
 
 const Zeros = new Uint8Array(32);
@@ -19229,7 +19028,6 @@ class JsonRpcApiProvider extends AbstractProvider {
                     address: a.address,
                     nonce: toQuantity(a.nonce),
                     chainId: toQuantity(a.chainId),
-                    yParity: toQuantity(a.signature.yParity),
                     r: toQuantity(a.signature.r),
                     s: toQuantity(a.signature.s),
                 };
@@ -20544,7 +20342,7 @@ function decryptKeystoreJsonSync(json, _password) {
     else {
         pass = toUtf8String(_password);
     }
-    let wal = qcsdk.deserializeEncryptedWallet(json, pass);
+    let wal = deserializeEncryptedWallet(json, pass);
     let privKey = wal.privateKey;
     let ks = {
         address: wal.address,
@@ -20564,13 +20362,13 @@ function encryptKeystoreJsonSync(account, password) {
     const signingKey = new SigningKey(account.privateKey);
     const privateKey = getBytes(signingKey.privateKey);
     const publicKey = getBytes(signingKey.publicKey);
-    const wal = new qcsdk.Wallet(account.address, privateKey, publicKey);
+    const wal = new Wallet$1(account.address, privateKey, publicKey);
     if (typeof password === 'string') {
-        return qcsdk.serializeEncryptedWallet(wal, password);
+        return serializeEncryptedWallet(wal, password);
     }
     else {
         let passPhrase = toUtf8String(password);
-        return qcsdk.serializeEncryptedWallet(wal, passPhrase);
+        return serializeEncryptedWallet(wal, passPhrase);
     }
 }
 
@@ -20666,7 +20464,7 @@ class Wallet extends BaseWallet {
      *  If there is no crytographic random source, this will throw.
      */
     static createRandom(provider) {
-        let wal = qcsdk.newWallet();
+        let wal = newWallet();
         let privKey = wal.privateKey;
         return new Wallet(hexlify(privKey));
     }
@@ -20956,6 +20754,10 @@ const wordlists = {
 
 /////////////////////////////
 //
+async function initQuantum() {
+    let clientConfigVal = new Config("https://sdk.readrelay.quantumcoinapi.com", "https://sdk.writerelay.quantumcoinapi.com", 123123, "", ""); //Mainnet
+    return await initialize(clientConfigVal);
+}
 // dummy change; to pick-up ws security issue changes
 
 var quantumcoin = /*#__PURE__*/Object.freeze({
@@ -21084,6 +20886,7 @@ var quantumcoin = /*#__PURE__*/Object.freeze({
     hashMessage: hashMessage,
     hexlify: hexlify,
     id: id,
+    initQuantum: initQuantum,
     isAddress: isAddress,
     isAddressable: isAddressable,
     isBytesLike: isBytesLike,
@@ -21133,5 +20936,5 @@ var quantumcoin = /*#__PURE__*/Object.freeze({
     zeroPadValue: zeroPadValue
 });
 
-export { AbiCoder, AbstractProvider, AbstractSigner, BaseContract, BaseWallet, Block, BrowserProvider, ConstructorFragment, Contract, ContractEventPayload, ContractFactory, ContractTransactionReceipt, ContractTransactionResponse, ContractUnknownEventPayload, EnsPlugin, EnsResolver, ErrorDescription, ErrorFragment, EtherSymbol, EventFragment, EventLog, EventPayload, FallbackFragment, FallbackProvider, FeeData, FeeDataNetworkPlugin, FetchCancelSignal, FetchRequest, FetchResponse, FetchUrlFeeDataNetworkPlugin, FixedNumber, Fragment, FunctionFragment, GasCostPlugin, Indexed, Interface, IpcSocketProvider, JsonRpcApiProvider, JsonRpcProvider, JsonRpcSigner, LangEn, Log, LogDescription, MaxInt256, MaxUint256, MessagePrefix, MinInt256, MulticoinProviderPlugin, N, NamedFragment, Network, NetworkPlugin, NonceManager, ParamType, Result, Signature, SigningKey, SocketBlockSubscriber, SocketEventSubscriber, SocketPendingSubscriber, SocketProvider, SocketSubscriber, StructFragment, Transaction, TransactionDescription, TransactionReceipt, TransactionResponse, Typed, TypedDataEncoder, UndecodedEventLog, UnmanagedSubscriber, Utf8ErrorFuncs, VoidSigner, Wallet, WebSocketProvider, WeiPerEther, Wordlist, WordlistOwl, WordlistOwlA, ZeroAddress, ZeroHash, accessListify, assert, assertArgument, assertArgumentCount, assertNormalize, assertPrivate, authorizationify, checkResultErrors, computeAddress, computeHmac, concat, copyRequest, dataLength, dataSlice, decodeBase58, decodeBase64, decodeBytes32String, decodeRlp, decryptKeystoreJsonSync, defineProperties, dnsEncode, encodeBase58, encodeBase64, encodeBytes32String, encodeRlp, encryptKeystoreJsonSync, ensNormalize, quantumcoin as ethers, formatEther, formatUnits, fromTwos, getAddress, getBigInt, getBytes, getBytesCopy, getCreate2Address, getCreateAddress, getDefaultProvider, getNumber, getUint, hashAuthorization, hashMessage, hexlify, id, isAddress, isAddressable, isBytesLike, isCallException, isError, isHexString, isKeystoreJson, isValidName, keccak256, lock, makeError, mask, namehash, parseEther, parseUnits, pbkdf2, randomBytes, recoverAddress, resolveAddress, resolveProperties, ripemd160, scrypt, scryptSync, sha256, sha512, showThrottleMessage, solidityPacked, solidityPackedKeccak256, solidityPackedSha256, stripZerosLeft, toBeArray, toBeHex, toBigInt, toNumber, toQuantity, toTwos, toUtf8Bytes, toUtf8CodePoints, toUtf8String, uuidV4, verifyAuthorization, verifyMessage, verifyTypedData, version, wordlists, zeroPadBytes, zeroPadValue };
+export { AbiCoder, AbstractProvider, AbstractSigner, BaseContract, BaseWallet, Block, BrowserProvider, ConstructorFragment, Contract, ContractEventPayload, ContractFactory, ContractTransactionReceipt, ContractTransactionResponse, ContractUnknownEventPayload, EnsPlugin, EnsResolver, ErrorDescription, ErrorFragment, EtherSymbol, EventFragment, EventLog, EventPayload, FallbackFragment, FallbackProvider, FeeData, FeeDataNetworkPlugin, FetchCancelSignal, FetchRequest, FetchResponse, FetchUrlFeeDataNetworkPlugin, FixedNumber, Fragment, FunctionFragment, GasCostPlugin, Indexed, Interface, IpcSocketProvider, JsonRpcApiProvider, JsonRpcProvider, JsonRpcSigner, LangEn, Log, LogDescription, MaxInt256, MaxUint256, MessagePrefix, MinInt256, MulticoinProviderPlugin, N, NamedFragment, Network, NetworkPlugin, NonceManager, ParamType, Result, Signature, SigningKey, SocketBlockSubscriber, SocketEventSubscriber, SocketPendingSubscriber, SocketProvider, SocketSubscriber, StructFragment, Transaction, TransactionDescription, TransactionReceipt, TransactionResponse, Typed, TypedDataEncoder, UndecodedEventLog, UnmanagedSubscriber, Utf8ErrorFuncs, VoidSigner, Wallet, WebSocketProvider, WeiPerEther, Wordlist, WordlistOwl, WordlistOwlA, ZeroAddress, ZeroHash, accessListify, assert, assertArgument, assertArgumentCount, assertNormalize, assertPrivate, authorizationify, checkResultErrors, computeAddress, computeHmac, concat, copyRequest, dataLength, dataSlice, decodeBase58, decodeBase64, decodeBytes32String, decodeRlp, decryptKeystoreJsonSync, defineProperties, dnsEncode, encodeBase58, encodeBase64, encodeBytes32String, encodeRlp, encryptKeystoreJsonSync, ensNormalize, quantumcoin as ethers, formatEther, formatUnits, fromTwos, getAddress, getBigInt, getBytes, getBytesCopy, getCreate2Address, getCreateAddress, getDefaultProvider, getNumber, getUint, hashAuthorization, hashMessage, hexlify, id, initQuantum, isAddress, isAddressable, isBytesLike, isCallException, isError, isHexString, isKeystoreJson, isValidName, keccak256, lock, makeError, mask, namehash, parseEther, parseUnits, pbkdf2, randomBytes, recoverAddress, resolveAddress, resolveProperties, ripemd160, scrypt, scryptSync, sha256, sha512, showThrottleMessage, solidityPacked, solidityPackedKeccak256, solidityPackedSha256, stripZerosLeft, toBeArray, toBeHex, toBigInt, toNumber, toQuantity, toTwos, toUtf8Bytes, toUtf8CodePoints, toUtf8String, uuidV4, verifyAuthorization, verifyMessage, verifyTypedData, version, wordlists, zeroPadBytes, zeroPadValue };
 //# sourceMappingURL=quantumcoin.js.map