@credo-ts/core 0.6.0-pr-2392-20251010173905 → 0.6.0-pr-2457-20251016083534

package/build/utils/MultiHashEncoder.mjs

@@ -1,15 +1,16 @@
 
 
+import { TypedArrayEncoder } from "./TypedArrayEncoder.mjs";
 import { Hasher } from "../crypto/hashes/Hasher.mjs";
 import "../crypto/hashes/index.mjs";
-import { Buffer } from "./buffer.mjs";
 import { VarintEncoder } from "./VarintEncoder.mjs";
 
 //#region src/utils/MultiHashEncoder.ts
 const multiHashNameMap = {
 	"sha-1": 17,
 	"sha-256": 18,
-	"sha-512": 19
+	"sha-512": 19,
+	"sha-384": 32
 };
 const multiHashCodeMap = Object.entries(multiHashNameMap).reduce((map, [hashName, hashCode]) => ({
 	...map,
@@ -30,7 +31,7 @@ var MultiHashEncoder = class MultiHashEncoder {
 		const hashCode = multiHashNameMap[hashName];
 		const hashPrefix = VarintEncoder.encode(hashCode);
 		const hashLengthPrefix = VarintEncoder.encode(hash.length);
-		return Buffer.concat([
+		return TypedArrayEncoder.concat([
 			hashPrefix,
 			hashLengthPrefix,
 			hash
@@ -51,7 +52,7 @@ var MultiHashEncoder = class MultiHashEncoder {
 		const withoutLengthPrefix = withoutHashPrefix.slice(lengthPrefixByteLength);
 		if (!multiHashCodeMap[hashPrefix]) throw new Error(`Unsupported hash code 0x${hashPrefix.toString(16)}`);
 		return {
-			data: Buffer.from(withoutLengthPrefix),
+			data: new Uint8Array(withoutLengthPrefix),
 			hashName: multiHashCodeMap[hashPrefix]
 		};
 	}

package/build/utils/MultiHashEncoder.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"MultiHashEncoder.mjs","names":["multiHashNameMap: MultiHashNameMap","multiHashCodeMap: MultiHashCodeMap"],"sources":["../../src/utils/MultiHashEncoder.ts"],"sourcesContent":["import type { HashName } from '../crypto/hashes'\n\nimport { Hasher } from '../crypto/hashes'\n\nimport { VarintEncoder } from './VarintEncoder'\nimport { Buffer } from './buffer'\n\ntype MultiHashNameMap = {\n  [key in HashName]: number\n}\n\ntype MultiHashCodeMap = {\n  [key: number]: HashName\n}\n\nconst multiHashNameMap: MultiHashNameMap = {\n  'sha-1': 0x11,\n  'sha-256': 0x12,\n  'sha-512': 0x13,\n}\n\nconst multiHashCodeMap: MultiHashCodeMap = Object.entries(multiHashNameMap).reduce(\n  // biome-ignore lint/performance/noAccumulatingSpread: <explanation>\n  (map, [hashName, hashCode]) => ({ ...map, [hashCode]: hashName }),\n  {}\n)\n\n// biome-ignore lint/complexity/noStaticOnlyClass: <explanation>\nexport class MultiHashEncoder {\n  /**\n   *\n   * Encodes a buffer into a hash\n   *\n   * @param buffer the buffer that has to be encoded\n   * @param hashName the hashing algorithm, 'sha-256'\n   *\n   * @returns a multihash\n   */\n  public static encode(data: Uint8Array, hashName: HashName): Buffer {\n    const hash = Hasher.hash(data, hashName)\n    const hashCode = multiHashNameMap[hashName]\n\n    const hashPrefix = VarintEncoder.encode(hashCode)\n    const hashLengthPrefix = VarintEncoder.encode(hash.length)\n\n    return Buffer.concat([hashPrefix, hashLengthPrefix, hash])\n  }\n\n  /**\n   *\n   * Decodes the multihash\n   *\n   * @param data the multihash that has to be decoded\n   *\n   * @returns object with the data and the hashing algorithm\n   */\n  public static decode(data: Uint8Array): { data: Buffer; hashName: string } {\n    const [hashPrefix, hashPrefixByteLength] = VarintEncoder.decode(data)\n    const withoutHashPrefix = data.slice(hashPrefixByteLength)\n\n    const [, lengthPrefixByteLength] = VarintEncoder.decode(withoutHashPrefix)\n    const withoutLengthPrefix = withoutHashPrefix.slice(lengthPrefixByteLength)\n\n    const hashName = multiHashCodeMap[hashPrefix]\n\n    if (!hashName) {\n      throw new Error(`Unsupported hash code 0x${hashPrefix.toString(16)}`)\n    }\n\n    return {\n      data: Buffer.from(withoutLengthPrefix),\n      hashName: multiHashCodeMap[hashPrefix],\n    }\n  }\n\n  /**\n   *\n   * Validates if it is a valid mulithash\n   *\n   * @param data the multihash that needs to be validated\n   *\n   * @returns a boolean whether the multihash is valid\n   */\n  public static isValid(data: Uint8Array): boolean {\n    try {\n      MultiHashEncoder.decode(data)\n      return true\n    } catch (_e) {\n      return false\n    }\n  }\n}\n"],"mappings":";;;;;;;;AAeA,MAAMA,mBAAqC;CACzC,SAAS;CACT,WAAW;CACX,WAAW;CACZ;AAED,MAAMC,mBAAqC,OAAO,QAAQ,iBAAiB,CAAC,QAEzE,KAAK,CAAC,UAAU,eAAe;CAAE,GAAG;EAAM,WAAW;CAAU,GAChE,EAAE,CACH;AAGD,IAAa,mBAAb,MAAa,iBAAiB;;;;;;;;;;CAU5B,OAAc,OAAO,MAAkB,UAA4B;EACjE,MAAM,OAAO,OAAO,KAAK,MAAM,SAAS;EACxC,MAAM,WAAW,iBAAiB;EAElC,MAAM,aAAa,cAAc,OAAO,SAAS;EACjD,MAAM,mBAAmB,cAAc,OAAO,KAAK,OAAO;AAE1D,SAAO,OAAO,OAAO;GAAC;GAAY;GAAkB;GAAK,CAAC;;;;;;;;;;CAW5D,OAAc,OAAO,MAAsD;EACzE,MAAM,CAAC,YAAY,wBAAwB,cAAc,OAAO,KAAK;EACrE,MAAM,oBAAoB,KAAK,MAAM,qBAAqB;EAE1D,MAAM,GAAG,0BAA0B,cAAc,OAAO,kBAAkB;EAC1E,MAAM,sBAAsB,kBAAkB,MAAM,uBAAuB;AAI3E,MAAI,CAFa,iBAAiB,YAGhC,OAAM,IAAI,MAAM,2BAA2B,WAAW,SAAS,GAAG,GAAG;AAGvE,SAAO;GACL,MAAM,OAAO,KAAK,oBAAoB;GACtC,UAAU,iBAAiB;GAC5B;;;;;;;;;;CAWH,OAAc,QAAQ,MAA2B;AAC/C,MAAI;AACF,oBAAiB,OAAO,KAAK;AAC7B,UAAO;WACA,IAAI;AACX,UAAO"}
+{"version":3,"file":"MultiHashEncoder.mjs","names":["multiHashNameMap: MultiHashNameMap","multiHashCodeMap: MultiHashCodeMap"],"sources":["../../src/utils/MultiHashEncoder.ts"],"sourcesContent":["import type { HashName } from '../crypto/hashes'\n\nimport { Hasher } from '../crypto/hashes'\nimport type { AnyUint8Array, Uint8ArrayBuffer } from '../types'\nimport { TypedArrayEncoder } from './TypedArrayEncoder'\nimport { VarintEncoder } from './VarintEncoder'\n\ntype MultiHashNameMap = {\n  [key in HashName]: number\n}\n\ntype MultiHashCodeMap = {\n  [key: number]: HashName\n}\n\nconst multiHashNameMap: MultiHashNameMap = {\n  'sha-1': 0x11,\n  'sha-256': 0x12,\n  'sha-512': 0x13,\n  'sha-384': 0x20,\n}\n\nconst multiHashCodeMap: MultiHashCodeMap = Object.entries(multiHashNameMap).reduce(\n  // biome-ignore lint/performance/noAccumulatingSpread: no explanation\n  (map, [hashName, hashCode]) => ({ ...map, [hashCode]: hashName }),\n  {}\n)\n\n// biome-ignore lint/complexity/noStaticOnlyClass: no explanation\nexport class MultiHashEncoder {\n  /**\n   *\n   * Encodes a buffer into a hash\n   *\n   * @param buffer the buffer that has to be encoded\n   * @param hashName the hashing algorithm, 'sha-256'\n   *\n   * @returns a multihash\n   */\n  public static encode(data: AnyUint8Array, hashName: HashName): Uint8ArrayBuffer {\n    const hash = Hasher.hash(data, hashName)\n    const hashCode = multiHashNameMap[hashName]\n\n    const hashPrefix = VarintEncoder.encode(hashCode)\n    const hashLengthPrefix = VarintEncoder.encode(hash.length)\n\n    return TypedArrayEncoder.concat([hashPrefix, hashLengthPrefix, hash])\n  }\n\n  /**\n   *\n   * Decodes the multihash\n   *\n   * @param data the multihash that has to be decoded\n   *\n   * @returns object with the data and the hashing algorithm\n   */\n  public static decode(data: AnyUint8Array): { data: Uint8ArrayBuffer; hashName: string } {\n    const [hashPrefix, hashPrefixByteLength] = VarintEncoder.decode(data)\n    const withoutHashPrefix = data.slice(hashPrefixByteLength)\n\n    const [, lengthPrefixByteLength] = VarintEncoder.decode(withoutHashPrefix)\n    const withoutLengthPrefix = withoutHashPrefix.slice(lengthPrefixByteLength)\n\n    const hashName = multiHashCodeMap[hashPrefix]\n\n    if (!hashName) {\n      throw new Error(`Unsupported hash code 0x${hashPrefix.toString(16)}`)\n    }\n\n    return {\n      data: new Uint8Array(withoutLengthPrefix),\n      hashName: multiHashCodeMap[hashPrefix],\n    }\n  }\n\n  /**\n   *\n   * Validates if it is a valid mulithash\n   *\n   * @param data the multihash that needs to be validated\n   *\n   * @returns a boolean whether the multihash is valid\n   */\n  public static isValid(data: AnyUint8Array): boolean {\n    try {\n      MultiHashEncoder.decode(data)\n      return true\n    } catch (_e) {\n      return false\n    }\n  }\n}\n"],"mappings":";;;;;;;;AAeA,MAAMA,mBAAqC;CACzC,SAAS;CACT,WAAW;CACX,WAAW;CACX,WAAW;CACZ;AAED,MAAMC,mBAAqC,OAAO,QAAQ,iBAAiB,CAAC,QAEzE,KAAK,CAAC,UAAU,eAAe;CAAE,GAAG;EAAM,WAAW;CAAU,GAChE,EAAE,CACH;AAGD,IAAa,mBAAb,MAAa,iBAAiB;;;;;;;;;;CAU5B,OAAc,OAAO,MAAqB,UAAsC;EAC9E,MAAM,OAAO,OAAO,KAAK,MAAM,SAAS;EACxC,MAAM,WAAW,iBAAiB;EAElC,MAAM,aAAa,cAAc,OAAO,SAAS;EACjD,MAAM,mBAAmB,cAAc,OAAO,KAAK,OAAO;AAE1D,SAAO,kBAAkB,OAAO;GAAC;GAAY;GAAkB;GAAK,CAAC;;;;;;;;;;CAWvE,OAAc,OAAO,MAAmE;EACtF,MAAM,CAAC,YAAY,wBAAwB,cAAc,OAAO,KAAK;EACrE,MAAM,oBAAoB,KAAK,MAAM,qBAAqB;EAE1D,MAAM,GAAG,0BAA0B,cAAc,OAAO,kBAAkB;EAC1E,MAAM,sBAAsB,kBAAkB,MAAM,uBAAuB;AAI3E,MAAI,CAFa,iBAAiB,YAGhC,OAAM,IAAI,MAAM,2BAA2B,WAAW,SAAS,GAAG,GAAG;AAGvE,SAAO;GACL,MAAM,IAAI,WAAW,oBAAoB;GACzC,UAAU,iBAAiB;GAC5B;;;;;;;;;;CAWH,OAAc,QAAQ,MAA8B;AAClD,MAAI;AACF,oBAAiB,OAAO,KAAK;AAC7B,UAAO;WACA,IAAI;AACX,UAAO"}

package/build/utils/TypedArrayEncoder.d.mts

@@ -1,3 +1,4 @@
+import { AnyUint8Array, Uint8ArrayBuffer } from "../types.mjs";
 import { Buffer } from "./buffer.mjs";
 
 //#region src/utils/TypedArrayEncoder.d.ts
@@ -7,50 +8,52 @@ declare class TypedArrayEncoder {
    *
    * @param buffer the buffer to encode into base64 string
    */
-  static toBase64(buffer: Buffer | Uint8Array): string;
+  static toBase64(buffer: Buffer | AnyUint8Array): string;
   /**
    * Encode buffer into base64url string.
    *
    * @param buffer the buffer to encode into base64url string
    */
-  static toBase64URL(buffer: Buffer | Uint8Array): string;
+  static toBase64URL(buffer: Buffer | AnyUint8Array): string;
   /**
    * Encode buffer into base58 string.
    *
    * @param buffer the buffer to encode into base58 string
    */
-  static toBase58(buffer: Buffer | Uint8Array): string;
+  static toBase58(buffer: Buffer | AnyUint8Array): string;
   /**
    * Decode base64 string into buffer. Also supports base64url
    *
    * @param base64 the base64 or base64url string to decode into buffer format
    */
-  static fromBase64(base64: string): Buffer;
+  static fromBase64(base64: string): Buffer<ArrayBuffer>;
   /**
    * Decode base58 string into buffer
    *
    * @param base58 the base58 string to decode into buffer format
    */
-  static fromBase58(base58: string): Buffer;
+  static fromBase58(base58: string): Buffer<ArrayBuffer>;
   /**
    * Encode buffer into base64 string.
    *
    * @param buffer the buffer to encode into base64 string
    */
-  static toHex(buffer: Buffer | Uint8Array): string;
+  static toHex(buffer: Buffer | AnyUint8Array): string;
   /**
    * Decode hex string into buffer
    *
    * @param hex the hex string to decode into buffer format
    */
-  static fromHex(hex: string): Buffer;
+  static fromHex(hex: string): Buffer<ArrayBuffer>;
   /**
    * Decode string into buffer.
    *
    * @param str the string to decode into buffer format
    */
-  static fromString(str: string): Buffer;
-  static toUtf8String(buffer: Buffer | Uint8Array): string;
+  static fromString(str: string): Uint8ArrayBuffer;
+  static toUtf8String(buffer: Buffer | AnyUint8Array): string;
+  static concat(entries: AnyUint8Array[]): Uint8ArrayBuffer;
+  static equals(firstBuffer: AnyUint8Array, otherBuffer: AnyUint8Array): boolean;
   /**
    * Check whether an array is byte, or typed, array
    *

package/build/utils/TypedArrayEncoder.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"TypedArrayEncoder.d.mts","names":[],"sources":["../../src/utils/TypedArrayEncoder.ts"],"sourcesContent":[],"mappings":";;;cAKa,iBAAA;;;;AAAb;;SAMiC,QAAA,CAAA,MAAA,EAAA,MAAA,GAAS,UAAT,CAAA,EAAA,MAAA;;;;;;SA2BQ,WAAA,CAAA,MAAA,EAlBL,MAkBK,GAlBI,UAkBJ,CAAA,EAAA,MAAA;;;;;;SAwCJ,QAAA,CAAA,MAAA,EAjDJ,MAiDI,GAjDK,UAiDL,CAAA,EAAA,MAAA;;;;;;qCAxCI;;;;;;qCASA;;;;;;uBASX,SAAS;;;;;;+BASJ;;;;;;kCASM;8BAIJ,SAAS"}
+{"version":3,"file":"TypedArrayEncoder.d.mts","names":[],"sources":["../../src/utils/TypedArrayEncoder.ts"],"sourcesContent":[],"mappings":";;;;cAMa,iBAAA;;;;AAAb;;SAMiC,QAAA,CAAA,MAAA,EAAA,MAAA,GAAS,aAAT,CAAA,EAAA,MAAA;;;;;;SA2BQ,WAAA,CAAA,MAAA,EAlBL,MAkBK,GAlBI,aAkBJ,CAAA,EAAA,MAAA;;;;;;SA2BN,QAAA,CAAA,MAAA,EApCF,MAoCE,GApCO,aAoCP,CAAA,EAAA,MAAA;;;;;;SAiBe,UAAA,CAAA,MAAA,EAAA,MAAA,CAAA,EA5CT,MA4CS,CA5CT,WA4CS,CAAA;;;;;;qCAnCT,OAAA;;;;;;uBASX,SAAS;;;;;;+BASJ,OAAA;;;;;;kCASM;8BAIJ,SAAS;yBAId,kBAAkB;6BAId,4BAA4B"}

package/build/utils/TypedArrayEncoder.d.ts

@@ -1,3 +1,4 @@
+import { AnyUint8Array, Uint8ArrayBuffer } from "../types.js";
 import { Buffer } from "./buffer.js";
 
 //#region src/utils/TypedArrayEncoder.d.ts
@@ -7,50 +8,52 @@ declare class TypedArrayEncoder {
    *
    * @param buffer the buffer to encode into base64 string
    */
-  static toBase64(buffer: Buffer | Uint8Array): string;
+  static toBase64(buffer: Buffer | AnyUint8Array): string;
   /**
    * Encode buffer into base64url string.
    *
    * @param buffer the buffer to encode into base64url string
    */
-  static toBase64URL(buffer: Buffer | Uint8Array): string;
+  static toBase64URL(buffer: Buffer | AnyUint8Array): string;
   /**
    * Encode buffer into base58 string.
    *
    * @param buffer the buffer to encode into base58 string
    */
-  static toBase58(buffer: Buffer | Uint8Array): string;
+  static toBase58(buffer: Buffer | AnyUint8Array): string;
   /**
    * Decode base64 string into buffer. Also supports base64url
    *
    * @param base64 the base64 or base64url string to decode into buffer format
    */
-  static fromBase64(base64: string): Buffer;
+  static fromBase64(base64: string): Buffer<ArrayBuffer>;
   /**
    * Decode base58 string into buffer
    *
    * @param base58 the base58 string to decode into buffer format
    */
-  static fromBase58(base58: string): Buffer;
+  static fromBase58(base58: string): Buffer<ArrayBuffer>;
   /**
    * Encode buffer into base64 string.
    *
    * @param buffer the buffer to encode into base64 string
    */
-  static toHex(buffer: Buffer | Uint8Array): string;
+  static toHex(buffer: Buffer | AnyUint8Array): string;
   /**
    * Decode hex string into buffer
    *
    * @param hex the hex string to decode into buffer format
    */
-  static fromHex(hex: string): Buffer;
+  static fromHex(hex: string): Buffer<ArrayBuffer>;
   /**
    * Decode string into buffer.
    *
    * @param str the string to decode into buffer format
    */
-  static fromString(str: string): Buffer;
-  static toUtf8String(buffer: Buffer | Uint8Array): string;
+  static fromString(str: string): Uint8ArrayBuffer;
+  static toUtf8String(buffer: Buffer | AnyUint8Array): string;
+  static concat(entries: AnyUint8Array[]): Uint8ArrayBuffer;
+  static equals(firstBuffer: AnyUint8Array, otherBuffer: AnyUint8Array): boolean;
   /**
    * Check whether an array is byte, or typed, array
    *

package/build/utils/TypedArrayEncoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TypedArrayEncoder.d.ts","names":[],"sources":["../../src/utils/TypedArrayEncoder.ts"],"sourcesContent":[],"mappings":";;;cAKa,iBAAA;;AAAb;;;;SAeoC,QAAA,CAAA,MAAA,EATH,MASG,GATM,UASN,CAAA,EAAA,MAAA;;;;;;SAoCN,WAAA,CAAA,MAAA,EApCM,MAoCN,GApCe,UAoCf,CAAA,EAAA,MAAA;;;;;;EAsB0B,OAAA,QAAA,CAAA,MAAA,EAjDvB,MAiDuB,GAjDd,UAiDc,CAAA,EAAA,MAAA;;;;;;qCAxCf;;;;;;qCASA;;;;;;uBASX,SAAS;;;;;;+BASJ;;;;;;kCASM;8BAIJ,SAAS"}
+{"version":3,"file":"TypedArrayEncoder.d.ts","names":[],"sources":["../../src/utils/TypedArrayEncoder.ts"],"sourcesContent":[],"mappings":";;;;cAMa,iBAAA;;AAAb;;;;SAeoC,QAAA,CAAA,MAAA,EATH,MASG,GATM,aASN,CAAA,EAAA,MAAA;;;;;;SA2BK,WAAA,CAAA,MAAA,EA3BL,MA2BK,GA3BI,aA2BJ,CAAA,EAAA,MAAA;;;;;;SA2BA,QAAA,CAAA,MAAA,EA7CR,MA6CQ,GA7CC,aA6CD,CAAA,EAAA,MAAA;;;;;;SAYuB,UAAA,CAAA,MAAA,EAAA,MAAA,CAAA,EAhDvB,MAgDuB,CAhDvB,WAgDuB,CAAA;EAAa;;;;;qCAvCpC,OAAA;;;;;;uBASX,SAAS;;;;;;+BASJ,OAAA;;;;;;kCASM;8BAIJ,SAAS;yBAId,kBAAkB;6BAId,4BAA4B"}

package/build/utils/TypedArrayEncoder.js

@@ -3,9 +3,8 @@
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
 const require_base58 = require('./base58.js');
 const require_base64 = require('./base64.js');
-require('./buffer.js');
-let buffer_index_js = require("buffer/index.js");
-buffer_index_js = require_rolldown_runtime.__toESM(buffer_index_js);
+let buffer = require("buffer");
+buffer = require_rolldown_runtime.__toESM(buffer);
 
 //#region src/utils/TypedArrayEncoder.ts
 var TypedArrayEncoder = class TypedArrayEncoder {
@@ -14,24 +13,24 @@ var TypedArrayEncoder = class TypedArrayEncoder {
 	*
 	* @param buffer the buffer to encode into base64 string
 	*/
-	static toBase64(buffer) {
-		return buffer_index_js.Buffer.from(buffer).toString("base64");
+	static toBase64(buffer$1) {
+		return buffer.Buffer.from(buffer$1).toString("base64");
 	}
 	/**
 	* Encode buffer into base64url string.
 	*
 	* @param buffer the buffer to encode into base64url string
 	*/
-	static toBase64URL(buffer) {
-		return require_base64.base64ToBase64URL(TypedArrayEncoder.toBase64(buffer));
+	static toBase64URL(buffer$1) {
+		return require_base64.base64ToBase64URL(TypedArrayEncoder.toBase64(buffer$1));
 	}
 	/**
 	* Encode buffer into base58 string.
 	*
 	* @param buffer the buffer to encode into base58 string
 	*/
-	static toBase58(buffer) {
-		return require_base58.encodeToBase58(buffer);
+	static toBase58(buffer$1) {
+		return require_base58.encodeToBase58(buffer$1);
 	}
 	/**
 	* Decode base64 string into buffer. Also supports base64url
@@ -39,7 +38,7 @@ var TypedArrayEncoder = class TypedArrayEncoder {
 	* @param base64 the base64 or base64url string to decode into buffer format
 	*/
 	static fromBase64(base64) {
-		return buffer_index_js.Buffer.from(base64, "base64");
+		return buffer.Buffer.from(base64, "base64");
 	}
 	/**
 	* Decode base58 string into buffer
@@ -47,15 +46,15 @@ var TypedArrayEncoder = class TypedArrayEncoder {
 	* @param base58 the base58 string to decode into buffer format
 	*/
 	static fromBase58(base58) {
-		return buffer_index_js.Buffer.from(require_base58.decodeFromBase58(base58));
+		return buffer.Buffer.from(require_base58.decodeFromBase58(base58));
 	}
 	/**
 	* Encode buffer into base64 string.
 	*
 	* @param buffer the buffer to encode into base64 string
 	*/
-	static toHex(buffer) {
-		return buffer_index_js.Buffer.from(buffer).toString("hex");
+	static toHex(buffer$1) {
+		return buffer.Buffer.from(buffer$1).toString("hex");
 	}
 	/**
 	* Decode hex string into buffer
@@ -63,7 +62,7 @@ var TypedArrayEncoder = class TypedArrayEncoder {
 	* @param hex the hex string to decode into buffer format
 	*/
 	static fromHex(hex) {
-		return buffer_index_js.Buffer.from(hex, "hex");
+		return buffer.Buffer.from(hex, "hex");
 	}
 	/**
 	* Decode string into buffer.
@@ -71,10 +70,16 @@ var TypedArrayEncoder = class TypedArrayEncoder {
 	* @param str the string to decode into buffer format
 	*/
 	static fromString(str) {
-		return buffer_index_js.Buffer.from(str);
+		return buffer.Buffer.from(str);
 	}
-	static toUtf8String(buffer) {
-		return buffer_index_js.Buffer.from(buffer).toString();
+	static toUtf8String(buffer$1) {
+		return buffer.Buffer.from(buffer$1).toString();
+	}
+	static concat(entries) {
+		return buffer.Buffer.concat(entries);
+	}
+	static equals(firstBuffer, otherBuffer) {
+		return buffer.Buffer.from(firstBuffer).equals(otherBuffer);
 	}
 	/**
 	* Check whether an array is byte, or typed, array

package/build/utils/TypedArrayEncoder.mjs

@@ -1,8 +1,8 @@
 
 
+import { Buffer } from "./buffer.mjs";
 import { decodeFromBase58, encodeToBase58 } from "./base58.mjs";
 import { base64ToBase64URL } from "./base64.mjs";
-import { Buffer } from "./buffer.mjs";
 
 //#region src/utils/TypedArrayEncoder.ts
 var TypedArrayEncoder = class TypedArrayEncoder {
@@ -73,6 +73,12 @@ var TypedArrayEncoder = class TypedArrayEncoder {
 	static toUtf8String(buffer) {
 		return Buffer.from(buffer).toString();
 	}
+	static concat(entries) {
+		return Buffer.concat(entries);
+	}
+	static equals(firstBuffer, otherBuffer) {
+		return Buffer.from(firstBuffer).equals(otherBuffer);
+	}
 	/**
 	* Check whether an array is byte, or typed, array
 	*

package/build/utils/TypedArrayEncoder.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"TypedArrayEncoder.mjs","names":[],"sources":["../../src/utils/TypedArrayEncoder.ts"],"sourcesContent":["import { decodeFromBase58, encodeToBase58 } from './base58'\nimport { base64ToBase64URL } from './base64'\nimport { Buffer } from './buffer'\n\n// biome-ignore lint/complexity/noStaticOnlyClass: <explanation>\nexport class TypedArrayEncoder {\n  /**\n   * Encode buffer into base64 string.\n   *\n   * @param buffer the buffer to encode into base64 string\n   */\n  public static toBase64(buffer: Buffer | Uint8Array) {\n    return Buffer.from(buffer).toString('base64')\n  }\n\n  /**\n   * Encode buffer into base64url string.\n   *\n   * @param buffer the buffer to encode into base64url string\n   */\n  public static toBase64URL(buffer: Buffer | Uint8Array) {\n    return base64ToBase64URL(TypedArrayEncoder.toBase64(buffer))\n  }\n\n  /**\n   * Encode buffer into base58 string.\n   *\n   * @param buffer the buffer to encode into base58 string\n   */\n  public static toBase58(buffer: Buffer | Uint8Array) {\n    return encodeToBase58(buffer)\n  }\n\n  /**\n   * Decode base64 string into buffer. Also supports base64url\n   *\n   * @param base64 the base64 or base64url string to decode into buffer format\n   */\n  public static fromBase64(base64: string) {\n    return Buffer.from(base64, 'base64')\n  }\n\n  /**\n   * Decode base58 string into buffer\n   *\n   * @param base58 the base58 string to decode into buffer format\n   */\n  public static fromBase58(base58: string) {\n    return Buffer.from(decodeFromBase58(base58))\n  }\n\n  /**\n   * Encode buffer into base64 string.\n   *\n   * @param buffer the buffer to encode into base64 string\n   */\n  public static toHex(buffer: Buffer | Uint8Array) {\n    return Buffer.from(buffer).toString('hex')\n  }\n\n  /**\n   * Decode hex string into buffer\n   *\n   * @param hex the hex string to decode into buffer format\n   */\n  public static fromHex(hex: string) {\n    return Buffer.from(hex, 'hex')\n  }\n\n  /**\n   * Decode string into buffer.\n   *\n   * @param str the string to decode into buffer format\n   */\n  public static fromString(str: string): Buffer {\n    return Buffer.from(str)\n  }\n\n  public static toUtf8String(buffer: Buffer | Uint8Array) {\n    return Buffer.from(buffer).toString()\n  }\n\n  /**\n   * Check whether an array is byte, or typed, array\n   *\n   * @param array unknown The array that has to be checked\n   *\n   * @returns A boolean if the array is a byte array\n   */\n  public static isTypedArray(array: unknown): boolean {\n    // Checks whether the static property 'BYTES_PER_ELEMENT' exists on the provided array.\n    // This has to be done, since the TypedArrays, e.g. Uint8Array and Float32Array, do not\n    // extend a single base class\n    return 'BYTES_PER_ELEMENT' in (array as Record<string, unknown>)\n  }\n}\n"],"mappings":";;;;;;;AAKA,IAAa,oBAAb,MAAa,kBAAkB;;;;;;CAM7B,OAAc,SAAS,QAA6B;AAClD,SAAO,OAAO,KAAK,OAAO,CAAC,SAAS,SAAS;;;;;;;CAQ/C,OAAc,YAAY,QAA6B;AACrD,SAAO,kBAAkB,kBAAkB,SAAS,OAAO,CAAC;;;;;;;CAQ9D,OAAc,SAAS,QAA6B;AAClD,SAAO,eAAe,OAAO;;;;;;;CAQ/B,OAAc,WAAW,QAAgB;AACvC,SAAO,OAAO,KAAK,QAAQ,SAAS;;;;;;;CAQtC,OAAc,WAAW,QAAgB;AACvC,SAAO,OAAO,KAAK,iBAAiB,OAAO,CAAC;;;;;;;CAQ9C,OAAc,MAAM,QAA6B;AAC/C,SAAO,OAAO,KAAK,OAAO,CAAC,SAAS,MAAM;;;;;;;CAQ5C,OAAc,QAAQ,KAAa;AACjC,SAAO,OAAO,KAAK,KAAK,MAAM;;;;;;;CAQhC,OAAc,WAAW,KAAqB;AAC5C,SAAO,OAAO,KAAK,IAAI;;CAGzB,OAAc,aAAa,QAA6B;AACtD,SAAO,OAAO,KAAK,OAAO,CAAC,UAAU;;;;;;;;;CAUvC,OAAc,aAAa,OAAyB;AAIlD,SAAO,uBAAwB"}
+{"version":3,"file":"TypedArrayEncoder.mjs","names":[],"sources":["../../src/utils/TypedArrayEncoder.ts"],"sourcesContent":["import type { AnyUint8Array, Uint8ArrayBuffer } from '../types'\nimport { decodeFromBase58, encodeToBase58 } from './base58'\nimport { base64ToBase64URL } from './base64'\nimport { Buffer } from './buffer'\n\n// biome-ignore lint/complexity/noStaticOnlyClass: no explanation\nexport class TypedArrayEncoder {\n  /**\n   * Encode buffer into base64 string.\n   *\n   * @param buffer the buffer to encode into base64 string\n   */\n  public static toBase64(buffer: Buffer | AnyUint8Array) {\n    return Buffer.from(buffer).toString('base64')\n  }\n\n  /**\n   * Encode buffer into base64url string.\n   *\n   * @param buffer the buffer to encode into base64url string\n   */\n  public static toBase64URL(buffer: Buffer | AnyUint8Array) {\n    return base64ToBase64URL(TypedArrayEncoder.toBase64(buffer))\n  }\n\n  /**\n   * Encode buffer into base58 string.\n   *\n   * @param buffer the buffer to encode into base58 string\n   */\n  public static toBase58(buffer: Buffer | AnyUint8Array) {\n    return encodeToBase58(buffer)\n  }\n\n  /**\n   * Decode base64 string into buffer. Also supports base64url\n   *\n   * @param base64 the base64 or base64url string to decode into buffer format\n   */\n  public static fromBase64(base64: string) {\n    return Buffer.from(base64, 'base64')\n  }\n\n  /**\n   * Decode base58 string into buffer\n   *\n   * @param base58 the base58 string to decode into buffer format\n   */\n  public static fromBase58(base58: string) {\n    return Buffer.from(decodeFromBase58(base58))\n  }\n\n  /**\n   * Encode buffer into base64 string.\n   *\n   * @param buffer the buffer to encode into base64 string\n   */\n  public static toHex(buffer: Buffer | AnyUint8Array) {\n    return Buffer.from(buffer).toString('hex')\n  }\n\n  /**\n   * Decode hex string into buffer\n   *\n   * @param hex the hex string to decode into buffer format\n   */\n  public static fromHex(hex: string) {\n    return Buffer.from(hex, 'hex')\n  }\n\n  /**\n   * Decode string into buffer.\n   *\n   * @param str the string to decode into buffer format\n   */\n  public static fromString(str: string): Uint8ArrayBuffer {\n    return Buffer.from(str)\n  }\n\n  public static toUtf8String(buffer: Buffer | AnyUint8Array) {\n    return Buffer.from(buffer).toString()\n  }\n\n  public static concat(entries: AnyUint8Array[]): Uint8ArrayBuffer {\n    return Buffer.concat(entries)\n  }\n\n  public static equals(firstBuffer: AnyUint8Array, otherBuffer: AnyUint8Array): boolean {\n    return Buffer.from(firstBuffer).equals(otherBuffer)\n  }\n\n  /**\n   * Check whether an array is byte, or typed, array\n   *\n   * @param array unknown The array that has to be checked\n   *\n   * @returns A boolean if the array is a byte array\n   */\n  public static isTypedArray(array: unknown): boolean {\n    // Checks whether the static property 'BYTES_PER_ELEMENT' exists on the provided array.\n    // This has to be done, since the TypedArrays, e.g. Uint8Array and Float32Array, do not\n    // extend a single base class\n    return 'BYTES_PER_ELEMENT' in (array as Record<string, unknown>)\n  }\n}\n"],"mappings":";;;;;;;AAMA,IAAa,oBAAb,MAAa,kBAAkB;;;;;;CAM7B,OAAc,SAAS,QAAgC;AACrD,SAAO,OAAO,KAAK,OAAO,CAAC,SAAS,SAAS;;;;;;;CAQ/C,OAAc,YAAY,QAAgC;AACxD,SAAO,kBAAkB,kBAAkB,SAAS,OAAO,CAAC;;;;;;;CAQ9D,OAAc,SAAS,QAAgC;AACrD,SAAO,eAAe,OAAO;;;;;;;CAQ/B,OAAc,WAAW,QAAgB;AACvC,SAAO,OAAO,KAAK,QAAQ,SAAS;;;;;;;CAQtC,OAAc,WAAW,QAAgB;AACvC,SAAO,OAAO,KAAK,iBAAiB,OAAO,CAAC;;;;;;;CAQ9C,OAAc,MAAM,QAAgC;AAClD,SAAO,OAAO,KAAK,OAAO,CAAC,SAAS,MAAM;;;;;;;CAQ5C,OAAc,QAAQ,KAAa;AACjC,SAAO,OAAO,KAAK,KAAK,MAAM;;;;;;;CAQhC,OAAc,WAAW,KAA+B;AACtD,SAAO,OAAO,KAAK,IAAI;;CAGzB,OAAc,aAAa,QAAgC;AACzD,SAAO,OAAO,KAAK,OAAO,CAAC,UAAU;;CAGvC,OAAc,OAAO,SAA4C;AAC/D,SAAO,OAAO,OAAO,QAAQ;;CAG/B,OAAc,OAAO,aAA4B,aAAqC;AACpF,SAAO,OAAO,KAAK,YAAY,CAAC,OAAO,YAAY;;;;;;;;;CAUrD,OAAc,aAAa,OAAyB;AAIlD,SAAO,uBAAwB"}

package/build/utils/VarintEncoder.js

@@ -1,11 +1,8 @@
 
 
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
-require('./buffer.js');
 let varint = require("varint");
 varint = require_rolldown_runtime.__toESM(varint);
-let buffer_index_js = require("buffer/index.js");
-buffer_index_js = require_rolldown_runtime.__toESM(buffer_index_js);
 
 //#region src/utils/VarintEncoder.ts
 var VarintEncoder = class VarintEncoder {
@@ -13,7 +10,7 @@ var VarintEncoder = class VarintEncoder {
 		return [varint.default.decode(data), varint.default.decode.bytes];
 	}
 	static encode(int) {
-		const target = new buffer_index_js.Buffer(VarintEncoder.encodingLength(int));
+		const target = new Uint8Array(VarintEncoder.encodingLength(int));
 		varint.default.encode(int, target);
 		return target;
 	}

package/build/utils/VarintEncoder.mjs

@@ -1,6 +1,5 @@
 
 
-import { Buffer } from "./buffer.mjs";
 import varint from "varint";
 
 //#region src/utils/VarintEncoder.ts
@@ -9,7 +8,7 @@ var VarintEncoder = class VarintEncoder {
 		return [varint.decode(data), varint.decode.bytes];
 	}
 	static encode(int) {
-		const target = new Buffer(VarintEncoder.encodingLength(int));
+		const target = new Uint8Array(VarintEncoder.encodingLength(int));
 		varint.encode(int, target);
 		return target;
 	}

package/build/utils/VarintEncoder.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"VarintEncoder.mjs","names":[],"sources":["../../src/utils/VarintEncoder.ts"],"sourcesContent":["import varint from 'varint'\n\nimport { Buffer } from './buffer'\n\n// biome-ignore lint/complexity/noStaticOnlyClass: <explanation>\nexport class VarintEncoder {\n  public static decode(data: Uint8Array | number[] | Buffer) {\n    const code = varint.decode(data)\n    return [code, varint.decode.bytes] as const\n  }\n\n  public static encode(int: number) {\n    const target = new Buffer(VarintEncoder.encodingLength(int))\n    varint.encode(int, target)\n    return target\n  }\n\n  public static encodingLength(int: number) {\n    return varint.encodingLength(int)\n  }\n}\n"],"mappings":";;;;;;AAKA,IAAa,gBAAb,MAAa,cAAc;CACzB,OAAc,OAAO,MAAsC;AAEzD,SAAO,CADM,OAAO,OAAO,KAAK,EAClB,OAAO,OAAO,MAAM;;CAGpC,OAAc,OAAO,KAAa;EAChC,MAAM,SAAS,IAAI,OAAO,cAAc,eAAe,IAAI,CAAC;AAC5D,SAAO,OAAO,KAAK,OAAO;AAC1B,SAAO;;CAGT,OAAc,eAAe,KAAa;AACxC,SAAO,OAAO,eAAe,IAAI"}
+{"version":3,"file":"VarintEncoder.mjs","names":[],"sources":["../../src/utils/VarintEncoder.ts"],"sourcesContent":["import varint from 'varint'\n\nimport type { AnyUint8Array } from '../types'\n\n// biome-ignore lint/complexity/noStaticOnlyClass: no explanation\nexport class VarintEncoder {\n  public static decode(data: AnyUint8Array | number[]) {\n    const code = varint.decode(data)\n    return [code, varint.decode.bytes] as const\n  }\n\n  public static encode(int: number) {\n    const target = new Uint8Array(VarintEncoder.encodingLength(int))\n    varint.encode(int, target)\n    return target\n  }\n\n  public static encodingLength(int: number) {\n    return varint.encodingLength(int)\n  }\n}\n"],"mappings":";;;;;AAKA,IAAa,gBAAb,MAAa,cAAc;CACzB,OAAc,OAAO,MAAgC;AAEnD,SAAO,CADM,OAAO,OAAO,KAAK,EAClB,OAAO,OAAO,MAAM;;CAGpC,OAAc,OAAO,KAAa;EAChC,MAAM,SAAS,IAAI,WAAW,cAAc,eAAe,IAAI,CAAC;AAChE,SAAO,OAAO,KAAK,OAAO;AAC1B,SAAO;;CAGT,OAAc,eAAe,KAAa;AACxC,SAAO,OAAO,eAAe,IAAI"}

package/build/utils/base58.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"base58.mjs","names":[],"sources":["../../src/utils/base58.ts"],"sourcesContent":["import base from '@multiformats/base-x'\n\nconst BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n\nconst base58Converter = base(BASE58_ALPHABET)\n\nexport function decodeFromBase58(base58: string) {\n  return base58Converter.decode(base58)\n}\n\nexport function encodeToBase58(buffer: Uint8Array) {\n  return base58Converter.encode(buffer)\n}\n"],"mappings":";;;;;AAIA,MAAM,kBAAkB,KAFA,6DAEqB;AAE7C,SAAgB,iBAAiB,QAAgB;AAC/C,QAAO,gBAAgB,OAAO,OAAO;;AAGvC,SAAgB,eAAe,QAAoB;AACjD,QAAO,gBAAgB,OAAO,OAAO"}
+{"version":3,"file":"base58.mjs","names":[],"sources":["../../src/utils/base58.ts"],"sourcesContent":["import base from '@multiformats/base-x'\nimport type { AnyUint8Array, Uint8ArrayBuffer } from '../types'\n\nconst BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n\nconst base58Converter = base(BASE58_ALPHABET)\n\nexport function decodeFromBase58(base58: string): Uint8ArrayBuffer {\n  return base58Converter.decode(base58) as Uint8ArrayBuffer\n}\n\nexport function encodeToBase58(buffer: AnyUint8Array) {\n  return base58Converter.encode(buffer)\n}\n"],"mappings":";;;;;AAKA,MAAM,kBAAkB,KAFA,6DAEqB;AAE7C,SAAgB,iBAAiB,QAAkC;AACjE,QAAO,gBAAgB,OAAO,OAAO;;AAGvC,SAAgB,eAAe,QAAuB;AACpD,QAAO,gBAAgB,OAAO,OAAO"}

package/build/utils/buffer.d.mts

@@ -1,2 +1,2 @@
-import { Buffer } from "buffer/index.js";
+import { Buffer } from "buffer";
 export { Buffer };

package/build/utils/buffer.d.ts

@@ -1,2 +1,2 @@
-import { Buffer } from "buffer/index.js";
+import { Buffer } from "buffer";
 export { Buffer };

package/build/utils/buffer.mjs

@@ -1,5 +1,5 @@
 
 
-import { Buffer } from "buffer/index.js";
+import { Buffer } from "buffer";
 
 export { Buffer };

package/build/utils/deepEquality.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"deepEquality.mjs","names":[],"sources":["../../src/utils/deepEquality.ts"],"sourcesContent":["import { areObjectsEqual } from './objectEquality'\n\n// biome-ignore lint/suspicious/noExplicitAny: <explanation>\nexport function deepEquality(x: any, y: any): boolean {\n  // We do a simple equals here to check primitives, functions, regex, etc.\n  // This will only happen if the typing of the function is ignored\n  const isXSimpleEqualY = simpleEqual(x, y)\n  if (isXSimpleEqualY !== undefined) return isXSimpleEqualY\n\n  if (!(x instanceof Map) || !(y instanceof Map)) return areObjectsEqual(x, y)\n\n  const xMap = x as Map<string, unknown>\n  const yMap = y as Map<string, unknown>\n\n  // At this point we are sure we have two instances of a Map\n  const xKeys = Array.from(xMap.keys())\n  const yKeys = Array.from(yMap.keys())\n\n  // Keys from both maps are not equal, content has not been verified, yet\n  if (!equalsIgnoreOrder(xKeys, yKeys)) return false\n\n  // Here we recursively check whether the value of xMap is equals to the value of yMap\n  return Array.from(xMap.entries()).every(([key, xVal]) => deepEquality(xVal, yMap.get(key)))\n}\n\n/**\n * @note This will only work for primitive array equality\n */\nexport function equalsIgnoreOrder<Item = string>(a: Array<Item>, b: Array<Item>): boolean {\n  if (a.length !== b.length) return false\n  return a.every((k) => b.includes(k))\n}\n\n/**\n * @note This will only work for primitive array equality\n */\nexport function equalsWithOrder<Item = string>(lhs: Array<Item>, rhs: Array<Item>): boolean {\n  if (lhs.length !== rhs.length) return false\n  return lhs.every((k, i) => k === rhs[i])\n}\n\n// We take any here as we have to check some properties, they will be undefined if they do not exist\n// biome-ignore lint/suspicious/noExplicitAny: <explanation>\nfunction simpleEqual(x: any, y: any) {\n  // short circuit for easy equality\n  if (x === y) return true\n\n  if ((x === null || x === undefined) && (y === null || y === undefined)) return x === y\n\n  // after this just checking type of one would be enough\n  if (x.constructor !== y.constructor) return false\n\n  // if they are functions, they should exactly refer to same one (because of closures)\n  if (x instanceof Function) return x === y\n\n  // if they are regexps, they should exactly refer to same one (it is hard to better equality check on current ES)\n  if (x instanceof RegExp) return x === y\n\n  if (x.valueOf && y.valueOf && x.valueOf() === y.valueOf()) return true\n\n  // if they are dates, they must had equal valueOf\n  if (x instanceof Date || y instanceof Date) return false\n}\n"],"mappings":";;;;;AAGA,SAAgB,aAAa,GAAQ,GAAiB;CAGpD,MAAM,kBAAkB,YAAY,GAAG,EAAE;AACzC,KAAI,oBAAoB,OAAW,QAAO;AAE1C,KAAI,EAAE,aAAa,QAAQ,EAAE,aAAa,KAAM,QAAO,gBAAgB,GAAG,EAAE;CAE5E,MAAM,OAAO;CACb,MAAM,OAAO;AAOb,KAAI,CAAC,kBAJS,MAAM,KAAK,KAAK,MAAM,CAAC,EACvB,MAAM,KAAK,KAAK,MAAM,CAAC,CAGD,CAAE,QAAO;AAG7C,QAAO,MAAM,KAAK,KAAK,SAAS,CAAC,CAAC,OAAO,CAAC,KAAK,UAAU,aAAa,MAAM,KAAK,IAAI,IAAI,CAAC,CAAC;;;;;AAM7F,SAAgB,kBAAiC,GAAgB,GAAyB;AACxF,KAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAClC,QAAO,EAAE,OAAO,MAAM,EAAE,SAAS,EAAE,CAAC;;;;;AAMtC,SAAgB,gBAA+B,KAAkB,KAA2B;AAC1F,KAAI,IAAI,WAAW,IAAI,OAAQ,QAAO;AACtC,QAAO,IAAI,OAAO,GAAG,MAAM,MAAM,IAAI,GAAG;;AAK1C,SAAS,YAAY,GAAQ,GAAQ;AAEnC,KAAI,MAAM,EAAG,QAAO;AAEpB,MAAK,MAAM,QAAQ,MAAM,YAAe,MAAM,QAAQ,MAAM,QAAY,QAAO,MAAM;AAGrF,KAAI,EAAE,gBAAgB,EAAE,YAAa,QAAO;AAG5C,KAAI,aAAa,SAAU,QAAO,MAAM;AAGxC,KAAI,aAAa,OAAQ,QAAO,MAAM;AAEtC,KAAI,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,KAAK,EAAE,SAAS,CAAE,QAAO;AAGlE,KAAI,aAAa,QAAQ,aAAa,KAAM,QAAO"}
+{"version":3,"file":"deepEquality.mjs","names":[],"sources":["../../src/utils/deepEquality.ts"],"sourcesContent":["import { areObjectsEqual } from './objectEquality'\n\n// biome-ignore lint/suspicious/noExplicitAny: no explanation\nexport function deepEquality(x: any, y: any): boolean {\n  // We do a simple equals here to check primitives, functions, regex, etc.\n  // This will only happen if the typing of the function is ignored\n  const isXSimpleEqualY = simpleEqual(x, y)\n  if (isXSimpleEqualY !== undefined) return isXSimpleEqualY\n\n  if (!(x instanceof Map) || !(y instanceof Map)) return areObjectsEqual(x, y)\n\n  const xMap = x as Map<string, unknown>\n  const yMap = y as Map<string, unknown>\n\n  // At this point we are sure we have two instances of a Map\n  const xKeys = Array.from(xMap.keys())\n  const yKeys = Array.from(yMap.keys())\n\n  // Keys from both maps are not equal, content has not been verified, yet\n  if (!equalsIgnoreOrder(xKeys, yKeys)) return false\n\n  // Here we recursively check whether the value of xMap is equals to the value of yMap\n  return Array.from(xMap.entries()).every(([key, xVal]) => deepEquality(xVal, yMap.get(key)))\n}\n\n/**\n * @note This will only work for primitive array equality\n */\nexport function equalsIgnoreOrder<Item = string>(a: Array<Item>, b: Array<Item>): boolean {\n  if (a.length !== b.length) return false\n  return a.every((k) => b.includes(k))\n}\n\n/**\n * @note This will only work for primitive array equality\n */\nexport function equalsWithOrder<Item = string>(lhs: Array<Item>, rhs: Array<Item>): boolean {\n  if (lhs.length !== rhs.length) return false\n  return lhs.every((k, i) => k === rhs[i])\n}\n\n// We take any here as we have to check some properties, they will be undefined if they do not exist\n// biome-ignore lint/suspicious/noExplicitAny: no explanation\nfunction simpleEqual(x: any, y: any) {\n  // short circuit for easy equality\n  if (x === y) return true\n\n  if ((x === null || x === undefined) && (y === null || y === undefined)) return x === y\n\n  // after this just checking type of one would be enough\n  if (x.constructor !== y.constructor) return false\n\n  // if they are functions, they should exactly refer to same one (because of closures)\n  if (x instanceof Function) return x === y\n\n  // if they are regexps, they should exactly refer to same one (it is hard to better equality check on current ES)\n  if (x instanceof RegExp) return x === y\n\n  if (x.valueOf && y.valueOf && x.valueOf() === y.valueOf()) return true\n\n  // if they are dates, they must had equal valueOf\n  if (x instanceof Date || y instanceof Date) return false\n}\n"],"mappings":";;;;;AAGA,SAAgB,aAAa,GAAQ,GAAiB;CAGpD,MAAM,kBAAkB,YAAY,GAAG,EAAE;AACzC,KAAI,oBAAoB,OAAW,QAAO;AAE1C,KAAI,EAAE,aAAa,QAAQ,EAAE,aAAa,KAAM,QAAO,gBAAgB,GAAG,EAAE;CAE5E,MAAM,OAAO;CACb,MAAM,OAAO;AAOb,KAAI,CAAC,kBAJS,MAAM,KAAK,KAAK,MAAM,CAAC,EACvB,MAAM,KAAK,KAAK,MAAM,CAAC,CAGD,CAAE,QAAO;AAG7C,QAAO,MAAM,KAAK,KAAK,SAAS,CAAC,CAAC,OAAO,CAAC,KAAK,UAAU,aAAa,MAAM,KAAK,IAAI,IAAI,CAAC,CAAC;;;;;AAM7F,SAAgB,kBAAiC,GAAgB,GAAyB;AACxF,KAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAClC,QAAO,EAAE,OAAO,MAAM,EAAE,SAAS,EAAE,CAAC;;;;;AAMtC,SAAgB,gBAA+B,KAAkB,KAA2B;AAC1F,KAAI,IAAI,WAAW,IAAI,OAAQ,QAAO;AACtC,QAAO,IAAI,OAAO,GAAG,MAAM,MAAM,IAAI,GAAG;;AAK1C,SAAS,YAAY,GAAQ,GAAQ;AAEnC,KAAI,MAAM,EAAG,QAAO;AAEpB,MAAK,MAAM,QAAQ,MAAM,YAAe,MAAM,QAAQ,MAAM,QAAY,QAAO,MAAM;AAGrF,KAAI,EAAE,gBAAgB,EAAE,YAAa,QAAO;AAG5C,KAAI,aAAa,SAAU,QAAO,MAAM;AAGxC,KAAI,aAAa,OAAQ,QAAO,MAAM;AAEtC,KAAI,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,KAAK,EAAE,SAAS,CAAE,QAAO;AAGlE,KAAI,aAAa,QAAQ,aAAa,KAAM,QAAO"}

package/build/utils/index.js

@@ -1,21 +1,20 @@
 
 
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
-require('./buffer.js');
+const require_array = require('./array.js');
+const require_objectEquality = require('./objectEquality.js');
+const require_deepEquality = require('./deepEquality.js');
 const require_TypedArrayEncoder = require('./TypedArrayEncoder.js');
-const require_JsonEncoder = require('./JsonEncoder.js');
-const require_MessageValidator = require('./MessageValidator.js');
-const require_JsonTransformer = require('./JsonTransformer.js');
+const require_did = require('./did.js');
 const require_MultiBaseEncoder = require('./MultiBaseEncoder.js');
 const require_VarintEncoder = require('./VarintEncoder.js');
 const require_MultiHashEncoder = require('./MultiHashEncoder.js');
 const require_HashlinkEncoder = require('./HashlinkEncoder.js');
-const require_array = require('./array.js');
-const require_validators = require('./validators.js');
-const require_objectEquality = require('./objectEquality.js');
-const require_deepEquality = require('./deepEquality.js');
-const require_did = require('./did.js');
+const require_JsonEncoder = require('./JsonEncoder.js');
+const require_MessageValidator = require('./MessageValidator.js');
+const require_JsonTransformer = require('./JsonTransformer.js');
 const require_timestamp = require('./timestamp.js');
 const require_transformers = require('./transformers.js');
-let buffer_index_js = require("buffer/index.js");
-buffer_index_js = require_rolldown_runtime.__toESM(buffer_index_js);
+const require_validators = require('./validators.js');
+let buffer = require("buffer");
+buffer = require_rolldown_runtime.__toESM(buffer);

package/build/utils/index.mjs

@@ -1,18 +1,18 @@
 
 
+import { asArray, mapSingleOrArray } from "./array.mjs";
 import { Buffer } from "./buffer.mjs";
+import { areObjectsEqual } from "./objectEquality.mjs";
+import { deepEquality, equalsIgnoreOrder, equalsWithOrder } from "./deepEquality.mjs";
 import { TypedArrayEncoder } from "./TypedArrayEncoder.mjs";
-import { JsonEncoder } from "./JsonEncoder.mjs";
-import { MessageValidator } from "./MessageValidator.mjs";
-import { JsonTransformer } from "./JsonTransformer.mjs";
+import { indyDidFromPublicKeyBase58, isDid } from "./did.mjs";
 import { MultiBaseEncoder } from "./MultiBaseEncoder.mjs";
 import { VarintEncoder } from "./VarintEncoder.mjs";
 import { MultiHashEncoder } from "./MultiHashEncoder.mjs";
 import { HashlinkEncoder } from "./HashlinkEncoder.mjs";
-import { asArray, mapSingleOrArray } from "./array.mjs";
-import { IsInstanceOrArrayOfInstances, IsNever, IsStringOrInstance, IsStringOrInstanceOrArrayOfInstances, IsUri, UriValidator, isUri } from "./validators.mjs";
-import { areObjectsEqual } from "./objectEquality.mjs";
-import { deepEquality, equalsIgnoreOrder, equalsWithOrder } from "./deepEquality.mjs";
-import { indyDidFromPublicKeyBase58, isDid } from "./did.mjs";
-import { nowInSeconds } from "./timestamp.mjs";
+import { JsonEncoder } from "./JsonEncoder.mjs";
+import { MessageValidator } from "./MessageValidator.mjs";
+import { JsonTransformer } from "./JsonTransformer.mjs";
+import { addSecondsToDate, dateToSeconds, nowInSeconds } from "./timestamp.mjs";
 import { DateTransformer, IsStringOrStringArray } from "./transformers.mjs";
+import { IsInstanceOrArrayOfInstances, IsNever, IsStringOrInstance, IsStringOrInstanceOrArrayOfInstances, IsUri, UriValidator, isUri } from "./validators.mjs";

package/build/utils/objectEquality.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"objectEquality.mjs","names":[],"sources":["../../src/utils/objectEquality.ts"],"sourcesContent":["// biome-ignore lint/suspicious/noExplicitAny: <explanation>\nexport function areObjectsEqual<A = any, B extends A = A>(a: A, b: B): boolean {\n  if (typeof a === 'object' && a != null && typeof b === 'object' && b != null) {\n    const definedA = Object.fromEntries(Object.entries(a).filter(([, value]) => value !== undefined))\n    const definedB = Object.fromEntries(Object.entries(b).filter(([, value]) => value !== undefined))\n    if (Object.keys(definedA).length !== Object.keys(definedB).length) return false\n    for (const key in definedA) {\n      if (!(key in definedB) || !areObjectsEqual(definedA[key], definedB[key])) {\n        return false\n      }\n    }\n    for (const key in definedB) {\n      if (!(key in definedA) || !areObjectsEqual(definedB[key], definedA[key])) {\n        return false\n      }\n    }\n    return true\n  }\n  return a === b\n}\n"],"mappings":";;;AACA,SAAgB,gBAA0C,GAAM,GAAe;AAC7E,KAAI,OAAO,MAAM,YAAY,KAAK,QAAQ,OAAO,MAAM,YAAY,KAAK,MAAM;EAC5E,MAAM,WAAW,OAAO,YAAY,OAAO,QAAQ,EAAE,CAAC,QAAQ,GAAG,WAAW,UAAU,OAAU,CAAC;EACjG,MAAM,WAAW,OAAO,YAAY,OAAO,QAAQ,EAAE,CAAC,QAAQ,GAAG,WAAW,UAAU,OAAU,CAAC;AACjG,MAAI,OAAO,KAAK,SAAS,CAAC,WAAW,OAAO,KAAK,SAAS,CAAC,OAAQ,QAAO;AAC1E,OAAK,MAAM,OAAO,SAChB,KAAI,EAAE,OAAO,aAAa,CAAC,gBAAgB,SAAS,MAAM,SAAS,KAAK,CACtE,QAAO;AAGX,OAAK,MAAM,OAAO,SAChB,KAAI,EAAE,OAAO,aAAa,CAAC,gBAAgB,SAAS,MAAM,SAAS,KAAK,CACtE,QAAO;AAGX,SAAO;;AAET,QAAO,MAAM"}
+{"version":3,"file":"objectEquality.mjs","names":[],"sources":["../../src/utils/objectEquality.ts"],"sourcesContent":["// biome-ignore lint/suspicious/noExplicitAny: no explanation\nexport function areObjectsEqual<A = any, B extends A = A>(a: A, b: B): boolean {\n  if (typeof a === 'object' && a != null && typeof b === 'object' && b != null) {\n    const definedA = Object.fromEntries(Object.entries(a).filter(([, value]) => value !== undefined))\n    const definedB = Object.fromEntries(Object.entries(b).filter(([, value]) => value !== undefined))\n    if (Object.keys(definedA).length !== Object.keys(definedB).length) return false\n    for (const key in definedA) {\n      if (!(key in definedB) || !areObjectsEqual(definedA[key], definedB[key])) {\n        return false\n      }\n    }\n    for (const key in definedB) {\n      if (!(key in definedA) || !areObjectsEqual(definedB[key], definedA[key])) {\n        return false\n      }\n    }\n    return true\n  }\n  return a === b\n}\n"],"mappings":";;;AACA,SAAgB,gBAA0C,GAAM,GAAe;AAC7E,KAAI,OAAO,MAAM,YAAY,KAAK,QAAQ,OAAO,MAAM,YAAY,KAAK,MAAM;EAC5E,MAAM,WAAW,OAAO,YAAY,OAAO,QAAQ,EAAE,CAAC,QAAQ,GAAG,WAAW,UAAU,OAAU,CAAC;EACjG,MAAM,WAAW,OAAO,YAAY,OAAO,QAAQ,EAAE,CAAC,QAAQ,GAAG,WAAW,UAAU,OAAU,CAAC;AACjG,MAAI,OAAO,KAAK,SAAS,CAAC,WAAW,OAAO,KAAK,SAAS,CAAC,OAAQ,QAAO;AAC1E,OAAK,MAAM,OAAO,SAChB,KAAI,EAAE,OAAO,aAAa,CAAC,gBAAgB,SAAS,MAAM,SAAS,KAAK,CACtE,QAAO;AAGX,OAAK,MAAM,OAAO,SAChB,KAAI,EAAE,OAAO,aAAa,CAAC,gBAAgB,SAAS,MAAM,SAAS,KAAK,CACtE,QAAO;AAGX,SAAO;;AAET,QAAO,MAAM"}

package/build/utils/timestamp.d.mts

@@ -1,5 +1,13 @@
+import { Uint8ArrayBuffer } from "../types.mjs";
+
 //#region src/utils/timestamp.d.ts
-declare function timestamp(): Uint8Array;
+declare function timestamp(): Uint8ArrayBuffer;
+/**
+ * Returns the current time in seconds
+ */
+declare function nowInSeconds(): number;
+declare function addSecondsToDate(date: Date, seconds: number): Date;
+declare function dateToSeconds(date: Date): number;
 //#endregion
-export { timestamp };
+export { addSecondsToDate, dateToSeconds, nowInSeconds, timestamp };
 //# sourceMappingURL=timestamp.d.mts.map

package/build/utils/timestamp.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"timestamp.d.mts","names":[],"sources":["../../src/utils/timestamp.ts"],"sourcesContent":[],"mappings":";iBAEwB,SAAA,CAAA,GAAa"}
+{"version":3,"file":"timestamp.d.mts","names":[],"sources":["../../src/utils/timestamp.ts"],"sourcesContent":[],"mappings":";;;iBAIwB,SAAA,CAAA,GAAa;;;;AAAb,iBAcR,YAAA,CAAA,CAdqB,EAAA,MAAgB;AAcrC,iBAIA,gBAAA,CAJY,IAAA,EAIW,IAJX,EAAA,OAAA,EAAA,MAAA,CAAA,EAIgC,IAJhC;AAIZ,iBAIA,aAAA,CAJgB,IAAA,EAII,IAJJ,CAAA,EAAA,MAAA"}

package/build/utils/timestamp.d.ts

@@ -1,5 +1,13 @@
+import { Uint8ArrayBuffer } from "../types.js";
+
 //#region src/utils/timestamp.d.ts
-declare function timestamp(): Uint8Array;
+declare function timestamp(): Uint8ArrayBuffer;
+/**
+ * Returns the current time in seconds
+ */
+declare function nowInSeconds(): number;
+declare function addSecondsToDate(date: Date, seconds: number): Date;
+declare function dateToSeconds(date: Date): number;
 //#endregion
-export { timestamp };
+export { addSecondsToDate, dateToSeconds, nowInSeconds, timestamp };
 //# sourceMappingURL=timestamp.d.ts.map

package/build/utils/timestamp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timestamp.d.ts","names":[],"sources":["../../src/utils/timestamp.ts"],"sourcesContent":[],"mappings":";iBAEwB,SAAA,CAAA,GAAa"}
+{"version":3,"file":"timestamp.d.ts","names":[],"sources":["../../src/utils/timestamp.ts"],"sourcesContent":[],"mappings":";;;iBAIwB,SAAA,CAAA,GAAa;;AAJW;AAkBhD;AAIgB,iBAJA,YAAA,CAAA,CAIgB,EAAA,MAAA;AAAA,iBAAhB,gBAAA,CAAgB,IAAA,EAAO,IAAP,EAAA,OAAA,EAAA,MAAA,CAAA,EAA4B,IAA5B;AAAO,iBAIvB,aAAA,CAJuB,IAAA,EAIH,IAJG,CAAA,EAAA,MAAA"}

package/build/utils/timestamp.js

@@ -16,9 +16,17 @@ function timestamp() {
 * Returns the current time in seconds
 */
 function nowInSeconds() {
-	return Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
+	return Math.floor(Date.now() / 1e3);
+}
+function addSecondsToDate(date, seconds) {
+	return new Date(date.getTime() + seconds * 1e3);
+}
+function dateToSeconds(date) {
+	return Math.floor(date.getTime() / 1e3);
 }
 
 //#endregion
+exports.addSecondsToDate = addSecondsToDate;
+exports.dateToSeconds = dateToSeconds;
 exports.default = timestamp;
 exports.nowInSeconds = nowInSeconds;

package/build/utils/timestamp.mjs

@@ -15,9 +15,15 @@ function timestamp() {
 * Returns the current time in seconds
 */
 function nowInSeconds() {
-	return Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
+	return Math.floor(Date.now() / 1e3);
+}
+function addSecondsToDate(date, seconds) {
+	return new Date(date.getTime() + seconds * 1e3);
+}
+function dateToSeconds(date) {
+	return Math.floor(date.getTime() / 1e3);
 }
 
 //#endregion
-export { timestamp as default, nowInSeconds };
+export { addSecondsToDate, dateToSeconds, timestamp as default, nowInSeconds };
 //# sourceMappingURL=timestamp.mjs.map

package/build/utils/timestamp.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"timestamp.mjs","names":[],"sources":["../../src/utils/timestamp.ts"],"sourcesContent":["// Question: Spec isn't clear about the endianness. Assumes big-endian here\n// since ACA-Py uses big-endian.\nexport default function timestamp(): Uint8Array {\n  let time = Date.now()\n  const bytes = []\n  for (let i = 0; i < 8; i++) {\n    const byte = time & 0xff\n    bytes.push(byte)\n    time = (time - byte) / 256 // Javascript right shift (>>>) only works on 32 bit integers\n  }\n  return Uint8Array.from(bytes).reverse()\n}\n\n/**\n * Returns the current time in seconds\n */\nexport function nowInSeconds() {\n  return Math.floor(new Date().getTime() / 1000)\n}\n"],"mappings":";;;AAEA,SAAwB,YAAwB;CAC9C,IAAI,OAAO,KAAK,KAAK;CACrB,MAAM,QAAQ,EAAE;AAChB,MAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;EAC1B,MAAM,OAAO,OAAO;AACpB,QAAM,KAAK,KAAK;AAChB,UAAQ,OAAO,QAAQ;;AAEzB,QAAO,WAAW,KAAK,MAAM,CAAC,SAAS;;;;;AAMzC,SAAgB,eAAe;AAC7B,QAAO,KAAK,uBAAM,IAAI,MAAM,EAAC,SAAS,GAAG,IAAK"}
+{"version":3,"file":"timestamp.mjs","names":[],"sources":["../../src/utils/timestamp.ts"],"sourcesContent":["import type { Uint8ArrayBuffer } from '../types'\n\n// Question: Spec isn't clear about the endianness. Assumes big-endian here\n// since ACA-Py uses big-endian.\nexport default function timestamp(): Uint8ArrayBuffer {\n  let time = Date.now()\n  const bytes = []\n  for (let i = 0; i < 8; i++) {\n    const byte = time & 0xff\n    bytes.push(byte)\n    time = (time - byte) / 256 // Javascript right shift (>>>) only works on 32 bit integers\n  }\n  return Uint8Array.from(bytes).reverse()\n}\n\n/**\n * Returns the current time in seconds\n */\nexport function nowInSeconds() {\n  return Math.floor(Date.now() / 1000)\n}\n\nexport function addSecondsToDate(date: Date, seconds: number) {\n  return new Date(date.getTime() + seconds * 1000)\n}\n\nexport function dateToSeconds(date: Date) {\n  return Math.floor(date.getTime() / 1000)\n}\n"],"mappings":";;;AAIA,SAAwB,YAA8B;CACpD,IAAI,OAAO,KAAK,KAAK;CACrB,MAAM,QAAQ,EAAE;AAChB,MAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;EAC1B,MAAM,OAAO,OAAO;AACpB,QAAM,KAAK,KAAK;AAChB,UAAQ,OAAO,QAAQ;;AAEzB,QAAO,WAAW,KAAK,MAAM,CAAC,SAAS;;;;;AAMzC,SAAgB,eAAe;AAC7B,QAAO,KAAK,MAAM,KAAK,KAAK,GAAG,IAAK;;AAGtC,SAAgB,iBAAiB,MAAY,SAAiB;AAC5D,QAAO,IAAI,KAAK,KAAK,SAAS,GAAG,UAAU,IAAK;;AAGlD,SAAgB,cAAc,MAAY;AACxC,QAAO,KAAK,MAAM,KAAK,SAAS,GAAG,IAAK"}

package/build/utils/transformers.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.mts","names":[],"sources":["../../src/utils/transformers.ts"],"sourcesContent":[],"mappings":";;;;;;AA6BgB,iBAAA,eAAA,CAAA,CAAe,EAAA,iBAAA;;;;iBAoCf,qBAAA,qBAA0C,KAAK,6BAA6B"}
+{"version":3,"file":"transformers.d.mts","names":[],"sources":["../../src/utils/transformers.ts"],"sourcesContent":[],"mappings":";;;;;;AA4BgB,iBAAA,eAAA,CAAA,CAAe,EAAA,iBAAA;;;;iBAoCf,qBAAA,qBAA0C,KAAK,6BAA6B"}

package/build/utils/transformers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/utils/transformers.ts"],"sourcesContent":[],"mappings":";;;;;AA6BA;AAoCA;AAAqC,iBApCrB,eAAA,CAAA,CAoCqB,EApCN,iBAoCM;;;;iBAArB,qBAAA,qBAA0C,KAAK,6BAA6B"}
+{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/utils/transformers.ts"],"sourcesContent":[],"mappings":";;;;;AA4BA;AAoCA;AAAqC,iBApCrB,eAAA,CAAA,CAoCqB,EApCN,iBAoCM;;;;iBAArB,qBAAA,qBAA0C,KAAK,6BAA6B"}