quantumcoin 6.14.2 → 6.14.5

package/dist/quantumcoin.umd.js

@@ -1,15 +1,15 @@
 const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !== 'undefined' ? window: typeof global !== 'undefined' ? global: typeof self !== 'undefined' ? self: {});
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ethers = {}));
-})(this, (function (exports) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('quantum-coin-js-sdk'), require('quantum-coin-pqc-js-sdk')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'quantum-coin-js-sdk', 'quantum-coin-pqc-js-sdk'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ethers = {}, global.quantumCoinJsSdk, global.quantumCoinPqcJsSdk));
+})(this, (function (exports, quantumCoinJsSdk, quantumCoinPqcJsSdk) { 'use strict';
 
     /* 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.
@@ -461,7 +461,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
      *
      *  @_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
@@ -475,7 +475,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
     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
@@ -495,7 +495,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
         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
@@ -551,7 +551,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
      */
     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;
@@ -637,7 +637,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
      */
     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);
@@ -695,7 +695,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
         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.
@@ -721,7 +721,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
      *  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]);
@@ -1915,7 +1915,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
      *  @_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 = {};
@@ -1939,7 +1939,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
             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 {
@@ -1997,7 +1997,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
     }
     function toString(val, decimals) {
         let negative = "";
-        if (val < BN_0$8) {
+        if (val < BN_0$7) {
             negative = "-";
             val *= BN_N1;
         }
@@ -2188,13 +2188,13 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
         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);
@@ -2218,12 +2218,12 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
          *  (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");
@@ -2282,7 +2282,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
          */
         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;
@@ -2296,7 +2296,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
          */
         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;
@@ -2325,11 +2325,11 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
         /**
          *  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%%.
          */
@@ -2366,7 +2366,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
             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;
@@ -4779,11 +4779,6 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
     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 {
@@ -4799,7 +4794,6 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
         #r;
         #s;
         #v;
-        #networkV;
         /**
          *  The ``r`` value for a signature.
          *
@@ -4820,67 +4814,22 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
         }
         /**
          *  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
@@ -4890,94 +4839,26 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
             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]].
          *
@@ -4991,85 +4872,20 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
                 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);
         }
     }
 
@@ -5080,7 +4896,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
      */
     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.
      */
@@ -5107,9 +4923,10 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
          */
         sign(digest) {
             assertArgument(dataLength(digest) === CRYPTO_MESSAGE_LENGTH, "invalid digest length", "digest", digest);
-            const sig = pqc.cryptoSign(getBytesCopy(digest), getBytesCopy(this.#privateKey));
+            const sig = quantumCoinPqcJsSdk.cryptoSign(getBytesCopy(digest), getBytesCopy(this.#privateKey));
             const pubBytes = getBytes(this.publicKey);
-            const combinedSig = qcsdk.combinePublicKeySignature(pubBytes, sig);
+            let combinedSig = quantumCoinJsSdk.combinePublicKeySignature(pubBytes, sig);
+            combinedSig = "0x" + combinedSig;
             return Signature.from({
                 r: this.publicKey,
                 s: combinedSig,
@@ -5117,7 +4934,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
             });
         }
         /**
-         *  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:
@@ -5128,9 +4945,17 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
          *    //_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 = quantumCoinJsSdk.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;
         }
         /**
@@ -5156,7 +4981,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
             const sig = Signature.from(signature);
             let sigBytes = getBytes(sig.s);
             let digestBytes = digest;
-            let publicKey = qcsdk.publicKeyFromSignature(digestBytes, sigBytes);
+            let publicKey = quantumCoinJsSdk.publicKeyFromSignature(digestBytes, sigBytes);
             return publicKey;
         }
     }
@@ -6560,13 +6385,18 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
     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 quantumCoinJsSdk.addressFromPublicKey(pubKeyBytes);
     }
     /**
      *  Returns the recovered address for the private key that was
@@ -6663,9 +6493,9 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
                     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
                     })
                 });
             }
@@ -6704,7 +6534,6 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
                 formatNumber(a.chainId, "chainId"),
                 a.address,
                 formatNumber(a.nonce, "nonce"),
-                formatNumber(a.signature.yParity, "yParity"),
                 a.signature.r,
                 a.signature.s
             ];
@@ -6772,17 +6601,8 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
         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)
@@ -6793,17 +6613,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
             }
             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));
@@ -6811,19 +6621,9 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
         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) {
@@ -6863,7 +6663,6 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
             formatAccessList(tx.accessList || [])
         ];
         if (sig) {
-            fields.push(formatNumber(sig.yParity, "yParity"));
             fields.push(toBeArray(sig.r));
             fields.push(toBeArray(sig.s));
         }
@@ -6903,7 +6702,6 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
             formatAccessList(tx.accessList || [])
         ];
         if (sig) {
-            fields.push(formatNumber(sig.yParity, "recoveryParam"));
             fields.push(toBeArray(sig.r));
             fields.push(toBeArray(sig.s));
         }
@@ -6981,7 +6779,6 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
             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
@@ -7037,7 +6834,6 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
             formatAuthorizationList(tx.authorizationList || [])
         ];
         if (sig) {
-            fields.push(formatNumber(sig.yParity, "yParity"));
             fields.push(toBeArray(sig.r));
             fields.push(toBeArray(sig.s));
         }
@@ -7758,276 +7554,276 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
     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)));
+    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);
+    			}
+    		}
+    	}
     }
 
-    // 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);
-    			}
-    		}
-    	}
-    }
-
-    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
@@ -8037,786 +7833,786 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
     // SHA-256: a974b6f8541fc29d919bc85118af0a44015851fab5343f8679cb31be2bdb209e
     var COMPRESSED = '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';
 
-    // 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;
-    	}
+    // 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));
     }
 
-    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);
@@ -19235,7 +19031,6 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
                         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),
                     };
@@ -20550,7 +20345,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
         else {
             pass = toUtf8String(_password);
         }
-        let wal = qcsdk.deserializeEncryptedWallet(json, pass);
+        let wal = quantumCoinJsSdk.deserializeEncryptedWallet(json, pass);
         let privKey = wal.privateKey;
         let ks = {
             address: wal.address,
@@ -20570,13 +20365,13 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
         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 quantumCoinJsSdk.Wallet(account.address, privateKey, publicKey);
         if (typeof password === 'string') {
-            return qcsdk.serializeEncryptedWallet(wal, password);
+            return quantumCoinJsSdk.serializeEncryptedWallet(wal, password);
         }
         else {
             let passPhrase = toUtf8String(password);
-            return qcsdk.serializeEncryptedWallet(wal, passPhrase);
+            return quantumCoinJsSdk.serializeEncryptedWallet(wal, passPhrase);
         }
     }
 
@@ -20672,7 +20467,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
          *  If there is no crytographic random source, this will throw.
          */
         static createRandom(provider) {
-            let wal = qcsdk.newWallet();
+            let wal = quantumCoinJsSdk.newWallet();
             let privKey = wal.privateKey;
             return new Wallet(hexlify(privKey));
         }
@@ -20962,6 +20757,10 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
 
     /////////////////////////////
     //
+    async function initQuantum() {
+        let clientConfigVal = new quantumCoinJsSdk.Config("https://sdk.readrelay.quantumcoinapi.com", "https://sdk.writerelay.quantumcoinapi.com", 123123, "", ""); //Mainnet
+        return await quantumCoinJsSdk.initialize(clientConfigVal);
+    }
     // dummy change; to pick-up ws security issue changes
 
     var quantumcoin = /*#__PURE__*/Object.freeze({
@@ -21090,6 +20889,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
         hashMessage: hashMessage,
         hexlify: hexlify,
         id: id,
+        initQuantum: initQuantum,
         isAddress: isAddress,
         isAddressable: isAddressable,
         isBytesLike: isBytesLike,
@@ -21264,6 +21064,7 @@ const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !==
     exports.hashMessage = hashMessage;
     exports.hexlify = hexlify;
     exports.id = id;
+    exports.initQuantum = initQuantum;
     exports.isAddress = isAddress;
     exports.isAddressable = isAddressable;
     exports.isBytesLike = isBytesLike;