@0xpolygonid/js-sdk 1.19.0 → 1.20.1

package/dist/browser/esm/index.js

@@ -2031,10 +2031,16 @@ function randomBytes$1(bytesLength = 32) {
     if (crypto$3 && typeof crypto$3.getRandomValues === 'function') {
         return crypto$3.getRandomValues(new Uint8Array(bytesLength));
     }
+    // Legacy Node.js compatibility
+    if (crypto$3 && typeof crypto$3.randomBytes === 'function') {
+        return crypto$3.randomBytes(bytesLength);
+    }
     throw new Error('crypto.getRandomValues must be defined');
 }
 
-// Polyfill for Safari 14
+/**
+ * Polyfill for Safari 14
+ */
 function setBigUint64$1(view, byteOffset, value, isLE) {
     if (typeof view.setBigUint64 === 'function')
         return view.setBigUint64(byteOffset, value, isLE);
@@ -2047,9 +2053,13 @@ function setBigUint64$1(view, byteOffset, value, isLE) {
     view.setUint32(byteOffset + h, wh, isLE);
     view.setUint32(byteOffset + l, wl, isLE);
 }
-// Choice: a ? b : c
+/**
+ * Choice: a ? b : c
+ */
 const Chi$1 = (a, b, c) => (a & b) ^ (~a & c);
-// Majority function, true if any two inpust is true
+/**
+ * Majority function, true if any two inputs is true
+ */
 const Maj$1 = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
 /**
  * Merkle-Damgard hash construction base class.
@@ -3239,6 +3249,60 @@ function wNAF$1(c, bits) {
         },
     };
 }
+/**
+ * Pippenger algorithm for multi-scalar multiplication (MSM).
+ * MSM is basically (Pa + Qb + Rc + ...).
+ * 30x faster vs naive addition on L=4096, 10x faster with precomputes.
+ * For N=254bit, L=1, it does: 1024 ADD + 254 DBL. For L=5: 1536 ADD + 254 DBL.
+ * Algorithmically constant-time (for same L), even when 1 point + scalar, or when scalar = 0.
+ * @param c Curve Point constructor
+ * @param field field over CURVE.N - important that it's not over CURVE.P
+ * @param points array of L curve points
+ * @param scalars array of L scalars (aka private keys / bigints)
+ */
+function pippenger(c, field, points, scalars) {
+    // If we split scalars by some window (let's say 8 bits), every chunk will only
+    // take 256 buckets even if there are 4096 scalars, also re-uses double.
+    // TODO:
+    // - https://eprint.iacr.org/2024/750.pdf
+    // - https://tches.iacr.org/index.php/TCHES/article/view/10287
+    // 0 is accepted in scalars
+    if (!Array.isArray(points) || !Array.isArray(scalars) || scalars.length !== points.length)
+        throw new Error('arrays of points and scalars must have equal length');
+    scalars.forEach((s, i) => {
+        if (!field.isValid(s))
+            throw new Error(`wrong scalar at index ${i}`);
+    });
+    points.forEach((p, i) => {
+        if (!(p instanceof c))
+            throw new Error(`wrong point at index ${i}`);
+    });
+    const wbits = bitLen$1(BigInt(points.length));
+    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1; // in bits
+    const MASK = (1 << windowSize) - 1;
+    const buckets = new Array(MASK + 1).fill(c.ZERO); // +1 for zero array
+    const lastBits = Math.floor((field.BITS - 1) / windowSize) * windowSize;
+    let sum = c.ZERO;
+    for (let i = lastBits; i >= 0; i -= windowSize) {
+        buckets.fill(c.ZERO);
+        for (let j = 0; j < scalars.length; j++) {
+            const scalar = scalars[j];
+            const wbits = Number((scalar >> BigInt(i)) & BigInt(MASK));
+            buckets[wbits] = buckets[wbits].add(points[j]);
+        }
+        let resI = c.ZERO; // not using this will do small speed-up, but will lose ct
+        // Skip first bucket, because it is zero
+        for (let j = buckets.length - 1, sumI = c.ZERO; j > 0; j--) {
+            sumI = sumI.add(buckets[j]);
+            resI = resI.add(sumI);
+        }
+        sum = sum.add(resI);
+        if (i !== 0)
+            for (let j = 0; j < windowSize; j++)
+                sum = sum.double();
+    }
+    return sum;
+}
 function validateBasic$1(curve) {
     validateField$1(curve.Fp);
     validateObject$1(curve, {
@@ -3293,6 +3357,7 @@ function twistedEdwards(curveDef) {
     const { Fp, n: CURVE_ORDER, prehash: prehash, hash: cHash, randomBytes, nByteLength, h: cofactor, } = CURVE;
     const MASK = _2n$7 << (BigInt(nByteLength * 8) - _1n$a);
     const modP = Fp.create; // Function overrides
+    const Fn = Field$1(CURVE.n, CURVE.nBitLength);
     // sqrt(u/v)
     const uvRatio = CURVE.uvRatio ||
         ((u, v) => {
@@ -3391,6 +3456,10 @@ function twistedEdwards(curveDef) {
             const toInv = Fp.invertBatch(points.map((p) => p.ez));
             return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
         }
+        // Multiscalar Multiplication
+        static msm(points, scalars) {
+            return pippenger(Point, Fn, points, scalars);
+        }
         // "Private method", don't use it directly
         _setWindowSize(windowSize) {
             wnaf.setWindowSize(this, windowSize);
@@ -4040,6 +4109,10 @@ let HMAC$1 = class HMAC extends Hash$1 {
  * @param hash - function that would be used e.g. sha256
  * @param key - message key
  * @param message - message data
+ * @example
+ * import { hmac } from '@noble/hashes/hmac';
+ * import { sha256 } from '@noble/hashes/sha2';
+ * const mac1 = hmac(sha256, 'key', 'message');
  */
 const hmac$1 = (hash, key, message) => new HMAC$1(hash, key).update(message).digest();
 hmac$1.create = (hash, key) => new HMAC$1(hash, key);
@@ -4079,8 +4152,14 @@ function validatePointOpts$1(curve) {
     }
     return Object.freeze({ ...opts });
 }
-// ASN.1 DER encoding utilities
 const { bytesToNumberBE: b2n$1, hexToBytes: h2b$1 } = ut$1;
+/**
+ * ASN.1 DER encoding utilities. ASN is very complex & fragile. Format:
+ *
+ *     [0x30 (SEQUENCE), bytelength, 0x02 (INTEGER), intLength, R, 0x02 (INTEGER), intLength, S]
+ *
+ * Docs: https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/, https://luca.ntop.org/Teaching/Appunti/asn1.html
+ */
 const DER$1 = {
     // asn.1 DER encoding utils
     Err: class DERErr extends Error {
@@ -4088,54 +4167,103 @@ const DER$1 = {
             super(m);
         }
     },
-    _parseInt(data) {
-        const { Err: E } = DER$1;
-        if (data.length < 2 || data[0] !== 0x02)
-            throw new E('Invalid signature integer tag');
-        const len = data[1];
-        const res = data.subarray(2, len + 2);
-        if (!len || res.length !== len)
-            throw new E('Invalid signature integer: wrong length');
-        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
-        // since we always use positive integers here. It must always be empty:
-        // - add zero byte if exists
-        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
-        if (res[0] & 0b10000000)
-            throw new E('Invalid signature integer: negative');
-        if (res[0] === 0x00 && !(res[1] & 0b10000000))
-            throw new E('Invalid signature integer: unnecessary leading zero');
-        return { d: b2n$1(res), l: data.subarray(len + 2) }; // d is data, l is left
+    // Basic building block is TLV (Tag-Length-Value)
+    _tlv: {
+        encode: (tag, data) => {
+            const { Err: E } = DER$1;
+            if (tag < 0 || tag > 256)
+                throw new E('tlv.encode: wrong tag');
+            if (data.length & 1)
+                throw new E('tlv.encode: unpadded data');
+            const dataLen = data.length / 2;
+            const len = numberToHexUnpadded$1(dataLen);
+            if ((len.length / 2) & 128)
+                throw new E('tlv.encode: long form length too big');
+            // length of length with long form flag
+            const lenLen = dataLen > 127 ? numberToHexUnpadded$1((len.length / 2) | 128) : '';
+            return `${numberToHexUnpadded$1(tag)}${lenLen}${len}${data}`;
+        },
+        // v - value, l - left bytes (unparsed)
+        decode(tag, data) {
+            const { Err: E } = DER$1;
+            let pos = 0;
+            if (tag < 0 || tag > 256)
+                throw new E('tlv.encode: wrong tag');
+            if (data.length < 2 || data[pos++] !== tag)
+                throw new E('tlv.decode: wrong tlv');
+            const first = data[pos++];
+            const isLong = !!(first & 128); // First bit of first length byte is flag for short/long form
+            let length = 0;
+            if (!isLong)
+                length = first;
+            else {
+                // Long form: [longFlag(1bit), lengthLength(7bit), length (BE)]
+                const lenLen = first & 127;
+                if (!lenLen)
+                    throw new E('tlv.decode(long): indefinite length not supported');
+                if (lenLen > 4)
+                    throw new E('tlv.decode(long): byte length is too big'); // this will overflow u32 in js
+                const lengthBytes = data.subarray(pos, pos + lenLen);
+                if (lengthBytes.length !== lenLen)
+                    throw new E('tlv.decode: length bytes not complete');
+                if (lengthBytes[0] === 0)
+                    throw new E('tlv.decode(long): zero leftmost byte');
+                for (const b of lengthBytes)
+                    length = (length << 8) | b;
+                pos += lenLen;
+                if (length < 128)
+                    throw new E('tlv.decode(long): not minimal encoding');
+            }
+            const v = data.subarray(pos, pos + length);
+            if (v.length !== length)
+                throw new E('tlv.decode: wrong value length');
+            return { v, l: data.subarray(pos + length) };
+        },
+    },
+    // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
+    // since we always use positive integers here. It must always be empty:
+    // - add zero byte if exists
+    // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
+    _int: {
+        encode(num) {
+            const { Err: E } = DER$1;
+            if (num < _0n$6)
+                throw new E('integer: negative integers are not allowed');
+            let hex = numberToHexUnpadded$1(num);
+            // Pad with zero byte if negative flag is present
+            if (Number.parseInt(hex[0], 16) & 0b1000)
+                hex = '00' + hex;
+            if (hex.length & 1)
+                throw new E('unexpected assertion');
+            return hex;
+        },
+        decode(data) {
+            const { Err: E } = DER$1;
+            if (data[0] & 128)
+                throw new E('Invalid signature integer: negative');
+            if (data[0] === 0x00 && !(data[1] & 128))
+                throw new E('Invalid signature integer: unnecessary leading zero');
+            return b2n$1(data);
+        },
     },
     toSig(hex) {
         // parse DER signature
-        const { Err: E } = DER$1;
+        const { Err: E, _int: int, _tlv: tlv } = DER$1;
         const data = typeof hex === 'string' ? h2b$1(hex) : hex;
         abytes(data);
-        let l = data.length;
-        if (l < 2 || data[0] != 0x30)
-            throw new E('Invalid signature tag');
-        if (data[1] !== l - 2)
-            throw new E('Invalid signature: incorrect length');
-        const { d: r, l: sBytes } = DER$1._parseInt(data.subarray(2));
-        const { d: s, l: rBytesLeft } = DER$1._parseInt(sBytes);
-        if (rBytesLeft.length)
+        const { v: seqBytes, l: seqLeftBytes } = tlv.decode(0x30, data);
+        if (seqLeftBytes.length)
             throw new E('Invalid signature: left bytes after parsing');
-        return { r, s };
+        const { v: rBytes, l: rLeftBytes } = tlv.decode(0x02, seqBytes);
+        const { v: sBytes, l: sLeftBytes } = tlv.decode(0x02, rLeftBytes);
+        if (sLeftBytes.length)
+            throw new E('Invalid signature: left bytes after parsing');
+        return { r: int.decode(rBytes), s: int.decode(sBytes) };
     },
     hexFromSig(sig) {
-        // Add leading zero if first byte has negative bit enabled. More details in '_parseInt'
-        const slice = (s) => (Number.parseInt(s[0], 16) & 0b1000 ? '00' + s : s);
-        const h = (num) => {
-            const hex = num.toString(16);
-            return hex.length & 1 ? `0${hex}` : hex;
-        };
-        const s = slice(h(sig.s));
-        const r = slice(h(sig.r));
-        const shl = s.length / 2;
-        const rhl = r.length / 2;
-        const sl = h(shl);
-        const rl = h(rhl);
-        return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;
+        const { _tlv: tlv, _int: int } = DER$1;
+        const seq = `${tlv.encode(0x02, int.encode(sig.r))}${tlv.encode(0x02, int.encode(sig.s))}`;
+        return tlv.encode(0x30, seq);
     },
 };
 // Be friendly to bad ECMAScript parsers by not using bigint literals
@@ -4144,6 +4272,7 @@ const _0n$6 = BigInt(0), _1n$8 = BigInt(1); BigInt(2); const _3n$2 = BigInt(3);
 function weierstrassPoints$1(opts) {
     const CURVE = validatePointOpts$1(opts);
     const { Fp } = CURVE; // All curves has same field / group length as for now, but they can differ
+    const Fn = Field$1(CURVE.n, CURVE.nBitLength);
     const toBytes = CURVE.toBytes ||
         ((_c, point, _isCompressed) => {
             const a = point.toAffine();
@@ -4317,6 +4446,10 @@ function weierstrassPoints$1(opts) {
         static fromPrivateKey(privateKey) {
             return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
         }
+        // Multiscalar Multiplication
+        static msm(points, scalars) {
+            return pippenger(Point, Fn, points, scalars);
+        }
         // "Private method", don't use it directly
         _setWindowSize(windowSize) {
             wnaf.setWindowSize(this, windowSize);
@@ -7557,7 +7690,7 @@ const VerifiableConstants = Object.freeze({
         PUSH_NOTIFICATION: 'push-notification'
     },
     AUTH: {
-        AUTH_BJJ_CREDENTAIL_HASH: '013fd3f623559d850fb5b02ff012d0e2',
+        AUTH_BJJ_CREDENTIAL_HASH: '013fd3f623559d850fb5b02ff012d0e2',
         AUTH_BJJ_CREDENTIAL_SCHEMA_JSON_URL: 'https://schema.iden3.io/core/json/auth.json',
         AUTH_BJJ_CREDENTIAL_SCHEMA_JSONLD_URL: 'https://schema.iden3.io/core/jsonld/auth.jsonld',
         AUTH_BJJ_CREDENTIAL_TYPE: 'AuthBJJCredential',
@@ -7589,7 +7722,7 @@ var CredentialStatusType;
     CredentialStatusType["Iden3ReverseSparseMerkleTreeProof"] = "Iden3ReverseSparseMerkleTreeProof";
     // Iden3commRevocationStatusV1 is CredentialStatusType for iden3comm revocation status
     CredentialStatusType["Iden3commRevocationStatusV1"] = "Iden3commRevocationStatusV1.0";
-    // Iden3OnсhainSparseMerkleTreeProof2023 is a proof type for MTP proofs with iden3 metadata from blockchain
+    // Iden3OnchainSparseMerkleTreeProof2023 is a proof type for MTP proofs with iden3 metadata from blockchain
     CredentialStatusType["Iden3OnchainSparseMerkleTreeProof2023"] = "Iden3OnchainSparseMerkleTreeProof2023";
 })(CredentialStatusType || (CredentialStatusType = {}));
 /**
@@ -20007,7 +20140,7 @@ class W3CCredential {
     }
     async verifyIden3SparseMerkleTreeProof(proof, coreClaim, resolverURL) {
         await validateDIDDocumentAuth(proof.issuerData.id, resolverURL, proof.issuerData.state.value);
-        // root from proof == issuerData.state.сlaimsTreeRoot
+        // root from proof == issuerData.state.claimsTreeRoot
         const { hi, hv } = coreClaim.hiHv();
         const rootFromProofValue = await rootFromProof(proof.mtp, hi, hv);
         if (!rootFromProofValue.equals(proof.issuerData.state.claimsTreeRoot)) {
@@ -20905,169 +21038,162 @@ var codegen = {};
 
 var code$1 = {};
 
-var hasRequiredCode$1;
-
-function requireCode$1 () {
-	if (hasRequiredCode$1) return code$1;
-	hasRequiredCode$1 = 1;
-	(function (exports) {
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0;
-		class _CodeOrName {
-		}
-		exports._CodeOrName = _CodeOrName;
-		exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
-		class Name extends _CodeOrName {
-		    constructor(s) {
-		        super();
-		        if (!exports.IDENTIFIER.test(s))
-		            throw new Error("CodeGen: name must be a valid identifier");
-		        this.str = s;
-		    }
-		    toString() {
-		        return this.str;
-		    }
-		    emptyStr() {
-		        return false;
-		    }
-		    get names() {
-		        return { [this.str]: 1 };
-		    }
-		}
-		exports.Name = Name;
-		class _Code extends _CodeOrName {
-		    constructor(code) {
-		        super();
-		        this._items = typeof code === "string" ? [code] : code;
-		    }
-		    toString() {
-		        return this.str;
-		    }
-		    emptyStr() {
-		        if (this._items.length > 1)
-		            return false;
-		        const item = this._items[0];
-		        return item === "" || item === '""';
-		    }
-		    get str() {
-		        var _a;
-		        return ((_a = this._str) !== null && _a !== void 0 ? _a : (this._str = this._items.reduce((s, c) => `${s}${c}`, "")));
-		    }
-		    get names() {
-		        var _a;
-		        return ((_a = this._names) !== null && _a !== void 0 ? _a : (this._names = this._items.reduce((names, c) => {
-		            if (c instanceof Name)
-		                names[c.str] = (names[c.str] || 0) + 1;
-		            return names;
-		        }, {})));
-		    }
-		}
-		exports._Code = _Code;
-		exports.nil = new _Code("");
-		function _(strs, ...args) {
-		    const code = [strs[0]];
-		    let i = 0;
-		    while (i < args.length) {
-		        addCodeArg(code, args[i]);
-		        code.push(strs[++i]);
-		    }
-		    return new _Code(code);
-		}
-		exports._ = _;
-		const plus = new _Code("+");
-		function str(strs, ...args) {
-		    const expr = [safeStringify(strs[0])];
-		    let i = 0;
-		    while (i < args.length) {
-		        expr.push(plus);
-		        addCodeArg(expr, args[i]);
-		        expr.push(plus, safeStringify(strs[++i]));
-		    }
-		    optimize(expr);
-		    return new _Code(expr);
-		}
-		exports.str = str;
-		function addCodeArg(code, arg) {
-		    if (arg instanceof _Code)
-		        code.push(...arg._items);
-		    else if (arg instanceof Name)
-		        code.push(arg);
-		    else
-		        code.push(interpolate(arg));
-		}
-		exports.addCodeArg = addCodeArg;
-		function optimize(expr) {
-		    let i = 1;
-		    while (i < expr.length - 1) {
-		        if (expr[i] === plus) {
-		            const res = mergeExprItems(expr[i - 1], expr[i + 1]);
-		            if (res !== undefined) {
-		                expr.splice(i - 1, 3, res);
-		                continue;
-		            }
-		            expr[i++] = "+";
-		        }
-		        i++;
-		    }
-		}
-		function mergeExprItems(a, b) {
-		    if (b === '""')
-		        return a;
-		    if (a === '""')
-		        return b;
-		    if (typeof a == "string") {
-		        if (b instanceof Name || a[a.length - 1] !== '"')
-		            return;
-		        if (typeof b != "string")
-		            return `${a.slice(0, -1)}${b}"`;
-		        if (b[0] === '"')
-		            return a.slice(0, -1) + b.slice(1);
-		        return;
-		    }
-		    if (typeof b == "string" && b[0] === '"' && !(a instanceof Name))
-		        return `"${a}${b.slice(1)}`;
-		    return;
-		}
-		function strConcat(c1, c2) {
-		    return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str `${c1}${c2}`;
-		}
-		exports.strConcat = strConcat;
-		// TODO do not allow arrays here
-		function interpolate(x) {
-		    return typeof x == "number" || typeof x == "boolean" || x === null
-		        ? x
-		        : safeStringify(Array.isArray(x) ? x.join(",") : x);
-		}
-		function stringify(x) {
-		    return new _Code(safeStringify(x));
-		}
-		exports.stringify = stringify;
-		function safeStringify(x) {
-		    return JSON.stringify(x)
-		        .replace(/\u2028/g, "\\u2028")
-		        .replace(/\u2029/g, "\\u2029");
-		}
-		exports.safeStringify = safeStringify;
-		function getProperty(key) {
-		    return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _ `[${key}]`;
-		}
-		exports.getProperty = getProperty;
-		//Does best effort to format the name properly
-		function getEsmExportName(key) {
-		    if (typeof key == "string" && exports.IDENTIFIER.test(key)) {
-		        return new _Code(`${key}`);
-		    }
-		    throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
-		}
-		exports.getEsmExportName = getEsmExportName;
-		function regexpCode(rx) {
-		    return new _Code(rx.toString());
-		}
-		exports.regexpCode = regexpCode;
-		
-	} (code$1));
-	return code$1;
-}
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0;
+	class _CodeOrName {
+	}
+	exports._CodeOrName = _CodeOrName;
+	exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
+	class Name extends _CodeOrName {
+	    constructor(s) {
+	        super();
+	        if (!exports.IDENTIFIER.test(s))
+	            throw new Error("CodeGen: name must be a valid identifier");
+	        this.str = s;
+	    }
+	    toString() {
+	        return this.str;
+	    }
+	    emptyStr() {
+	        return false;
+	    }
+	    get names() {
+	        return { [this.str]: 1 };
+	    }
+	}
+	exports.Name = Name;
+	class _Code extends _CodeOrName {
+	    constructor(code) {
+	        super();
+	        this._items = typeof code === "string" ? [code] : code;
+	    }
+	    toString() {
+	        return this.str;
+	    }
+	    emptyStr() {
+	        if (this._items.length > 1)
+	            return false;
+	        const item = this._items[0];
+	        return item === "" || item === '""';
+	    }
+	    get str() {
+	        var _a;
+	        return ((_a = this._str) !== null && _a !== void 0 ? _a : (this._str = this._items.reduce((s, c) => `${s}${c}`, "")));
+	    }
+	    get names() {
+	        var _a;
+	        return ((_a = this._names) !== null && _a !== void 0 ? _a : (this._names = this._items.reduce((names, c) => {
+	            if (c instanceof Name)
+	                names[c.str] = (names[c.str] || 0) + 1;
+	            return names;
+	        }, {})));
+	    }
+	}
+	exports._Code = _Code;
+	exports.nil = new _Code("");
+	function _(strs, ...args) {
+	    const code = [strs[0]];
+	    let i = 0;
+	    while (i < args.length) {
+	        addCodeArg(code, args[i]);
+	        code.push(strs[++i]);
+	    }
+	    return new _Code(code);
+	}
+	exports._ = _;
+	const plus = new _Code("+");
+	function str(strs, ...args) {
+	    const expr = [safeStringify(strs[0])];
+	    let i = 0;
+	    while (i < args.length) {
+	        expr.push(plus);
+	        addCodeArg(expr, args[i]);
+	        expr.push(plus, safeStringify(strs[++i]));
+	    }
+	    optimize(expr);
+	    return new _Code(expr);
+	}
+	exports.str = str;
+	function addCodeArg(code, arg) {
+	    if (arg instanceof _Code)
+	        code.push(...arg._items);
+	    else if (arg instanceof Name)
+	        code.push(arg);
+	    else
+	        code.push(interpolate(arg));
+	}
+	exports.addCodeArg = addCodeArg;
+	function optimize(expr) {
+	    let i = 1;
+	    while (i < expr.length - 1) {
+	        if (expr[i] === plus) {
+	            const res = mergeExprItems(expr[i - 1], expr[i + 1]);
+	            if (res !== undefined) {
+	                expr.splice(i - 1, 3, res);
+	                continue;
+	            }
+	            expr[i++] = "+";
+	        }
+	        i++;
+	    }
+	}
+	function mergeExprItems(a, b) {
+	    if (b === '""')
+	        return a;
+	    if (a === '""')
+	        return b;
+	    if (typeof a == "string") {
+	        if (b instanceof Name || a[a.length - 1] !== '"')
+	            return;
+	        if (typeof b != "string")
+	            return `${a.slice(0, -1)}${b}"`;
+	        if (b[0] === '"')
+	            return a.slice(0, -1) + b.slice(1);
+	        return;
+	    }
+	    if (typeof b == "string" && b[0] === '"' && !(a instanceof Name))
+	        return `"${a}${b.slice(1)}`;
+	    return;
+	}
+	function strConcat(c1, c2) {
+	    return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str `${c1}${c2}`;
+	}
+	exports.strConcat = strConcat;
+	// TODO do not allow arrays here
+	function interpolate(x) {
+	    return typeof x == "number" || typeof x == "boolean" || x === null
+	        ? x
+	        : safeStringify(Array.isArray(x) ? x.join(",") : x);
+	}
+	function stringify(x) {
+	    return new _Code(safeStringify(x));
+	}
+	exports.stringify = stringify;
+	function safeStringify(x) {
+	    return JSON.stringify(x)
+	        .replace(/\u2028/g, "\\u2028")
+	        .replace(/\u2029/g, "\\u2029");
+	}
+	exports.safeStringify = safeStringify;
+	function getProperty(key) {
+	    return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _ `[${key}]`;
+	}
+	exports.getProperty = getProperty;
+	//Does best effort to format the name properly
+	function getEsmExportName(key) {
+	    if (typeof key == "string" && exports.IDENTIFIER.test(key)) {
+	        return new _Code(`${key}`);
+	    }
+	    throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
+	}
+	exports.getEsmExportName = getEsmExportName;
+	function regexpCode(rx) {
+	    return new _Code(rx.toString());
+	}
+	exports.regexpCode = regexpCode;
+	
+} (code$1));
 
 var scope = {};
 
@@ -21079,7 +21205,7 @@ function requireScope () {
 	(function (exports) {
 		Object.defineProperty(exports, "__esModule", { value: true });
 		exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0;
-		const code_1 = requireCode$1();
+		const code_1 = code$1;
 		class ValueError extends Error {
 		    constructor(name) {
 		        super(`CodeGen: "code" for ${name} not defined`);
@@ -21231,9 +21357,9 @@ function requireCodegen () {
 	(function (exports) {
 		Object.defineProperty(exports, "__esModule", { value: true });
 		exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0;
-		const code_1 = requireCode$1();
+		const code_1 = code$1;
 		const scope_1 = requireScope();
-		var code_2 = requireCode$1();
+		var code_2 = code$1;
 		Object.defineProperty(exports, "_", { enumerable: true, get: function () { return code_2._; } });
 		Object.defineProperty(exports, "str", { enumerable: true, get: function () { return code_2.str; } });
 		Object.defineProperty(exports, "strConcat", { enumerable: true, get: function () { return code_2.strConcat; } });
@@ -21935,7 +22061,7 @@ var util = {};
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = void 0;
 	const codegen_1 = requireCodegen();
-	const code_1 = requireCode$1();
+	const code_1 = code$1;
 	// TODO refactor to use Set
 	function toHash(arr) {
 	    const hash = {};
@@ -22368,37 +22494,29 @@ rules.getRules = getRules;
 
 var applicability = {};
 
-var hasRequiredApplicability;
-
-function requireApplicability () {
-	if (hasRequiredApplicability) return applicability;
-	hasRequiredApplicability = 1;
-	Object.defineProperty(applicability, "__esModule", { value: true });
-	applicability.shouldUseRule = applicability.shouldUseGroup = applicability.schemaHasRulesForType = void 0;
-	function schemaHasRulesForType({ schema, self }, type) {
-	    const group = self.RULES.types[type];
-	    return group && group !== true && shouldUseGroup(schema, group);
-	}
-	applicability.schemaHasRulesForType = schemaHasRulesForType;
-	function shouldUseGroup(schema, group) {
-	    return group.rules.some((rule) => shouldUseRule(schema, rule));
-	}
-	applicability.shouldUseGroup = shouldUseGroup;
-	function shouldUseRule(schema, rule) {
-	    var _a;
-	    return (schema[rule.keyword] !== undefined ||
-	        ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== undefined)));
-	}
-	applicability.shouldUseRule = shouldUseRule;
-	
-	return applicability;
+Object.defineProperty(applicability, "__esModule", { value: true });
+applicability.shouldUseRule = applicability.shouldUseGroup = applicability.schemaHasRulesForType = void 0;
+function schemaHasRulesForType({ schema, self }, type) {
+    const group = self.RULES.types[type];
+    return group && group !== true && shouldUseGroup(schema, group);
+}
+applicability.schemaHasRulesForType = schemaHasRulesForType;
+function shouldUseGroup(schema, group) {
+    return group.rules.some((rule) => shouldUseRule(schema, rule));
+}
+applicability.shouldUseGroup = shouldUseGroup;
+function shouldUseRule(schema, rule) {
+    var _a;
+    return (schema[rule.keyword] !== undefined ||
+        ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== undefined)));
 }
+applicability.shouldUseRule = shouldUseRule;
 
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0;
 	const rules_1 = rules;
-	const applicability_1 = requireApplicability();
+	const applicability_1 = applicability;
 	const errors_1 = requireErrors();
 	const codegen_1 = requireCodegen();
 	const util_1 = util;
@@ -22646,143 +22764,135 @@ var keyword = {};
 
 var code = {};
 
-var hasRequiredCode;
-
-function requireCode () {
-	if (hasRequiredCode) return code;
-	hasRequiredCode = 1;
-	Object.defineProperty(code, "__esModule", { value: true });
-	code.validateUnion = code.validateArray = code.usePattern = code.callValidateCode = code.schemaProperties = code.allSchemaProperties = code.noPropertyInData = code.propertyInData = code.isOwnProperty = code.hasPropFunc = code.reportMissingProp = code.checkMissingProp = code.checkReportMissingProp = void 0;
-	const codegen_1 = requireCodegen();
-	const util_1 = util;
-	const names_1 = requireNames();
-	const util_2 = util;
-	function checkReportMissingProp(cxt, prop) {
-	    const { gen, data, it } = cxt;
-	    gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
-	        cxt.setParams({ missingProperty: (0, codegen_1._) `${prop}` }, true);
-	        cxt.error();
-	    });
-	}
-	code.checkReportMissingProp = checkReportMissingProp;
-	function checkMissingProp({ gen, data, it: { opts } }, properties, missing) {
-	    return (0, codegen_1.or)(...properties.map((prop) => (0, codegen_1.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1._) `${missing} = ${prop}`)));
-	}
-	code.checkMissingProp = checkMissingProp;
-	function reportMissingProp(cxt, missing) {
-	    cxt.setParams({ missingProperty: missing }, true);
-	    cxt.error();
-	}
-	code.reportMissingProp = reportMissingProp;
-	function hasPropFunc(gen) {
-	    return gen.scopeValue("func", {
-	        // eslint-disable-next-line @typescript-eslint/unbound-method
-	        ref: Object.prototype.hasOwnProperty,
-	        code: (0, codegen_1._) `Object.prototype.hasOwnProperty`,
-	    });
-	}
-	code.hasPropFunc = hasPropFunc;
-	function isOwnProperty(gen, data, property) {
-	    return (0, codegen_1._) `${hasPropFunc(gen)}.call(${data}, ${property})`;
-	}
-	code.isOwnProperty = isOwnProperty;
-	function propertyInData(gen, data, property, ownProperties) {
-	    const cond = (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(property)} !== undefined`;
-	    return ownProperties ? (0, codegen_1._) `${cond} && ${isOwnProperty(gen, data, property)}` : cond;
-	}
-	code.propertyInData = propertyInData;
-	function noPropertyInData(gen, data, property, ownProperties) {
-	    const cond = (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(property)} === undefined`;
-	    return ownProperties ? (0, codegen_1.or)(cond, (0, codegen_1.not)(isOwnProperty(gen, data, property))) : cond;
-	}
-	code.noPropertyInData = noPropertyInData;
-	function allSchemaProperties(schemaMap) {
-	    return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : [];
-	}
-	code.allSchemaProperties = allSchemaProperties;
-	function schemaProperties(it, schemaMap) {
-	    return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]));
-	}
-	code.schemaProperties = schemaProperties;
-	function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {
-	    const dataAndSchema = passSchema ? (0, codegen_1._) `${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;
-	    const valCxt = [
-	        [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)],
-	        [names_1.default.parentData, it.parentData],
-	        [names_1.default.parentDataProperty, it.parentDataProperty],
-	        [names_1.default.rootData, names_1.default.rootData],
-	    ];
-	    if (it.opts.dynamicRef)
-	        valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]);
-	    const args = (0, codegen_1._) `${dataAndSchema}, ${gen.object(...valCxt)}`;
-	    return context !== codegen_1.nil ? (0, codegen_1._) `${func}.call(${context}, ${args})` : (0, codegen_1._) `${func}(${args})`;
-	}
-	code.callValidateCode = callValidateCode;
-	const newRegExp = (0, codegen_1._) `new RegExp`;
-	function usePattern({ gen, it: { opts } }, pattern) {
-	    const u = opts.unicodeRegExp ? "u" : "";
-	    const { regExp } = opts.code;
-	    const rx = regExp(pattern, u);
-	    return gen.scopeValue("pattern", {
-	        key: rx.toString(),
-	        ref: rx,
-	        code: (0, codegen_1._) `${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`,
-	    });
-	}
-	code.usePattern = usePattern;
-	function validateArray(cxt) {
-	    const { gen, data, keyword, it } = cxt;
-	    const valid = gen.name("valid");
-	    if (it.allErrors) {
-	        const validArr = gen.let("valid", true);
-	        validateItems(() => gen.assign(validArr, false));
-	        return validArr;
-	    }
-	    gen.var(valid, true);
-	    validateItems(() => gen.break());
-	    return valid;
-	    function validateItems(notValid) {
-	        const len = gen.const("len", (0, codegen_1._) `${data}.length`);
-	        gen.forRange("i", 0, len, (i) => {
-	            cxt.subschema({
-	                keyword,
-	                dataProp: i,
-	                dataPropType: util_1.Type.Num,
-	            }, valid);
-	            gen.if((0, codegen_1.not)(valid), notValid);
-	        });
-	    }
-	}
-	code.validateArray = validateArray;
-	function validateUnion(cxt) {
-	    const { gen, schema, keyword, it } = cxt;
-	    /* istanbul ignore if */
-	    if (!Array.isArray(schema))
-	        throw new Error("ajv implementation error");
-	    const alwaysValid = schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));
-	    if (alwaysValid && !it.opts.unevaluated)
-	        return;
-	    const valid = gen.let("valid", false);
-	    const schValid = gen.name("_valid");
-	    gen.block(() => schema.forEach((_sch, i) => {
-	        const schCxt = cxt.subschema({
-	            keyword,
-	            schemaProp: i,
-	            compositeRule: true,
-	        }, schValid);
-	        gen.assign(valid, (0, codegen_1._) `${valid} || ${schValid}`);
-	        const merged = cxt.mergeValidEvaluated(schCxt, schValid);
-	        // can short-circuit if `unevaluatedProperties/Items` not supported (opts.unevaluated !== true)
-	        // or if all properties and items were evaluated (it.props === true && it.items === true)
-	        if (!merged)
-	            gen.if((0, codegen_1.not)(valid));
-	    }));
-	    cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
-	}
-	code.validateUnion = validateUnion;
-	
-	return code;
+Object.defineProperty(code, "__esModule", { value: true });
+code.validateUnion = code.validateArray = code.usePattern = code.callValidateCode = code.schemaProperties = code.allSchemaProperties = code.noPropertyInData = code.propertyInData = code.isOwnProperty = code.hasPropFunc = code.reportMissingProp = code.checkMissingProp = code.checkReportMissingProp = void 0;
+const codegen_1$r = requireCodegen();
+const util_1$q = util;
+const names_1$6 = requireNames();
+const util_2$1 = util;
+function checkReportMissingProp(cxt, prop) {
+    const { gen, data, it } = cxt;
+    gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
+        cxt.setParams({ missingProperty: (0, codegen_1$r._) `${prop}` }, true);
+        cxt.error();
+    });
+}
+code.checkReportMissingProp = checkReportMissingProp;
+function checkMissingProp({ gen, data, it: { opts } }, properties, missing) {
+    return (0, codegen_1$r.or)(...properties.map((prop) => (0, codegen_1$r.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1$r._) `${missing} = ${prop}`)));
+}
+code.checkMissingProp = checkMissingProp;
+function reportMissingProp(cxt, missing) {
+    cxt.setParams({ missingProperty: missing }, true);
+    cxt.error();
+}
+code.reportMissingProp = reportMissingProp;
+function hasPropFunc(gen) {
+    return gen.scopeValue("func", {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        ref: Object.prototype.hasOwnProperty,
+        code: (0, codegen_1$r._) `Object.prototype.hasOwnProperty`,
+    });
+}
+code.hasPropFunc = hasPropFunc;
+function isOwnProperty(gen, data, property) {
+    return (0, codegen_1$r._) `${hasPropFunc(gen)}.call(${data}, ${property})`;
+}
+code.isOwnProperty = isOwnProperty;
+function propertyInData(gen, data, property, ownProperties) {
+    const cond = (0, codegen_1$r._) `${data}${(0, codegen_1$r.getProperty)(property)} !== undefined`;
+    return ownProperties ? (0, codegen_1$r._) `${cond} && ${isOwnProperty(gen, data, property)}` : cond;
+}
+code.propertyInData = propertyInData;
+function noPropertyInData(gen, data, property, ownProperties) {
+    const cond = (0, codegen_1$r._) `${data}${(0, codegen_1$r.getProperty)(property)} === undefined`;
+    return ownProperties ? (0, codegen_1$r.or)(cond, (0, codegen_1$r.not)(isOwnProperty(gen, data, property))) : cond;
+}
+code.noPropertyInData = noPropertyInData;
+function allSchemaProperties(schemaMap) {
+    return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : [];
+}
+code.allSchemaProperties = allSchemaProperties;
+function schemaProperties(it, schemaMap) {
+    return allSchemaProperties(schemaMap).filter((p) => !(0, util_1$q.alwaysValidSchema)(it, schemaMap[p]));
+}
+code.schemaProperties = schemaProperties;
+function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {
+    const dataAndSchema = passSchema ? (0, codegen_1$r._) `${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;
+    const valCxt = [
+        [names_1$6.default.instancePath, (0, codegen_1$r.strConcat)(names_1$6.default.instancePath, errorPath)],
+        [names_1$6.default.parentData, it.parentData],
+        [names_1$6.default.parentDataProperty, it.parentDataProperty],
+        [names_1$6.default.rootData, names_1$6.default.rootData],
+    ];
+    if (it.opts.dynamicRef)
+        valCxt.push([names_1$6.default.dynamicAnchors, names_1$6.default.dynamicAnchors]);
+    const args = (0, codegen_1$r._) `${dataAndSchema}, ${gen.object(...valCxt)}`;
+    return context !== codegen_1$r.nil ? (0, codegen_1$r._) `${func}.call(${context}, ${args})` : (0, codegen_1$r._) `${func}(${args})`;
+}
+code.callValidateCode = callValidateCode;
+const newRegExp = (0, codegen_1$r._) `new RegExp`;
+function usePattern({ gen, it: { opts } }, pattern) {
+    const u = opts.unicodeRegExp ? "u" : "";
+    const { regExp } = opts.code;
+    const rx = regExp(pattern, u);
+    return gen.scopeValue("pattern", {
+        key: rx.toString(),
+        ref: rx,
+        code: (0, codegen_1$r._) `${regExp.code === "new RegExp" ? newRegExp : (0, util_2$1.useFunc)(gen, regExp)}(${pattern}, ${u})`,
+    });
+}
+code.usePattern = usePattern;
+function validateArray(cxt) {
+    const { gen, data, keyword, it } = cxt;
+    const valid = gen.name("valid");
+    if (it.allErrors) {
+        const validArr = gen.let("valid", true);
+        validateItems(() => gen.assign(validArr, false));
+        return validArr;
+    }
+    gen.var(valid, true);
+    validateItems(() => gen.break());
+    return valid;
+    function validateItems(notValid) {
+        const len = gen.const("len", (0, codegen_1$r._) `${data}.length`);
+        gen.forRange("i", 0, len, (i) => {
+            cxt.subschema({
+                keyword,
+                dataProp: i,
+                dataPropType: util_1$q.Type.Num,
+            }, valid);
+            gen.if((0, codegen_1$r.not)(valid), notValid);
+        });
+    }
+}
+code.validateArray = validateArray;
+function validateUnion(cxt) {
+    const { gen, schema, keyword, it } = cxt;
+    /* istanbul ignore if */
+    if (!Array.isArray(schema))
+        throw new Error("ajv implementation error");
+    const alwaysValid = schema.some((sch) => (0, util_1$q.alwaysValidSchema)(it, sch));
+    if (alwaysValid && !it.opts.unevaluated)
+        return;
+    const valid = gen.let("valid", false);
+    const schValid = gen.name("_valid");
+    gen.block(() => schema.forEach((_sch, i) => {
+        const schCxt = cxt.subschema({
+            keyword,
+            schemaProp: i,
+            compositeRule: true,
+        }, schValid);
+        gen.assign(valid, (0, codegen_1$r._) `${valid} || ${schValid}`);
+        const merged = cxt.mergeValidEvaluated(schCxt, schValid);
+        // can short-circuit if `unevaluatedProperties/Items` not supported (opts.unevaluated !== true)
+        // or if all properties and items were evaluated (it.props === true && it.items === true)
+        if (!merged)
+            gen.if((0, codegen_1$r.not)(valid));
+    }));
+    cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
 }
+code.validateUnion = validateUnion;
 
 var hasRequiredKeyword;
 
@@ -22793,7 +22903,7 @@ function requireKeyword () {
 	keyword.validateKeywordUsage = keyword.validSchemaType = keyword.funcKeywordCode = keyword.macroKeywordCode = void 0;
 	const codegen_1 = requireCodegen();
 	const names_1 = requireNames();
-	const code_1 = requireCode();
+	const code_1 = code;
 	const errors_1 = requireErrors();
 	function macroKeywordCode(cxt, def) {
 	    const { gen, keyword, schema, parentSchema, it } = cxt;
@@ -23311,7 +23421,7 @@ function requireValidate () {
 	validate.getData = validate.KeywordCxt = validate.validateFunctionCode = void 0;
 	const boolSchema_1 = requireBoolSchema();
 	const dataType_1 = dataType;
-	const applicability_1 = requireApplicability();
+	const applicability_1 = applicability;
 	const dataType_2 = dataType;
 	const defaults_1 = requireDefaults();
 	const keyword_1 = requireKeyword();
@@ -26197,7 +26307,7 @@ var ref = {};
 Object.defineProperty(ref, "__esModule", { value: true });
 ref.callRef = ref.getValidate = void 0;
 const ref_error_1 = requireRef_error();
-const code_1$8 = requireCode();
+const code_1$8 = code;
 const codegen_1$p = requireCodegen();
 const names_1$4 = requireNames();
 const compile_1$2 = compile;
@@ -26443,7 +26553,7 @@ limitLength.default = def$x;
 var pattern = {};
 
 Object.defineProperty(pattern, "__esModule", { value: true });
-const code_1$7 = requireCode();
+const code_1$7 = code;
 const codegen_1$l = requireCodegen();
 const error$h = {
     message: ({ schemaCode }) => (0, codegen_1$l.str) `must match pattern "${schemaCode}"`,
@@ -26493,7 +26603,7 @@ limitProperties.default = def$v;
 var required = {};
 
 Object.defineProperty(required, "__esModule", { value: true });
-const code_1$6 = requireCode();
+const code_1$6 = code;
 const codegen_1$j = requireCodegen();
 const util_1$l = util;
 const error$f = {
@@ -26835,7 +26945,7 @@ Object.defineProperty(items, "__esModule", { value: true });
 items.validateTuple = void 0;
 const codegen_1$d = requireCodegen();
 const util_1$g = util;
-const code_1$5 = requireCode();
+const code_1$5 = code;
 const def$o = {
     keyword: "items",
     type: "array",
@@ -26898,7 +27008,7 @@ var items2020 = {};
 Object.defineProperty(items2020, "__esModule", { value: true });
 const codegen_1$c = requireCodegen();
 const util_1$f = util;
-const code_1$4 = requireCode();
+const code_1$4 = code;
 const additionalItems_1$1 = additionalItems;
 const error$9 = {
     message: ({ params: { len } }) => (0, codegen_1$c.str) `must NOT have more than ${len} items`,
@@ -27027,7 +27137,7 @@ var dependencies = {};
 	exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0;
 	const codegen_1 = requireCodegen();
 	const util_1 = util;
-	const code_1 = requireCode();
+	const code_1 = code;
 	exports.error = {
 	    message: ({ params: { property, depsCount, deps } }) => {
 	        const property_ies = depsCount === 1 ? "property" : "properties";
@@ -27151,7 +27261,7 @@ propertyNames.default = def$k;
 var additionalProperties = {};
 
 Object.defineProperty(additionalProperties, "__esModule", { value: true });
-const code_1$3 = requireCode();
+const code_1$3 = code;
 const codegen_1$9 = requireCodegen();
 const names_1$3 = requireNames();
 const util_1$c = util;
@@ -27259,7 +27369,7 @@ var properties$g = {};
 
 Object.defineProperty(properties$g, "__esModule", { value: true });
 const validate_1 = requireValidate();
-const code_1$2 = requireCode();
+const code_1$2 = code;
 const util_1$b = util;
 const additionalProperties_1$1 = additionalProperties;
 const def$i = {
@@ -27313,7 +27423,7 @@ properties$g.default = def$i;
 var patternProperties = {};
 
 Object.defineProperty(patternProperties, "__esModule", { value: true });
-const code_1$1 = requireCode();
+const code_1$1 = code;
 const codegen_1$8 = requireCodegen();
 const util_1$a = util;
 const util_2 = util;
@@ -27416,7 +27526,7 @@ not.default = def$g;
 var anyOf = {};
 
 Object.defineProperty(anyOf, "__esModule", { value: true });
-const code_1 = requireCode();
+const code_1 = code;
 const def$f = {
     keyword: "anyOf",
     schemaType: "array",
@@ -53468,7 +53578,7 @@ class OnChainZKPVerifier {
                     });
                 }
             }
-            const metadata = this.packMetadatas(metadataArr);
+            const metadata = metadataArr.length ? this.packMetadatas(metadataArr) : '0x';
             payload.push({
                 requestId: requestID,
                 zkProof: zkProofEncoded,
@@ -53858,7 +53968,7 @@ class OnChainRevocationStorage {
      *
      * Creates an instance of OnChainIssuer.
      * @public
-     * @param {string} - onhcain contract address
+     * @param {string} - onchain contract address
      * @param {string} - rpc url to connect to the blockchain
      */
     constructor(_config, contractAddress, _signer) {
@@ -54989,7 +55099,7 @@ class OnChainResolver {
         }
         return network;
     }
-    // TODO (illia-korotia): is dirty hack for mock in tests.
+    // TODO: is dirty hack for mock in tests.
     // need to pass to constructor list of state stores not list of network configs
     _getStateStorageForIssuer(issuerId) {
         const issuerChainId = getChainId(DID.blockchainFromId(issuerId), DID.networkIdFromId(issuerId));
@@ -56383,10 +56493,10 @@ function fnvHash(str) {
         hash *= BigInt(0x100000001b3);
         hash %= uint64_max;
     }
-    let shash = hash.toString(16);
-    const n = 16 - shash.length;
-    shash = '0'.repeat(n).concat(shash);
-    return shash;
+    let hashHex = hash.toString(16);
+    const n = 16 - hashHex.length;
+    hashHex = '0'.repeat(n).concat(hashHex);
+    return hashHex;
 }
 
 /**