@haneullabs/utils 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @mysten/utils
 
+## 0.4.2
+
+### Patch Changes
+
+- 3aa65e2: Speed up BCS parsing and serialization: faster ULEB, integer and byte reads and writes,
+  enum and option encoding, string decoding, and a single input conversion per write for transformed
+  types. Base58, base64 and hex helpers in `@mysten/utils` are faster and no longer depend on
+  `@scure/base`. Sui address and object digest encoding is faster.
+
+  Behaviour changes:
+
+  - `BcsReader.readBytes` and `readULEB` throw instead of reading past the end of a view into the
+    rest of its buffer.
+  - `bcs.option(T)` returns `null`/`undefined` when `T` reads as `null`/`undefined` (for example a
+    nested option's inner `None`), instead of `true`.
+  - `bcs.Address.serializedSize` and `bcs.ObjectDigest.serializedSize` throw on invalid input
+    instead of returning a size.
+
+## 0.4.1
+
+### Patch Changes
+
+- f2f7048: Upgrade workspace dependencies, remove the legacy dapp-kit package, and migrate the
+  remaining consumers to the current gRPC-based dapp-kit. Remove the legacy API reference while
+  retaining the migration guide and deprecation notice.
+
 ## 0.4.0
 
 ### Minor Changes

package/dist/b58.d.mts

@@ -1,6 +1,6 @@
 //#region src/b58.d.ts
-declare const toBase58: (buffer: Uint8Array) => string;
-declare const fromBase58: (str: string) => Uint8Array<ArrayBuffer>;
+declare function toBase58(buffer: Uint8Array): string;
+declare function fromBase58(str: string): Uint8Array<ArrayBuffer>;
 //#endregion
 export { fromBase58, toBase58 };
 //# sourceMappingURL=b58.d.mts.map

package/dist/b58.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"b58.d.mts","names":[],"sources":["../src/b58.ts"],"mappings":";cAKa,QAAA,GAAY,MAAkB,EAAV,UAAU;AAAA,cAC9B,UAAA,GAAc,GAAA,aAAsC,UAAU,CAAC,WAAA"}
+{"version":3,"file":"b58.d.mts","names":[],"sources":["../src/b58.ts"],"mappings":";iBAyBgB,SAAS,QAAQ;iBA4DjB,WAAW,cAAc,WAAW"}

package/dist/b58.mjs

@@ -1,7 +1,94 @@
-import { base58 } from "@scure/base";
 //#region src/b58.ts
-const toBase58 = (buffer) => base58.encode(buffer);
-const fromBase58 = (str) => base58.decode(str);
+const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const ALPHABET_CODES = Array.from(ALPHABET, (char) => char.charCodeAt(0));
+const DIGIT_VALUES = (/* @__PURE__ */ new Int8Array(128)).fill(-1);
+for (let i = 0; i < 58; i++) DIGIT_VALUES[ALPHABET.charCodeAt(i)] = i;
+const B58_5 = 58 ** 5;
+function isBytes(value) {
+	return value instanceof Uint8Array || ArrayBuffer.isView(value) && value.constructor.name === "Uint8Array" && value.BYTES_PER_ELEMENT === 1;
+}
+function toBase58(buffer) {
+	if (!isBytes(buffer)) throw new TypeError("toBase58 expects a Uint8Array");
+	const length = buffer.length;
+	let zeros = 0;
+	while (zeros < length && buffer[zeros] === 0) zeros++;
+	const limbs = [];
+	let i = zeros;
+	if ((length - zeros) % 2 === 1) limbs.push(buffer[i++]);
+	for (; i < length; i += 2) {
+		let carry = buffer[i] * 256 + buffer[i + 1];
+		for (let j = 0; j < limbs.length; j++) {
+			const x = limbs[j] * 65536 + carry;
+			carry = Math.floor(x / B58_5);
+			limbs[j] = x - carry * B58_5;
+		}
+		while (carry > 0) {
+			const next = Math.floor(carry / B58_5);
+			limbs.push(carry - next * B58_5);
+			carry = next;
+		}
+	}
+	const digits = [];
+	for (let k = 0; k < zeros; k++) digits.push(ALPHABET_CODES[0]);
+	for (let j = limbs.length - 1; j >= 0; j--) {
+		let limb = limbs[j];
+		const start = digits.length;
+		const width = j === limbs.length - 1 ? 0 : 5;
+		for (let k = 0; k < 5 && (limb > 0 || k < width); k++) {
+			const next = Math.floor(limb / 58);
+			digits.push(ALPHABET_CODES[limb - next * 58]);
+			limb = next;
+		}
+		for (let a = start, b = digits.length - 1; a < b; a++, b--) {
+			const tmp = digits[a];
+			digits[a] = digits[b];
+			digits[b] = tmp;
+		}
+	}
+	let result = "";
+	for (let start = 0; start < digits.length; start += 8192) result += String.fromCharCode.apply(null, digits.slice(start, start + 8192));
+	return result;
+}
+function fromBase58(str) {
+	if (typeof str !== "string") throw new TypeError("fromBase58 expects a string");
+	const length = str.length;
+	let zeros = 0;
+	while (zeros < length && str.charCodeAt(zeros) === 49) zeros++;
+	const limbs = [];
+	let i = zeros;
+	const head = (length - zeros) % 5;
+	while (i < length) {
+		const chunkLength = i === zeros && head !== 0 ? head : 5;
+		let carry = 0;
+		let multiplier = 1;
+		for (let k = 0; k < chunkLength; k++) {
+			const code = str.charCodeAt(i + k);
+			const digit = code < 128 ? DIGIT_VALUES[code] : -1;
+			if (digit < 0) throw new Error(`Invalid base58 character "${str[i + k]}"`);
+			carry = carry * 58 + digit;
+			multiplier *= 58;
+		}
+		i += chunkLength;
+		for (let j = 0; j < limbs.length; j++) {
+			const x = limbs[j] * multiplier + carry;
+			carry = Math.floor(x / 65536);
+			limbs[j] = x - carry * 65536;
+		}
+		while (carry > 0) {
+			limbs.push(carry % 65536);
+			carry = Math.floor(carry / 65536);
+		}
+	}
+	let byteLength = limbs.length * 2;
+	if (byteLength > 0 && limbs[limbs.length - 1] < 256) byteLength--;
+	const out = new Uint8Array(zeros + byteLength);
+	let pos = out.length - 1;
+	for (let j = 0; j < limbs.length; j++) {
+		out[pos--] = limbs[j] & 255;
+		if (pos >= zeros) out[pos--] = limbs[j] >> 8;
+	}
+	return out;
+}
 //#endregion
 export { fromBase58, toBase58 };
 

package/dist/b58.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"b58.mjs","names":[],"sources":["../src/b58.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { base58 } from '@scure/base';\n\nexport const toBase58 = (buffer: Uint8Array) => base58.encode(buffer);\nexport const fromBase58 = (str: string) => base58.decode(str) as Uint8Array<ArrayBuffer>;\n"],"mappings":";;AAKA,MAAa,YAAY,WAAuB,OAAO,OAAO,MAAM;AACpE,MAAa,cAAc,QAAgB,OAAO,OAAO,GAAG"}
+{"version":3,"file":"b58.mjs","names":[],"sources":["../src/b58.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nconst ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';\nconst ALPHABET_CODES = Array.from(ALPHABET, (char) => char.charCodeAt(0));\nconst DIGIT_VALUES = new Int8Array(128).fill(-1);\nfor (let i = 0; i < ALPHABET.length; i++) {\n\tDIGIT_VALUES[ALPHABET.charCodeAt(i)] = i;\n}\n\n// Base conversion works on limbs so each step stays well inside the 2^53 float-exact range:\n// encoding accumulates base-58^5 limbs from 16-bit input chunks (< 2^46),\n// decoding accumulates base-2^16 limbs from 5-character chunks (< 2^46).\nconst B58_5 = 58 ** 5;\n\n// Same check as @scure/base, which also accepts Uint8Arrays from other realms (iframes, vm)\nfunction isBytes(value: unknown): value is Uint8Array {\n\treturn (\n\t\tvalue instanceof Uint8Array ||\n\t\t(ArrayBuffer.isView(value) &&\n\t\t\tvalue.constructor.name === 'Uint8Array' &&\n\t\t\t(value as Uint8Array).BYTES_PER_ELEMENT === 1)\n\t);\n}\n\nexport function toBase58(buffer: Uint8Array): string {\n\tif (!isBytes(buffer)) {\n\t\tthrow new TypeError('toBase58 expects a Uint8Array');\n\t}\n\n\tconst length = buffer.length;\n\tlet zeros = 0;\n\twhile (zeros < length && buffer[zeros] === 0) {\n\t\tzeros++;\n\t}\n\n\tconst limbs: number[] = [];\n\tlet i = zeros;\n\tif ((length - zeros) % 2 === 1) {\n\t\tlimbs.push(buffer[i++]);\n\t}\n\tfor (; i < length; i += 2) {\n\t\tlet carry = buffer[i] * 256 + buffer[i + 1];\n\t\tfor (let j = 0; j < limbs.length; j++) {\n\t\t\tconst x = limbs[j] * 65536 + carry;\n\t\t\tcarry = Math.floor(x / B58_5);\n\t\t\tlimbs[j] = x - carry * B58_5;\n\t\t}\n\t\twhile (carry > 0) {\n\t\t\tconst next = Math.floor(carry / B58_5);\n\t\t\tlimbs.push(carry - next * B58_5);\n\t\t\tcarry = next;\n\t\t}\n\t}\n\n\t// Each limb holds 5 base58 digits; the most significant limb is written without padding\n\tconst digits: number[] = [];\n\tfor (let k = 0; k < zeros; k++) {\n\t\tdigits.push(ALPHABET_CODES[0]);\n\t}\n\tfor (let j = limbs.length - 1; j >= 0; j--) {\n\t\tlet limb = limbs[j];\n\t\tconst start = digits.length;\n\t\tconst width = j === limbs.length - 1 ? 0 : 5;\n\t\tfor (let k = 0; k < 5 && (limb > 0 || k < width); k++) {\n\t\t\tconst next = Math.floor(limb / 58);\n\t\t\tdigits.push(ALPHABET_CODES[limb - next * 58]);\n\t\t\tlimb = next;\n\t\t}\n\t\t// Digits were produced least-significant first\n\t\tfor (let a = start, b = digits.length - 1; a < b; a++, b--) {\n\t\t\tconst tmp = digits[a];\n\t\t\tdigits[a] = digits[b];\n\t\t\tdigits[b] = tmp;\n\t\t}\n\t}\n\n\t// Chunked so long inputs stay under engine limits on function argument counts\n\tlet result = '';\n\tfor (let start = 0; start < digits.length; start += 8192) {\n\t\tresult += String.fromCharCode.apply(null, digits.slice(start, start + 8192));\n\t}\n\treturn result;\n}\n\nexport function fromBase58(str: string): Uint8Array<ArrayBuffer> {\n\tif (typeof str !== 'string') {\n\t\tthrow new TypeError('fromBase58 expects a string');\n\t}\n\n\tconst length = str.length;\n\tlet zeros = 0;\n\twhile (zeros < length && str.charCodeAt(zeros) === 49 /* '1' */) {\n\t\tzeros++;\n\t}\n\n\tconst limbs: number[] = [];\n\tlet i = zeros;\n\tconst head = (length - zeros) % 5;\n\twhile (i < length) {\n\t\tconst chunkLength = i === zeros && head !== 0 ? head : 5;\n\t\tlet carry = 0;\n\t\tlet multiplier = 1;\n\t\tfor (let k = 0; k < chunkLength; k++) {\n\t\t\tconst code = str.charCodeAt(i + k);\n\t\t\tconst digit = code < 128 ? DIGIT_VALUES[code] : -1;\n\t\t\tif (digit < 0) {\n\t\t\t\tthrow new Error(`Invalid base58 character \"${str[i + k]}\"`);\n\t\t\t}\n\t\t\tcarry = carry * 58 + digit;\n\t\t\tmultiplier *= 58;\n\t\t}\n\t\ti += chunkLength;\n\n\t\tfor (let j = 0; j < limbs.length; j++) {\n\t\t\tconst x = limbs[j] * multiplier + carry;\n\t\t\tcarry = Math.floor(x / 65536);\n\t\t\tlimbs[j] = x - carry * 65536;\n\t\t}\n\t\twhile (carry > 0) {\n\t\t\tlimbs.push(carry % 65536);\n\t\t\tcarry = Math.floor(carry / 65536);\n\t\t}\n\t}\n\n\tlet byteLength = limbs.length * 2;\n\tif (byteLength > 0 && limbs[limbs.length - 1] < 256) {\n\t\tbyteLength--;\n\t}\n\n\tconst out = new Uint8Array(zeros + byteLength);\n\tlet pos = out.length - 1;\n\tfor (let j = 0; j < limbs.length; j++) {\n\t\tout[pos--] = limbs[j] & 0xff;\n\t\tif (pos >= zeros) {\n\t\t\tout[pos--] = limbs[j] >> 8;\n\t\t}\n\t}\n\n\treturn out;\n}\n"],"mappings":"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"}

package/dist/b64.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"b64.d.mts","names":[],"sources":["../src/b64.ts"],"mappings":";iBAGgB,UAAA,CAAW,YAAA,WAAuB,UAAU,CAAC,WAAA;AAAA,iBAK7C,QAAA,CAAS,KAAiB,EAAV,UAAU"}
+{"version":3,"file":"b64.d.mts","names":[],"sources":["../src/b64.ts"],"mappings":";iBAGgB,WAAW,uBAAuB,WAAW;iBAU7C,SAAS,OAAO"}

package/dist/b64.mjs

@@ -1,14 +1,17 @@
 //#region src/b64.ts
 function fromBase64(base64String) {
-	return Uint8Array.from(atob(base64String), (char) => char.charCodeAt(0));
+	const binary = atob(base64String);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
 }
 const CHUNK_SIZE = 8192;
 function toBase64(bytes) {
-	if (bytes.length < CHUNK_SIZE) return btoa(String.fromCharCode(...bytes));
+	if (bytes.length <= CHUNK_SIZE) return btoa(String.fromCharCode.apply(null, bytes));
 	let output = "";
-	for (var i = 0; i < bytes.length; i += CHUNK_SIZE) {
+	for (let i = 0; i < bytes.length; i += CHUNK_SIZE) {
 		const chunk = bytes.slice(i, i + CHUNK_SIZE);
-		output += String.fromCharCode(...chunk);
+		output += String.fromCharCode.apply(null, chunk);
 	}
 	return btoa(output);
 }

package/dist/b64.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"b64.mjs","names":[],"sources":["../src/b64.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport function fromBase64(base64String: string): Uint8Array<ArrayBuffer> {\n\treturn Uint8Array.from(atob(base64String), (char) => char.charCodeAt(0));\n}\n\nconst CHUNK_SIZE = 8192;\nexport function toBase64(bytes: Uint8Array): string {\n\t// Special-case the simple case for speed's sake.\n\tif (bytes.length < CHUNK_SIZE) {\n\t\treturn btoa(String.fromCharCode(...bytes));\n\t}\n\n\tlet output = '';\n\tfor (var i = 0; i < bytes.length; i += CHUNK_SIZE) {\n\t\tconst chunk = bytes.slice(i, i + CHUNK_SIZE);\n\t\toutput += String.fromCharCode(...chunk);\n\t}\n\n\treturn btoa(output);\n}\n"],"mappings":";AAGA,SAAgB,WAAW,cAA+C;CACzE,OAAO,WAAW,KAAK,KAAK,YAAY,IAAI,SAAS,KAAK,WAAW,CAAC,CAAC;AACxE;AAEA,MAAM,aAAa;AACnB,SAAgB,SAAS,OAA2B;CAEnD,IAAI,MAAM,SAAS,YAClB,OAAO,KAAK,OAAO,aAAa,GAAG,KAAK,CAAC;CAG1C,IAAI,SAAS;CACb,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,YAAY;EAClD,MAAM,QAAQ,MAAM,MAAM,GAAG,IAAI,UAAU;EAC3C,UAAU,OAAO,aAAa,GAAG,KAAK;CACvC;CAEA,OAAO,KAAK,MAAM;AACnB"}
+{"version":3,"file":"b64.mjs","names":[],"sources":["../src/b64.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport function fromBase64(base64String: string): Uint8Array<ArrayBuffer> {\n\tconst binary = atob(base64String);\n\tconst bytes = new Uint8Array(binary.length);\n\tfor (let i = 0; i < binary.length; i++) {\n\t\tbytes[i] = binary.charCodeAt(i);\n\t}\n\treturn bytes;\n}\n\nconst CHUNK_SIZE = 8192;\nexport function toBase64(bytes: Uint8Array): string {\n\tif (bytes.length <= CHUNK_SIZE) {\n\t\treturn btoa(String.fromCharCode.apply(null, bytes as unknown as number[]));\n\t}\n\n\tlet output = '';\n\tfor (let i = 0; i < bytes.length; i += CHUNK_SIZE) {\n\t\tconst chunk = bytes.slice(i, i + CHUNK_SIZE);\n\t\toutput += String.fromCharCode.apply(null, chunk as unknown as number[]);\n\t}\n\n\treturn btoa(output);\n}\n"],"mappings":";AAGA,SAAgB,WAAW,cAA+C;CACzE,MAAM,SAAS,KAAK,YAAY;CAChC,MAAM,QAAQ,IAAI,WAAW,OAAO,MAAM;CAC1C,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAClC,MAAM,KAAK,OAAO,WAAW,CAAC;CAE/B,OAAO;AACR;AAEA,MAAM,aAAa;AACnB,SAAgB,SAAS,OAA2B;CACnD,IAAI,MAAM,UAAU,YACnB,OAAO,KAAK,OAAO,aAAa,MAAM,MAAM,KAA4B,CAAC;CAG1E,IAAI,SAAS;CACb,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,YAAY;EAClD,MAAM,QAAQ,MAAM,MAAM,GAAG,IAAI,UAAU;EAC3C,UAAU,OAAO,aAAa,MAAM,MAAM,KAA4B;CACvE;CAEA,OAAO,KAAK,MAAM;AACnB"}

package/dist/chunk.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk.d.mts","names":[],"sources":["../src/chunk.ts"],"mappings":";iBAGgB,KAAA,IAAS,KAAA,WAAgB,CAAA,IAAK,IAAA,WAAe,CAAC"}
+{"version":3,"file":"chunk.d.mts","names":[],"sources":["../src/chunk.ts"],"mappings":";iBAGgB,MAAM,GAAG,gBAAgB,KAAK,eAAe"}

package/dist/dataloader.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"dataloader.d.mts","names":[],"sources":["../src/dataloader.ts"],"mappings":";;AAsBA;;;;;;;;;;;;;;;;;cAAa,UAAA,WAAqB,CAAA;cACrB,WAAA,EAAa,UAAA,CAAW,WAAA,CAAY,CAAA,EAAG,CAAA,GAAI,OAAA,GAAU,UAAA,CAAW,OAAA,CAAQ,CAAA,EAAG,CAAA,EAAG,CAAA;EAiB1F,YAAA,EAAc,UAAA,CAAW,WAAA,CAAY,CAAA,EAAG,CAAA;EACxC,aAAA;EACA,gBAAA,GAAmB,EAAA;EACnB,WAAA,GAAc,GAAA,EAAK,CAAA,KAAM,CAAA;EACzB,SAAA,EAAW,UAAA,CAAW,QAAA,CAAS,CAAA,EAAG,OAAA,CAAQ,CAAA;EAC1C,MAAA,EAAQ,KAAA,CAAM,CAAA,EAAG,CAAA;EAKH;;;EAAd,IAAA,CAAK,GAAA,EAAK,CAAA,GAAI,OAAA,CAAQ,CAAA;EA4D8B;;;;;;;;;;;;;;;;;;;;EAApD,QAAA,CAAS,IAAA,EAAM,aAAA,CAAc,CAAA,IAAK,OAAA,CAAQ,KAAA,CAAM,CAAA,GAAI,KAAA;EAvFa;;;;EAyGjE,KAAA,CAAM,GAAA,EAAK,CAAA;EAzG4C;;;;;EAuHvD,QAAA;EArGA;;;;;;EAmHA,KAAA,CAAM,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA,GAAI,OAAA,CAAQ,CAAA,IAAK,KAAA;EAhHtC;;;;;EA6IA,IAAA;AAAA;AAAA,KAuDI,KAAA;EACJ,aAAA;EACA,IAAA,EAAM,KAAA,CAAM,CAAA;EACZ,SAAA,EAAW,KAAA;IACV,OAAA,GAAU,KAAA,EAAO,CAAA;IACjB,MAAA,GAAS,KAAA,EAAO,KAAA;EAAA;EAEjB,SAAA,GAAY,KAAA;AAAA;AAAA,kBAuNY,UAAA;EAAA,KAEZ,QAAA;IACX,GAAA,CAAI,GAAA,EAAK,CAAA,GAAI,CAAA;IACb,GAAA,CAAI,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA;IACnB,MAAA,CAAO,GAAA,EAAK,CAAA;IACZ,KAAA;EAAA;EAAA,KAKW,WAAA,UAAqB,IAAA,EAAM,aAAA,CAAc,CAAA,MAAO,WAAA,CAAY,SAAA,CAAU,CAAA,GAAI,KAAA;EAAA,KAI1E,OAAA,WAAkB,CAAA;IA7VxB;;;;;IAmWL,KAAA;IAvUwB;;;;IA6UxB,YAAA;IAhTG;AAAA;AACJ;;;IAsTC,eAAA,IAAmB,QAAA;IA9Pd;;;;;IAqQL,KAAA;IAhQgB;;;;IAsQhB,UAAA,IAAc,GAAA,EAAK,CAAA,KAAM,CAAA;IA3QpB;;;;IAiRL,QAAA,GAAW,QAAA,CAAS,CAAA,EAAG,OAAA,CAAQ,CAAA;IA/Qd;;;;;IAsRjB,IAAA;EAAA;AAAA"}
+{"version":3,"file":"dataloader.d.mts","names":[],"sources":["../src/dataloader.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAsBa,WAAW,GAAG,GAAG,IAAI;EACjC,YAAY,aAAa,WAAW,YAAY,GAAG,IAAI,UAAU,WAAW,QAAQ,GAAG,GAAG;EAiB1F,cAAc,WAAW,YAAY,GAAG;EACxC;EACA,mBAAmB;EACnB,cAAc,KAAK,MAAM;EACzB,WAAW,WAAW,SAAS,GAAG,QAAQ;EAC1C,QAAQ,MAAM,GAAG;;;;EAKjB,KAAK,KAAK,IAAI,QAAQ;;;;;;;;;;;;;;;;;;;;;EA4DtB,SAAS,MAAM,cAAc,KAAK,QAAQ,MAAM,IAAI;;;;;EAkBpD,MAAM,KAAK;;;;;;EAcX;;;;;;;EAcA,MAAM,KAAK,GAAG,OAAO,IAAI,QAAQ,KAAK;;;;;;EA6BtC;;KAuDI,MAAM,GAAG;EACb;EACA,MAAM,MAAM;EACZ,WAAW;IACV,UAAU,OAAO;IACjB,SAAS,OAAO;;EAEjB,YAAY;;kBAuNY;OAEZ,SAAS,GAAG;IACvB,IAAI,KAAK,IAAI;IACb,IAAI,KAAK,GAAG,OAAO;IACnB,OAAO,KAAK;IACZ;;OAKW,YAAY,GAAG,MAAM,MAAM,cAAc,OAAO,YAAY,UAAU,IAAI;OAI1E,QAAQ,GAAG,GAAG,IAAI;;;;;;IAM7B;;;;;IAMA;;;;;;IAOA,mBAAmB;;;;;;IAOnB;;;;;IAMA,cAAc,KAAK,MAAM;;;;;IAMzB,WAAW,SAAS,GAAG,QAAQ;;;;;;IAO/B"}

package/dist/hex.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"hex.d.mts","names":[],"sources":["../src/hex.ts"],"mappings":";iBAGgB,OAAA,CAAQ,MAAA,WAAiB,UAAU,CAAC,WAAA;AAAA,iBAYpC,KAAA,CAAM,KAAiB,EAAV,UAAU"}
+{"version":3,"file":"hex.d.mts","names":[],"sources":["../src/hex.ts"],"mappings":";iBAGgB,QAAQ,iBAAiB,WAAW;iBA0BpC,MAAM,OAAO"}

package/dist/hex.mjs

@@ -2,12 +2,26 @@
 function fromHex(hexStr) {
 	const normalized = hexStr.startsWith("0x") ? hexStr.slice(2) : hexStr;
 	const padded = normalized.length % 2 === 0 ? normalized : `0${normalized}`;
-	const intArr = padded.match(/[0-9a-fA-F]{2}/g)?.map((byte) => parseInt(byte, 16)) ?? [];
-	if (intArr.length !== padded.length / 2) throw new Error(`Invalid hex string ${hexStr}`);
-	return Uint8Array.from(intArr);
+	const bytes = new Uint8Array(padded.length / 2);
+	for (let i = 0; i < bytes.length; i++) {
+		const high = hexDigit(padded.charCodeAt(i * 2));
+		const low = hexDigit(padded.charCodeAt(i * 2 + 1));
+		if (high < 0 || low < 0) throw new Error(`Invalid hex string ${hexStr}`);
+		bytes[i] = high * 16 + low;
+	}
+	return bytes;
 }
+function hexDigit(code) {
+	if (code >= 48 && code <= 57) return code - 48;
+	if (code >= 97 && code <= 102) return code - 87;
+	if (code >= 65 && code <= 70) return code - 55;
+	return -1;
+}
+const HEX_BYTES = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
 function toHex(bytes) {
-	return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
+	let hex = "";
+	for (let i = 0; i < bytes.length; i++) hex += HEX_BYTES[bytes[i]];
+	return hex;
 }
 //#endregion
 export { fromHex, toHex };

package/dist/hex.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"hex.mjs","names":[],"sources":["../src/hex.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport function fromHex(hexStr: string): Uint8Array<ArrayBuffer> {\n\tconst normalized = hexStr.startsWith('0x') ? hexStr.slice(2) : hexStr;\n\tconst padded = normalized.length % 2 === 0 ? normalized : `0${normalized}`;\n\tconst intArr = padded.match(/[0-9a-fA-F]{2}/g)?.map((byte) => parseInt(byte, 16)) ?? [];\n\n\tif (intArr.length !== padded.length / 2) {\n\t\tthrow new Error(`Invalid hex string ${hexStr}`);\n\t}\n\n\treturn Uint8Array.from(intArr);\n}\n\nexport function toHex(bytes: Uint8Array): string {\n\treturn bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');\n}\n"],"mappings":";AAGA,SAAgB,QAAQ,QAAyC;CAChE,MAAM,aAAa,OAAO,WAAW,IAAI,IAAI,OAAO,MAAM,CAAC,IAAI;CAC/D,MAAM,SAAS,WAAW,SAAS,MAAM,IAAI,aAAa,IAAI;CAC9D,MAAM,SAAS,OAAO,MAAM,iBAAiB,CAAC,EAAE,KAAK,SAAS,SAAS,MAAM,EAAE,CAAC,KAAK,CAAC;CAEtF,IAAI,OAAO,WAAW,OAAO,SAAS,GACrC,MAAM,IAAI,MAAM,sBAAsB,QAAQ;CAG/C,OAAO,WAAW,KAAK,MAAM;AAC9B;AAEA,SAAgB,MAAM,OAA2B;CAChD,OAAO,MAAM,QAAQ,KAAK,SAAS,MAAM,KAAK,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,GAAG,EAAE;AAChF"}
+{"version":3,"file":"hex.mjs","names":[],"sources":["../src/hex.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport function fromHex(hexStr: string): Uint8Array<ArrayBuffer> {\n\tconst normalized = hexStr.startsWith('0x') ? hexStr.slice(2) : hexStr;\n\tconst padded = normalized.length % 2 === 0 ? normalized : `0${normalized}`;\n\tconst bytes = new Uint8Array(padded.length / 2);\n\n\tfor (let i = 0; i < bytes.length; i++) {\n\t\tconst high = hexDigit(padded.charCodeAt(i * 2));\n\t\tconst low = hexDigit(padded.charCodeAt(i * 2 + 1));\n\t\tif (high < 0 || low < 0) {\n\t\t\tthrow new Error(`Invalid hex string ${hexStr}`);\n\t\t}\n\t\tbytes[i] = high * 16 + low;\n\t}\n\n\treturn bytes;\n}\n\nfunction hexDigit(code: number): number {\n\tif (code >= 48 && code <= 57) return code - 48;\n\tif (code >= 97 && code <= 102) return code - 87;\n\tif (code >= 65 && code <= 70) return code - 55;\n\treturn -1;\n}\n\nconst HEX_BYTES = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n\nexport function toHex(bytes: Uint8Array): string {\n\tlet hex = '';\n\tfor (let i = 0; i < bytes.length; i++) {\n\t\thex += HEX_BYTES[bytes[i]];\n\t}\n\treturn hex;\n}\n"],"mappings":";AAGA,SAAgB,QAAQ,QAAyC;CAChE,MAAM,aAAa,OAAO,WAAW,IAAI,IAAI,OAAO,MAAM,CAAC,IAAI;CAC/D,MAAM,SAAS,WAAW,SAAS,MAAM,IAAI,aAAa,IAAI;CAC9D,MAAM,QAAQ,IAAI,WAAW,OAAO,SAAS,CAAC;CAE9C,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACtC,MAAM,OAAO,SAAS,OAAO,WAAW,IAAI,CAAC,CAAC;EAC9C,MAAM,MAAM,SAAS,OAAO,WAAW,IAAI,IAAI,CAAC,CAAC;EACjD,IAAI,OAAO,KAAK,MAAM,GACrB,MAAM,IAAI,MAAM,sBAAsB,QAAQ;EAE/C,MAAM,KAAK,OAAO,KAAK;CACxB;CAEA,OAAO;AACR;AAEA,SAAS,SAAS,MAAsB;CACvC,IAAI,QAAQ,MAAM,QAAQ,IAAI,OAAO,OAAO;CAC5C,IAAI,QAAQ,MAAM,QAAQ,KAAK,OAAO,OAAO;CAC7C,IAAI,QAAQ,MAAM,QAAQ,IAAI,OAAO,OAAO;CAC5C,OAAO;AACR;AAEA,MAAM,YAAY,MAAM,KAAK,EAAE,QAAQ,IAAI,IAAI,GAAG,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC;AAEvF,SAAgB,MAAM,OAA2B;CAChD,IAAI,MAAM;CACV,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KACjC,OAAO,UAAU,MAAM;CAExB,OAAO;AACR"}

package/dist/index.d.mts

@@ -5,5 +5,5 @@ import { Simplify, UnionToIntersection } from "./types.mjs";
 import { chunk } from "./chunk.mjs";
 import { PromiseWithResolvers, promiseWithResolvers } from "./with-resolver.mjs";
 import { DataLoader } from "./dataloader.mjs";
-import { Emitter, EventHandlerMap, Handler, WildcardHandler, mitt } from "./mitt.mjs";
+import mitt, { Emitter, EventHandlerMap, Handler, WildcardHandler } from "./mitt.mjs";
 export { DataLoader, type Emitter, type EventHandlerMap, type Handler, type PromiseWithResolvers, type Simplify, type UnionToIntersection, type WildcardHandler, chunk, fromBase58, fromBase64, fromHex, mitt, promiseWithResolvers, toBase58, toBase64, toHex };

package/dist/mitt.d.mts

@@ -28,5 +28,5 @@ interface Emitter<Events extends Record<EventType, unknown>> {
  */
 declare function mitt<Events extends Record<EventType, unknown>>(all?: EventHandlerMap<Events>): Emitter<Events>;
 //#endregion
-export { Emitter, EventHandlerMap, Handler, WildcardHandler, mitt };
+export { Emitter, EventHandlerList, EventHandlerMap, EventType, Handler, WildCardEventHandlerList, WildcardHandler, mitt as default };
 //# sourceMappingURL=mitt.d.mts.map

package/dist/mitt.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"mitt.d.mts","names":[],"sources":["../src/mitt.ts"],"mappings":";;AAWA;;;;AAAqB;AAIrB;KAJY,SAAA;AAAA,KAIA,OAAA,iBAAwB,KAAA,EAAO,CAAC;AAAA,KAChC,eAAA,KAAoB,MAAA,sBAC/B,IAAA,QAAY,CAAA,EACZ,KAAA,EAAO,CAAA,OAAQ,CAAA;AAAA,KAIJ,gBAAA,gBAAgC,KAAA,CAAM,OAAA,CAAQ,CAAA;AAAA,KAC9C,wBAAA,KAA6B,MAAA,qBAA2B,KAAA,CAAM,eAAA,CAAgB,CAAA;AAAA,KAG9E,eAAA,gBAA+B,MAAA,CAAO,SAAA,cAAuB,GAAA,OAClE,MAAA,QACN,gBAAA,CAAiB,MAAA,OAAa,MAAA,KAAW,wBAAA,CAAyB,MAAA;AAAA,UAGlD,OAAA,gBAAuB,MAAA,CAAO,SAAA;EAC9C,GAAA,EAAK,eAAA,CAAgB,MAAA;EAErB,EAAA,mBAAqB,MAAA,EAAQ,IAAA,EAAM,GAAA,EAAK,OAAA,EAAS,OAAA,CAAQ,MAAA,CAAO,GAAA;EAChE,EAAA,CAAG,IAAA,OAAW,OAAA,EAAS,eAAA,CAAgB,MAAA;EAEvC,GAAA,mBAAsB,MAAA,EAAQ,IAAA,EAAM,GAAA,EAAK,OAAA,GAAU,OAAA,CAAQ,MAAA,CAAO,GAAA;EAClE,GAAA,CAAI,IAAA,OAAW,OAAA,EAAS,eAAA,CAAgB,MAAA;EAExC,IAAA,mBAAuB,MAAA,EAAQ,IAAA,EAAM,GAAA,EAAK,KAAA,EAAO,MAAA,CAAO,GAAA;EACxD,IAAA,mBAAuB,MAAA,EAAQ,IAAA,oBAAwB,MAAA,CAAO,GAAA,IAAO,GAAA;AAAA;;;;;;iBAQ9C,IAAA,gBAAoB,MAAA,CAAO,SAAA,YAClD,GAAA,GAAM,eAAA,CAAgB,MAAA,IACpB,OAAA,CAAQ,MAAA"}
+{"version":3,"file":"mitt.d.mts","names":[],"sources":["../src/mitt.ts"],"mappings":";;;;;;;;KAWY;KAIA,QAAQ,gBAAgB,OAAO;KAC/B,gBAAgB,IAAI,4BAC/B,YAAY,GACZ,OAAO,QAAQ;KAIJ,iBAAiB,eAAe,MAAM,QAAQ;KAC9C,yBAAyB,IAAI,2BAA2B,MAAM,gBAAgB;KAG9E,gBAAgB,eAAe,OAAO,uBAAuB,UAClE,cACN,iBAAiB,aAAa,WAAW,yBAAyB;UAGlD,QAAQ,eAAe,OAAO;EAC9C,KAAK,gBAAgB;EAErB,GAAG,kBAAkB,QAAQ,MAAM,KAAK,SAAS,QAAQ,OAAO;EAChE,GAAG,WAAW,SAAS,gBAAgB;EAEvC,IAAI,kBAAkB,QAAQ,MAAM,KAAK,UAAU,QAAQ,OAAO;EAClE,IAAI,WAAW,SAAS,gBAAgB;EAExC,KAAK,kBAAkB,QAAQ,MAAM,KAAK,OAAO,OAAO;EACxD,KAAK,kBAAkB,QAAQ,wBAAwB,OAAO,OAAO;;;;;;;iBAQ9C,KAAK,eAAe,OAAO,qBAClD,MAAM,gBAAgB,UACpB,QAAQ"}

package/dist/mitt.mjs

@@ -29,8 +29,10 @@ function mitt(all) {
 		*/
 		off(type, handler) {
 			const handlers = all.get(type);
-			if (handlers) if (handler) handlers.splice(handlers.indexOf(handler) >>> 0, 1);
-			else all.set(type, []);
+			if (handlers) {
+				if (handler) handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+				else all.set(type, []);
+			}
 		},
 		/**
 		* Invoke all handlers for the given type.

package/dist/mitt.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"mitt.mjs","names":[],"sources":["../src/mitt.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Mitt - Tiny (~200b) functional event emitter / pubsub.\n *\n * Vendored from: https://github.com/developit/mitt\n * License: MIT\n * Copyright (c) 2021 Jason Miller\n */\n\nexport type EventType = string | symbol;\n\n// An event handler can take an optional event argument\n// and should not return a value\nexport type Handler<T = unknown> = (event: T) => void;\nexport type WildcardHandler<T = Record<string, unknown>> = (\n\ttype: keyof T,\n\tevent: T[keyof T],\n) => void;\n\n// An array of all currently registered event handlers for a type\nexport type EventHandlerList<T = unknown> = Array<Handler<T>>;\nexport type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;\n\n// A map of event types and their corresponding event handlers.\nexport type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<\n\tkeyof Events | '*',\n\tEventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>\n>;\n\nexport interface Emitter<Events extends Record<EventType, unknown>> {\n\tall: EventHandlerMap<Events>;\n\n\ton<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;\n\ton(type: '*', handler: WildcardHandler<Events>): void;\n\n\toff<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;\n\toff(type: '*', handler: WildcardHandler<Events>): void;\n\n\temit<Key extends keyof Events>(type: Key, event: Events[Key]): void;\n\temit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;\n}\n\n/**\n * Mitt: Tiny (~200b) functional event emitter / pubsub.\n * @name mitt\n * @returns {Mitt}\n */\nexport default function mitt<Events extends Record<EventType, unknown>>(\n\tall?: EventHandlerMap<Events>,\n): Emitter<Events> {\n\ttype GenericEventHandler = Handler<Events[keyof Events]> | WildcardHandler<Events>;\n\tall = all || new Map();\n\n\treturn {\n\t\t/**\n\t\t * A Map of event names to registered handler functions.\n\t\t */\n\t\tall,\n\n\t\t/**\n\t\t * Register an event handler for the given type.\n\t\t * @param type Type of event to listen for, or `'*'` for all events\n\t\t * @param handler Function to call in response to given event\n\t\t */\n\t\ton<Key extends keyof Events>(type: Key, handler: GenericEventHandler) {\n\t\t\tconst handlers: Array<GenericEventHandler> | undefined = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\thandlers.push(handler);\n\t\t\t} else {\n\t\t\t\tall!.set(type, [handler] as EventHandlerList<Events[keyof Events]>);\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Remove an event handler for the given type.\n\t\t * If `handler` is omitted, all handlers of the given type are removed.\n\t\t * @param type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)\n\t\t * @param handler Handler function to remove\n\t\t */\n\t\toff<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {\n\t\t\tconst handlers: Array<GenericEventHandler> | undefined = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\tif (handler) {\n\t\t\t\t\thandlers.splice(handlers.indexOf(handler) >>> 0, 1);\n\t\t\t\t} else {\n\t\t\t\t\tall!.set(type, []);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Invoke all handlers for the given type.\n\t\t * If present, `'*'` handlers are invoked after type-matched handlers.\n\t\t *\n\t\t * Note: Manually firing '*' handlers is not supported.\n\t\t *\n\t\t * @param type The event type to invoke\n\t\t * @param evt Any value (object is recommended and powerful), passed to each handler\n\t\t */\n\t\temit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {\n\t\t\tlet handlers = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\t(handlers as EventHandlerList<Events[keyof Events]>).slice().map((handler) => {\n\t\t\t\t\thandler(evt!);\n\t\t\t\t});\n\t\t\t}\n\n\t\t\thandlers = all!.get('*');\n\t\t\tif (handlers) {\n\t\t\t\t(handlers as WildCardEventHandlerList<Events>).slice().map((handler) => {\n\t\t\t\t\thandler(type, evt!);\n\t\t\t\t});\n\t\t\t}\n\t\t},\n\t};\n}\n"],"mappings":";;;;;;AAiDA,SAAwB,KACvB,KACkB;CAElB,MAAM,uBAAO,IAAI,IAAI;CAErB,OAAO;;;;EAIN;;;;;;EAOA,GAA6B,MAAW,SAA8B;GACrE,MAAM,WAAmD,IAAK,IAAI,IAAI;GACtE,IAAI,UACH,SAAS,KAAK,OAAO;QAErB,IAAK,IAAI,MAAM,CAAC,OAAO,CAA2C;EAEpE;;;;;;;EAQA,IAA8B,MAAW,SAA+B;GACvE,MAAM,WAAmD,IAAK,IAAI,IAAI;GACtE,IAAI,UACH,IAAI,SACH,SAAS,OAAO,SAAS,QAAQ,OAAO,MAAM,GAAG,CAAC;QAElD,IAAK,IAAI,MAAM,CAAC,CAAC;EAGpB;;;;;;;;;;EAWA,KAA+B,MAAW,KAAmB;GAC5D,IAAI,WAAW,IAAK,IAAI,IAAI;GAC5B,IAAI,UACH,SAAqD,MAAM,CAAC,CAAC,KAAK,YAAY;IAC7E,QAAQ,GAAI;GACb,CAAC;GAGF,WAAW,IAAK,IAAI,GAAG;GACvB,IAAI,UACH,SAA+C,MAAM,CAAC,CAAC,KAAK,YAAY;IACvE,QAAQ,MAAM,GAAI;GACnB,CAAC;EAEH;CACD;AACD"}
+{"version":3,"file":"mitt.mjs","names":[],"sources":["../src/mitt.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Mitt - Tiny (~200b) functional event emitter / pubsub.\n *\n * Vendored from: https://github.com/developit/mitt\n * License: MIT\n * Copyright (c) 2021 Jason Miller\n */\n\nexport type EventType = string | symbol;\n\n// An event handler can take an optional event argument\n// and should not return a value\nexport type Handler<T = unknown> = (event: T) => void;\nexport type WildcardHandler<T = Record<string, unknown>> = (\n\ttype: keyof T,\n\tevent: T[keyof T],\n) => void;\n\n// An array of all currently registered event handlers for a type\nexport type EventHandlerList<T = unknown> = Array<Handler<T>>;\nexport type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;\n\n// A map of event types and their corresponding event handlers.\nexport type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<\n\tkeyof Events | '*',\n\tEventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>\n>;\n\nexport interface Emitter<Events extends Record<EventType, unknown>> {\n\tall: EventHandlerMap<Events>;\n\n\ton<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;\n\ton(type: '*', handler: WildcardHandler<Events>): void;\n\n\toff<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;\n\toff(type: '*', handler: WildcardHandler<Events>): void;\n\n\temit<Key extends keyof Events>(type: Key, event: Events[Key]): void;\n\temit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;\n}\n\n/**\n * Mitt: Tiny (~200b) functional event emitter / pubsub.\n * @name mitt\n * @returns {Mitt}\n */\nexport default function mitt<Events extends Record<EventType, unknown>>(\n\tall?: EventHandlerMap<Events>,\n): Emitter<Events> {\n\ttype GenericEventHandler = Handler<Events[keyof Events]> | WildcardHandler<Events>;\n\tall = all || new Map();\n\n\treturn {\n\t\t/**\n\t\t * A Map of event names to registered handler functions.\n\t\t */\n\t\tall,\n\n\t\t/**\n\t\t * Register an event handler for the given type.\n\t\t * @param type Type of event to listen for, or `'*'` for all events\n\t\t * @param handler Function to call in response to given event\n\t\t */\n\t\ton<Key extends keyof Events>(type: Key, handler: GenericEventHandler) {\n\t\t\tconst handlers: Array<GenericEventHandler> | undefined = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\thandlers.push(handler);\n\t\t\t} else {\n\t\t\t\tall!.set(type, [handler] as EventHandlerList<Events[keyof Events]>);\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Remove an event handler for the given type.\n\t\t * If `handler` is omitted, all handlers of the given type are removed.\n\t\t * @param type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)\n\t\t * @param handler Handler function to remove\n\t\t */\n\t\toff<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {\n\t\t\tconst handlers: Array<GenericEventHandler> | undefined = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\tif (handler) {\n\t\t\t\t\thandlers.splice(handlers.indexOf(handler) >>> 0, 1);\n\t\t\t\t} else {\n\t\t\t\t\tall!.set(type, []);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Invoke all handlers for the given type.\n\t\t * If present, `'*'` handlers are invoked after type-matched handlers.\n\t\t *\n\t\t * Note: Manually firing '*' handlers is not supported.\n\t\t *\n\t\t * @param type The event type to invoke\n\t\t * @param evt Any value (object is recommended and powerful), passed to each handler\n\t\t */\n\t\temit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {\n\t\t\tlet handlers = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\t(handlers as EventHandlerList<Events[keyof Events]>).slice().map((handler) => {\n\t\t\t\t\thandler(evt!);\n\t\t\t\t});\n\t\t\t}\n\n\t\t\thandlers = all!.get('*');\n\t\t\tif (handlers) {\n\t\t\t\t(handlers as WildCardEventHandlerList<Events>).slice().map((handler) => {\n\t\t\t\t\thandler(type, evt!);\n\t\t\t\t});\n\t\t\t}\n\t\t},\n\t};\n}\n"],"mappings":";;;;;;AAiDA,SAAwB,KACvB,KACkB;CAElB,MAAM,uBAAO,IAAI,IAAI;CAErB,OAAO;;;;EAIN;;;;;;EAOA,GAA6B,MAAW,SAA8B;GACrE,MAAM,WAAmD,IAAK,IAAI,IAAI;GACtE,IAAI,UACH,SAAS,KAAK,OAAO;QAErB,IAAK,IAAI,MAAM,CAAC,OAAO,CAA2C;EAEpE;;;;;;;EAQA,IAA8B,MAAW,SAA+B;GACvE,MAAM,WAAmD,IAAK,IAAI,IAAI;GACtE,IAAI,UAAU;IACb,IAAI,SACH,SAAS,OAAO,SAAS,QAAQ,OAAO,MAAM,GAAG,CAAC;SAElD,IAAK,IAAI,MAAM,CAAC,CAAC;GAEnB;EACD;;;;;;;;;;EAWA,KAA+B,MAAW,KAAmB;GAC5D,IAAI,WAAW,IAAK,IAAI,IAAI;GAC5B,IAAI,UACH,SAAqD,MAAM,CAAC,CAAC,KAAK,YAAY;IAC7E,QAAQ,GAAI;GACb,CAAC;GAGF,WAAW,IAAK,IAAI,GAAG;GACvB,IAAI,UACH,SAA+C,MAAM,CAAC,CAAC,KAAK,YAAY;IACvE,QAAQ,MAAM,GAAI;GACnB,CAAC;EAEH;CACD;AACD"}

package/dist/types.d.mts

@@ -1,5 +1,5 @@
 //#region src/types.d.ts
-type Simplify<T> = { [K in keyof T]: T[K] } & {};
+type Simplify<T> = { [K in keyof T]: T[K]; } & {};
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 //#endregion
 export { Simplify, UnionToIntersection };

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";KAGY,QAAA,oBACC,CAAA,GAAI,CAAA,CAAE,CAAA;AAAA,KAGP,mBAAA,OAA0B,CAAA,gBAAiB,CAAA,EAAG,CAAC,6BAC1D,CAAA,sBAEE,CAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";KAGY,SAAS,QACnB,WAAW,IAAI,EAAE;KAGP,oBAAoB,MAAM,iBAAiB,GAAG,8BACzD,SAAS,cAEP"}

package/dist/with-resolver.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"with-resolver.d.mts","names":[],"sources":["../src/with-resolver.ts"],"mappings":";UAGiB,oBAAA;EAChB,OAAA,EAAS,OAAA,CAAQ,CAAA;EACjB,OAAA,GAAU,KAAA,EAAO,CAAA;EACjB,MAAA,GAAS,KAAA;AAAA;AAAA,iBAGM,oBAAA,OAA2B,oBAAoB,CAAC,CAAA"}
+{"version":3,"file":"with-resolver.d.mts","names":[],"sources":["../src/with-resolver.ts"],"mappings":";UAGiB,qBAAqB;EACrC,SAAS,QAAQ;EACjB,UAAU,OAAO;EACjB,SAAS;;iBAGM,qBAAqB,MAAM,qBAAqB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haneullabs/utils",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Shared utilities for @haneullabs/* packages",
   "license": "Apache-2.0",
   "author": "Haneul Labs <build@haneul-labs.com>",
@@ -32,15 +32,13 @@
   },
   "homepage": "https://github.com/GeunhwaJeong/haneul-ts-sdks/tree/main/packages/utils#readme",
   "devDependencies": {
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.8"
-  },
-  "dependencies": {
-    "@scure/base": "^2.2.0"
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11"
   },
   "scripts": {
     "clean": "rm -rf tsconfig.tsbuildinfo ./dist",
     "build": "rm -rf dist && tsc --noEmit && tsdown",
+    "test": "vitest run",
     "prettier:check": "prettier -c --ignore-unknown .",
     "prettier:fix": "prettier -w --ignore-unknown .",
     "oxlint:check": "oxlint  .",

package/src/b58.ts

@@ -1,7 +1,141 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { base58 } from '@scure/base';
+const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const ALPHABET_CODES = Array.from(ALPHABET, (char) => char.charCodeAt(0));
+const DIGIT_VALUES = new Int8Array(128).fill(-1);
+for (let i = 0; i < ALPHABET.length; i++) {
+	DIGIT_VALUES[ALPHABET.charCodeAt(i)] = i;
+}
 
-export const toBase58 = (buffer: Uint8Array) => base58.encode(buffer);
-export const fromBase58 = (str: string) => base58.decode(str) as Uint8Array<ArrayBuffer>;
+// Base conversion works on limbs so each step stays well inside the 2^53 float-exact range:
+// encoding accumulates base-58^5 limbs from 16-bit input chunks (< 2^46),
+// decoding accumulates base-2^16 limbs from 5-character chunks (< 2^46).
+const B58_5 = 58 ** 5;
+
+// Same check as @scure/base, which also accepts Uint8Arrays from other realms (iframes, vm)
+function isBytes(value: unknown): value is Uint8Array {
+	return (
+		value instanceof Uint8Array ||
+		(ArrayBuffer.isView(value) &&
+			value.constructor.name === 'Uint8Array' &&
+			(value as Uint8Array).BYTES_PER_ELEMENT === 1)
+	);
+}
+
+export function toBase58(buffer: Uint8Array): string {
+	if (!isBytes(buffer)) {
+		throw new TypeError('toBase58 expects a Uint8Array');
+	}
+
+	const length = buffer.length;
+	let zeros = 0;
+	while (zeros < length && buffer[zeros] === 0) {
+		zeros++;
+	}
+
+	const limbs: number[] = [];
+	let i = zeros;
+	if ((length - zeros) % 2 === 1) {
+		limbs.push(buffer[i++]);
+	}
+	for (; i < length; i += 2) {
+		let carry = buffer[i] * 256 + buffer[i + 1];
+		for (let j = 0; j < limbs.length; j++) {
+			const x = limbs[j] * 65536 + carry;
+			carry = Math.floor(x / B58_5);
+			limbs[j] = x - carry * B58_5;
+		}
+		while (carry > 0) {
+			const next = Math.floor(carry / B58_5);
+			limbs.push(carry - next * B58_5);
+			carry = next;
+		}
+	}
+
+	// Each limb holds 5 base58 digits; the most significant limb is written without padding
+	const digits: number[] = [];
+	for (let k = 0; k < zeros; k++) {
+		digits.push(ALPHABET_CODES[0]);
+	}
+	for (let j = limbs.length - 1; j >= 0; j--) {
+		let limb = limbs[j];
+		const start = digits.length;
+		const width = j === limbs.length - 1 ? 0 : 5;
+		for (let k = 0; k < 5 && (limb > 0 || k < width); k++) {
+			const next = Math.floor(limb / 58);
+			digits.push(ALPHABET_CODES[limb - next * 58]);
+			limb = next;
+		}
+		// Digits were produced least-significant first
+		for (let a = start, b = digits.length - 1; a < b; a++, b--) {
+			const tmp = digits[a];
+			digits[a] = digits[b];
+			digits[b] = tmp;
+		}
+	}
+
+	// Chunked so long inputs stay under engine limits on function argument counts
+	let result = '';
+	for (let start = 0; start < digits.length; start += 8192) {
+		result += String.fromCharCode.apply(null, digits.slice(start, start + 8192));
+	}
+	return result;
+}
+
+export function fromBase58(str: string): Uint8Array<ArrayBuffer> {
+	if (typeof str !== 'string') {
+		throw new TypeError('fromBase58 expects a string');
+	}
+
+	const length = str.length;
+	let zeros = 0;
+	while (zeros < length && str.charCodeAt(zeros) === 49 /* '1' */) {
+		zeros++;
+	}
+
+	const limbs: number[] = [];
+	let i = zeros;
+	const head = (length - zeros) % 5;
+	while (i < length) {
+		const chunkLength = i === zeros && head !== 0 ? head : 5;
+		let carry = 0;
+		let multiplier = 1;
+		for (let k = 0; k < chunkLength; k++) {
+			const code = str.charCodeAt(i + k);
+			const digit = code < 128 ? DIGIT_VALUES[code] : -1;
+			if (digit < 0) {
+				throw new Error(`Invalid base58 character "${str[i + k]}"`);
+			}
+			carry = carry * 58 + digit;
+			multiplier *= 58;
+		}
+		i += chunkLength;
+
+		for (let j = 0; j < limbs.length; j++) {
+			const x = limbs[j] * multiplier + carry;
+			carry = Math.floor(x / 65536);
+			limbs[j] = x - carry * 65536;
+		}
+		while (carry > 0) {
+			limbs.push(carry % 65536);
+			carry = Math.floor(carry / 65536);
+		}
+	}
+
+	let byteLength = limbs.length * 2;
+	if (byteLength > 0 && limbs[limbs.length - 1] < 256) {
+		byteLength--;
+	}
+
+	const out = new Uint8Array(zeros + byteLength);
+	let pos = out.length - 1;
+	for (let j = 0; j < limbs.length; j++) {
+		out[pos--] = limbs[j] & 0xff;
+		if (pos >= zeros) {
+			out[pos--] = limbs[j] >> 8;
+		}
+	}
+
+	return out;
+}

package/src/b64.ts

@@ -2,20 +2,24 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export function fromBase64(base64String: string): Uint8Array<ArrayBuffer> {
-	return Uint8Array.from(atob(base64String), (char) => char.charCodeAt(0));
+	const binary = atob(base64String);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) {
+		bytes[i] = binary.charCodeAt(i);
+	}
+	return bytes;
 }
 
 const CHUNK_SIZE = 8192;
 export function toBase64(bytes: Uint8Array): string {
-	// Special-case the simple case for speed's sake.
-	if (bytes.length < CHUNK_SIZE) {
-		return btoa(String.fromCharCode(...bytes));
+	if (bytes.length <= CHUNK_SIZE) {
+		return btoa(String.fromCharCode.apply(null, bytes as unknown as number[]));
 	}
 
 	let output = '';
-	for (var i = 0; i < bytes.length; i += CHUNK_SIZE) {
+	for (let i = 0; i < bytes.length; i += CHUNK_SIZE) {
 		const chunk = bytes.slice(i, i + CHUNK_SIZE);
-		output += String.fromCharCode(...chunk);
+		output += String.fromCharCode.apply(null, chunk as unknown as number[]);
 	}
 
 	return btoa(output);

package/src/hex.ts

@@ -4,15 +4,33 @@
 export function fromHex(hexStr: string): Uint8Array<ArrayBuffer> {
 	const normalized = hexStr.startsWith('0x') ? hexStr.slice(2) : hexStr;
 	const padded = normalized.length % 2 === 0 ? normalized : `0${normalized}`;
-	const intArr = padded.match(/[0-9a-fA-F]{2}/g)?.map((byte) => parseInt(byte, 16)) ?? [];
+	const bytes = new Uint8Array(padded.length / 2);
 
-	if (intArr.length !== padded.length / 2) {
-		throw new Error(`Invalid hex string ${hexStr}`);
+	for (let i = 0; i < bytes.length; i++) {
+		const high = hexDigit(padded.charCodeAt(i * 2));
+		const low = hexDigit(padded.charCodeAt(i * 2 + 1));
+		if (high < 0 || low < 0) {
+			throw new Error(`Invalid hex string ${hexStr}`);
+		}
+		bytes[i] = high * 16 + low;
 	}
 
-	return Uint8Array.from(intArr);
+	return bytes;
 }
 
+function hexDigit(code: number): number {
+	if (code >= 48 && code <= 57) return code - 48;
+	if (code >= 97 && code <= 102) return code - 87;
+	if (code >= 65 && code <= 70) return code - 55;
+	return -1;
+}
+
+const HEX_BYTES = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+
 export function toHex(bytes: Uint8Array): string {
-	return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');
+	let hex = '';
+	for (let i = 0; i < bytes.length; i++) {
+		hex += HEX_BYTES[bytes[i]];
+	}
+	return hex;
 }