@layerzerolabs/common-encoding-utils 0.2.90 → 0.2.91

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "@layerzerolabs/common-encoding-utils",
-  "version": "0.2.90",
+  "version": "0.2.91",
   "private": false,
   "license": "MIT",
   "type": "module",
   "exports": {
     "types": "./dist/index.d.ts",
-    "require": "./dist/index.cjs",
     "import": "./dist/index.js",
-    "default": "./dist/index.cjs"
+    "default": "./dist/index.js"
   },
-  "main": "./dist/index.cjs",
+  "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -19,8 +18,8 @@
   "devDependencies": {
     "tsup": "^8.4.0",
     "vitest": "^3.2.3",
-    "@layerzerolabs/tsup-configuration": "0.2.90",
-    "@layerzerolabs/typescript-configuration": "0.2.90"
+    "@layerzerolabs/tsup-configuration": "0.2.91",
+    "@layerzerolabs/typescript-configuration": "0.2.91"
   },
   "publishConfig": {
     "access": "public",
@@ -28,6 +27,7 @@
   },
   "externalRepoConfig": {
     "targets": [
+      "console-pen-test",
       "onesig-client"
     ]
   },

package/dist/DSXMRHUH.cjs

@@ -1,222 +0,0 @@
-'use strict';
-
-var YJF4D23A_cjs = require('./YJF4D23A.cjs');
-
-// src/byte-codec.ts
-function uMax(bits) {
-  if (!Number.isInteger(bits) || bits < 0) {
-    throw new RangeError(`ByteCodec: invalid bit width: ${bits}`);
-  }
-  return bits === 0 ? 0n : (1n << BigInt(bits)) - 1n;
-}
-YJF4D23A_cjs.__name(uMax, "uMax");
-var ByteCodec = class _ByteCodec {
-  static {
-    YJF4D23A_cjs.__name(this, "ByteCodec");
-  }
-  // Start with a small-ish initial capacity to avoid frequent reallocations for
-  // common short payloads (e.g. function selector + a few fixed-width fields),
-  // while still staying tiny in memory terms. Buffer grows by doubling as needed.
-  #buf = new ArrayBuffer(128);
-  #view = new DataView(this.#buf);
-  #cursor = 0;
-  static #ZERO = 0n;
-  static #U8_MAX = uMax(8);
-  static #U16_MAX = uMax(16);
-  static #U32_MAX = uMax(32);
-  static #U64_MAX = uMax(64);
-  static #U128_MAX = uMax(128);
-  static #U256_MAX = uMax(256);
-  static #outOfRange(targetLength, value) {
-    return new RangeError(`ByteCodec: value out of range for u${targetLength * 8}: ${value}`);
-  }
-  /**
-   * Read helpers (big-endian). These are intentionally small/low-level so other
-   * packages can share a single implementation for parsing encoded payloads.
-   */
-  static readU16be(buf, offset) {
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    return view.getUint16(offset, false);
-  }
-  static readU8(buf, offset) {
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    return view.getUint8(offset);
-  }
-  static readU32be(buf, offset) {
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    return view.getUint32(offset, false);
-  }
-  static readU128be(buf, offset) {
-    return _ByteCodec.readUNbe(buf, offset, 16);
-  }
-  static readUNbe(buf, offset, length) {
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    let out = 0n;
-    const end = offset + length;
-    let cursor = offset;
-    while (cursor + 8 <= end) {
-      out = out << 64n | view.getBigUint64(cursor, false);
-      cursor += 8;
-    }
-    while (cursor < end) {
-      out = out << 8n | BigInt(view.getUint8(cursor));
-      cursor += 1;
-    }
-    return out;
-  }
-  static readBytes32(buf, offset) {
-    if (offset + 32 > buf.length) throw new RangeError(`ByteCodec: out of bounds at ${offset}`);
-    return buf.slice(offset, offset + 32);
-  }
-  /**
-   * Left-pad `bytes` to `targetLength` using `padByte` (default 0x00).
-   *
-   * Commonly used to mimic Solidity's `bytes32(bytesN)`-style left zero padding.
-   */
-  static leftPad(bytes, targetLength, padByte = 0) {
-    if (!Number.isInteger(targetLength) || targetLength < 0) {
-      throw new RangeError(`ByteCodec: invalid length: target=${targetLength}`);
-    }
-    if (!Number.isInteger(padByte) || padByte < 0 || padByte > 255) {
-      throw new RangeError(`ByteCodec: invalid pad byte: ${padByte}`);
-    }
-    if (bytes.length > targetLength) {
-      throw new RangeError(`ByteCodec: bytes length ${bytes.length} exceeds target ${targetLength}`);
-    }
-    const out = new Uint8Array(targetLength);
-    if (padByte !== 0) out.fill(padByte);
-    out.set(bytes, targetLength - bytes.length);
-    return out;
-  }
-  /**
-   * Cast an unsigned big-endian integer in `bytes` into a fixed-width uint (by bytes),
-   * reverting on overflow.
-   *
-   * This mirrors Solidity-style safe casts like `SafeCast.toUint128(uint256)`:
-   * - if `bytes.length > targetLength`, the high (bytes.length - targetLength) bytes must be all zero
-   * - returns the low `targetLength` bytes as the result
-   *
-   * Examples:
-   * - cast bytes32 -> u128: castUNbe(bytes32, 16)
-   * - cast bytesN -> u64:   castUNbe(bytesN, 8)
-   */
-  static castUNbe(bytes, targetLength) {
-    if (!Number.isInteger(targetLength) || targetLength < 0) {
-      throw new RangeError(`ByteCodec: invalid length: target=${targetLength}`);
-    }
-    const len = bytes.length;
-    if (len <= targetLength) return _ByteCodec.readUNbe(bytes, 0, len);
-    const excess = len - targetLength;
-    for (let i = 0; i < excess; i++) {
-      if (bytes[i] !== 0) throw _ByteCodec.#outOfRange(targetLength, _ByteCodec.readUNbe(bytes, 0, len));
-    }
-    return _ByteCodec.readUNbe(bytes, excess, targetLength);
-  }
-  static castU8be(bytes) {
-    return _ByteCodec.castUNbe(bytes, 1);
-  }
-  static castU16be(bytes) {
-    return _ByteCodec.castUNbe(bytes, 2);
-  }
-  static castU32be(bytes) {
-    return _ByteCodec.castUNbe(bytes, 4);
-  }
-  static castU64be(bytes) {
-    return _ByteCodec.castUNbe(bytes, 8);
-  }
-  static castU128be(bytes) {
-    return _ByteCodec.castUNbe(bytes, 16);
-  }
-  ensureCapacity(additionalBytes) {
-    const needed = this.#cursor + additionalBytes;
-    if (needed <= this.#buf.byteLength) return;
-    let nextCap = this.#buf.byteLength;
-    while (nextCap < needed) nextCap *= 2;
-    const next = new ArrayBuffer(nextCap);
-    new Uint8Array(next).set(new Uint8Array(this.#buf, 0, this.#cursor));
-    this.#buf = next;
-    this.#view = new DataView(this.#buf);
-  }
-  bytes(b) {
-    this.ensureCapacity(b.length);
-    new Uint8Array(this.#buf, this.#cursor, b.length).set(b);
-    this.#cursor += b.length;
-    return this;
-  }
-  bytes32(b) {
-    return this.bytes(_ByteCodec.leftPad(b, 32));
-  }
-  bool(b) {
-    return this.u8(b ? 1n : _ByteCodec.#ZERO);
-  }
-  u8(v) {
-    if (v < _ByteCodec.#ZERO || v > _ByteCodec.#U8_MAX) throw new RangeError(`ByteCodec: value out of range for u8: ${v}`);
-    this.ensureCapacity(1);
-    this.#view.setUint8(this.#cursor, Number(v));
-    this.#cursor += 1;
-    return this;
-  }
-  u16be(v) {
-    if (v < _ByteCodec.#ZERO || v > _ByteCodec.#U16_MAX) throw new RangeError(`ByteCodec: value out of range for u16: ${v}`);
-    this.ensureCapacity(2);
-    this.#view.setUint16(this.#cursor, Number(v), false);
-    this.#cursor += 2;
-    return this;
-  }
-  u32be(v) {
-    if (v < _ByteCodec.#ZERO || v > _ByteCodec.#U32_MAX) {
-      throw new RangeError(`ByteCodec: value out of range for u32: ${v}`);
-    }
-    this.ensureCapacity(4);
-    this.#view.setUint32(this.#cursor, Number(v), false);
-    this.#cursor += 4;
-    return this;
-  }
-  u64be(v) {
-    if (v < _ByteCodec.#ZERO || v > _ByteCodec.#U64_MAX) {
-      throw new RangeError(`ByteCodec: value out of range for u64: ${v}`);
-    }
-    this.ensureCapacity(8);
-    this.#view.setBigUint64(this.#cursor, v, false);
-    this.#cursor += 8;
-    return this;
-  }
-  u128be(v) {
-    if (v < _ByteCodec.#ZERO || v > _ByteCodec.#U128_MAX) {
-      throw new RangeError(`ByteCodec: value out of range for u128: ${v}`);
-    }
-    this.ensureCapacity(16);
-    const hi = v >> 64n & _ByteCodec.#U64_MAX;
-    const lo = v & _ByteCodec.#U64_MAX;
-    this.#view.setBigUint64(this.#cursor, hi, false);
-    this.#view.setBigUint64(this.#cursor + 8, lo, false);
-    this.#cursor += 16;
-    return this;
-  }
-  u256be(v) {
-    if (v < _ByteCodec.#ZERO || v > _ByteCodec.#U256_MAX) {
-      throw new RangeError(`ByteCodec: value out of range for u256: ${v}`);
-    }
-    this.ensureCapacity(32);
-    const w0 = v >> 192n & _ByteCodec.#U64_MAX;
-    const w1 = v >> 128n & _ByteCodec.#U64_MAX;
-    const w2 = v >> 64n & _ByteCodec.#U64_MAX;
-    const w3 = v & _ByteCodec.#U64_MAX;
-    this.#view.setBigUint64(this.#cursor, w0, false);
-    this.#view.setBigUint64(this.#cursor + 8, w1, false);
-    this.#view.setBigUint64(this.#cursor + 16, w2, false);
-    this.#view.setBigUint64(this.#cursor + 24, w3, false);
-    this.#cursor += 32;
-    return this;
-  }
-  /**
-   * Returns a copy of the accumulated bytes (no shared backing buffer).
-   */
-  toBytes() {
-    return new Uint8Array(this.#buf, 0, this.#cursor).slice();
-  }
-};
-
-exports.ByteCodec = ByteCodec;
-//# sourceMappingURL=DSXMRHUH.cjs.map
-//# sourceMappingURL=DSXMRHUH.cjs.map

package/dist/DSXMRHUH.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/byte-codec.ts"],"names":["uMax","bits","Number","isInteger","RangeError","BigInt","ByteCodec","ArrayBuffer","DataView","targetLength","value","readU16be","buf","offset","view","buffer","byteOffset","byteLength","getUint16","readU8","getUint8","readU32be","getUint32","readU128be","readUNbe","length","out","end","cursor","getBigUint64","readBytes32","slice","leftPad","bytes","padByte","Uint8Array","fill","set","castUNbe","len","excess","i","castU8be","castU16be","castU32be","castU64be","castU128be","ensureCapacity","additionalBytes","needed","nextCap","next","b","bytes32","bool","u8","v","setUint8","u16be","setUint16","u32be","setUint32","u64be","setBigUint64","u128be","hi","lo","u256be","w0","w1","w2","w3","toBytes"],"mappings":"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","file":"DSXMRHUH.cjs","sourcesContent":["/**\n * Growable byte codec backed by `ArrayBuffer` + `DataView`.\n *\n * Low-level building block for constructing byte payloads deterministically.\n * Higher-level concerns (e.g. hashing, ABI encoding, function signatures) should\n * live in wrappers/subclasses.\n */\n\nfunction uMax(bits: number): bigint {\n    if (!Number.isInteger(bits) || bits < 0) {\n        throw new RangeError(`ByteCodec: invalid bit width: ${bits}`);\n    }\n    // (2^bits) - 1, as bigint\n    return bits === 0 ? 0n : (1n << BigInt(bits)) - 1n;\n}\n\n// TODO: add tests for this class — currently has zero test coverage\nexport class ByteCodec {\n    // Start with a small-ish initial capacity to avoid frequent reallocations for\n    // common short payloads (e.g. function selector + a few fixed-width fields),\n    // while still staying tiny in memory terms. Buffer grows by doubling as needed.\n    #buf = new ArrayBuffer(128);\n    #view = new DataView(this.#buf);\n    #cursor = 0;\n\n    static readonly #ZERO = 0n;\n    static readonly #U8_MAX = uMax(8);\n    static readonly #U16_MAX = uMax(16);\n    static readonly #U32_MAX = uMax(32);\n    static readonly #U64_MAX = uMax(64);\n    static readonly #U128_MAX = uMax(128);\n    static readonly #U256_MAX = uMax(256);\n\n    static #outOfRange(targetLength: number, value: bigint): RangeError {\n        return new RangeError(`ByteCodec: value out of range for u${targetLength * 8}: ${value}`);\n    }\n\n    /**\n     * Read helpers (big-endian). These are intentionally small/low-level so other\n     * packages can share a single implementation for parsing encoded payloads.\n     */\n    static readU16be(buf: Uint8Array, offset: number): number {\n        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);\n        return view.getUint16(offset, false);\n    }\n\n    static readU8(buf: Uint8Array, offset: number): number {\n        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);\n        return view.getUint8(offset);\n    }\n\n    static readU32be(buf: Uint8Array, offset: number): number {\n        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);\n        return view.getUint32(offset, false);\n    }\n\n    static readU128be(buf: Uint8Array, offset: number): bigint {\n        return ByteCodec.readUNbe(buf, offset, 16);\n    }\n\n    static readUNbe(buf: Uint8Array, offset: number, length: number): bigint {\n        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);\n\n        let out = 0n;\n        const end = offset + length;\n\n        // Fast path: read 8 bytes at a time\n        let cursor = offset;\n        while (cursor + 8 <= end) {\n            out = (out << 64n) | view.getBigUint64(cursor, false);\n            cursor += 8;\n        }\n\n        // Tail: 0..7 bytes\n        while (cursor < end) {\n            out = (out << 8n) | BigInt(view.getUint8(cursor));\n            cursor += 1;\n        }\n\n        return out;\n    }\n\n    static readBytes32(buf: Uint8Array, offset: number): Uint8Array {\n        if (offset + 32 > buf.length) throw new RangeError(`ByteCodec: out of bounds at ${offset}`);\n        return buf.slice(offset, offset + 32);\n    }\n\n    /**\n     * Left-pad `bytes` to `targetLength` using `padByte` (default 0x00).\n     *\n     * Commonly used to mimic Solidity's `bytes32(bytesN)`-style left zero padding.\n     */\n    static leftPad(bytes: Uint8Array, targetLength: number, padByte = 0): Uint8Array {\n        if (!Number.isInteger(targetLength) || targetLength < 0) {\n            throw new RangeError(`ByteCodec: invalid length: target=${targetLength}`);\n        }\n        if (!Number.isInteger(padByte) || padByte < 0 || padByte > 255) {\n            throw new RangeError(`ByteCodec: invalid pad byte: ${padByte}`);\n        }\n        if (bytes.length > targetLength) {\n            throw new RangeError(\n                `ByteCodec: bytes length ${bytes.length} exceeds target ${targetLength}`,\n            );\n        }\n\n        const out = new Uint8Array(targetLength);\n        if (padByte !== 0) out.fill(padByte);\n        out.set(bytes, targetLength - bytes.length);\n        return out;\n    }\n\n    /**\n     * Cast an unsigned big-endian integer in `bytes` into a fixed-width uint (by bytes),\n     * reverting on overflow.\n     *\n     * This mirrors Solidity-style safe casts like `SafeCast.toUint128(uint256)`:\n     * - if `bytes.length > targetLength`, the high (bytes.length - targetLength) bytes must be all zero\n     * - returns the low `targetLength` bytes as the result\n     *\n     * Examples:\n     * - cast bytes32 -> u128: castUNbe(bytes32, 16)\n     * - cast bytesN -> u64:   castUNbe(bytesN, 8)\n     */\n    static castUNbe(bytes: Uint8Array, targetLength: number): bigint {\n        if (!Number.isInteger(targetLength) || targetLength < 0) {\n            throw new RangeError(`ByteCodec: invalid length: target=${targetLength}`);\n        }\n\n        const len = bytes.length;\n        if (len <= targetLength) return ByteCodec.readUNbe(bytes, 0, len);\n\n        // Overflow check: any excess high bytes must be 0x00.\n        const excess = len - targetLength;\n        for (let i = 0; i < excess; i++) {\n            if (bytes[i] !== 0)\n                throw ByteCodec.#outOfRange(targetLength, ByteCodec.readUNbe(bytes, 0, len));\n        }\n\n        return ByteCodec.readUNbe(bytes, excess, targetLength);\n    }\n\n    static castU8be(bytes: Uint8Array): bigint {\n        return ByteCodec.castUNbe(bytes, 1);\n    }\n\n    static castU16be(bytes: Uint8Array): bigint {\n        return ByteCodec.castUNbe(bytes, 2);\n    }\n\n    static castU32be(bytes: Uint8Array): bigint {\n        return ByteCodec.castUNbe(bytes, 4);\n    }\n\n    static castU64be(bytes: Uint8Array): bigint {\n        return ByteCodec.castUNbe(bytes, 8);\n    }\n\n    static castU128be(bytes: Uint8Array): bigint {\n        return ByteCodec.castUNbe(bytes, 16);\n    }\n\n    protected ensureCapacity(additionalBytes: number): void {\n        const needed = this.#cursor + additionalBytes;\n        if (needed <= this.#buf.byteLength) return;\n\n        let nextCap = this.#buf.byteLength;\n        while (nextCap < needed) nextCap *= 2;\n\n        // Grow by allocating a new ArrayBuffer and copying the written prefix\n        // [0..cursor) into it. We then swap the backing buffer+view.\n        const next = new ArrayBuffer(nextCap);\n        new Uint8Array(next).set(new Uint8Array(this.#buf, 0, this.#cursor));\n        this.#buf = next;\n        this.#view = new DataView(this.#buf);\n    }\n\n    bytes(b: Uint8Array): this {\n        this.ensureCapacity(b.length);\n        new Uint8Array(this.#buf, this.#cursor, b.length).set(b);\n        this.#cursor += b.length;\n        return this;\n    }\n\n    bytes32(b: Uint8Array): this {\n        return this.bytes(ByteCodec.leftPad(b, 32));\n    }\n\n    bool(b: boolean): this {\n        return this.u8(b ? 1n : ByteCodec.#ZERO);\n    }\n\n    u8(v: bigint): this {\n        if (v < ByteCodec.#ZERO || v > ByteCodec.#U8_MAX)\n            throw new RangeError(`ByteCodec: value out of range for u8: ${v}`);\n        this.ensureCapacity(1);\n        this.#view.setUint8(this.#cursor, Number(v));\n        this.#cursor += 1;\n        return this;\n    }\n\n    u16be(v: bigint): this {\n        if (v < ByteCodec.#ZERO || v > ByteCodec.#U16_MAX)\n            throw new RangeError(`ByteCodec: value out of range for u16: ${v}`);\n        this.ensureCapacity(2);\n        this.#view.setUint16(this.#cursor, Number(v), false);\n        this.#cursor += 2;\n        return this;\n    }\n\n    u32be(v: bigint): this {\n        if (v < ByteCodec.#ZERO || v > ByteCodec.#U32_MAX) {\n            throw new RangeError(`ByteCodec: value out of range for u32: ${v}`);\n        }\n        this.ensureCapacity(4);\n        this.#view.setUint32(this.#cursor, Number(v), false);\n        this.#cursor += 4;\n        return this;\n    }\n\n    u64be(v: bigint): this {\n        if (v < ByteCodec.#ZERO || v > ByteCodec.#U64_MAX) {\n            throw new RangeError(`ByteCodec: value out of range for u64: ${v}`);\n        }\n        this.ensureCapacity(8);\n        this.#view.setBigUint64(this.#cursor, v, false);\n        this.#cursor += 8;\n        return this;\n    }\n\n    u128be(v: bigint): this {\n        if (v < ByteCodec.#ZERO || v > ByteCodec.#U128_MAX) {\n            throw new RangeError(`ByteCodec: value out of range for u128: ${v}`);\n        }\n        this.ensureCapacity(16);\n        const hi = (v >> 64n) & ByteCodec.#U64_MAX;\n        const lo = v & ByteCodec.#U64_MAX;\n        this.#view.setBigUint64(this.#cursor, hi, false);\n        this.#view.setBigUint64(this.#cursor + 8, lo, false);\n        this.#cursor += 16;\n        return this;\n    }\n\n    u256be(v: bigint): this {\n        if (v < ByteCodec.#ZERO || v > ByteCodec.#U256_MAX) {\n            throw new RangeError(`ByteCodec: value out of range for u256: ${v}`);\n        }\n        this.ensureCapacity(32);\n        const w0 = (v >> 192n) & ByteCodec.#U64_MAX;\n        const w1 = (v >> 128n) & ByteCodec.#U64_MAX;\n        const w2 = (v >> 64n) & ByteCodec.#U64_MAX;\n        const w3 = v & ByteCodec.#U64_MAX;\n        this.#view.setBigUint64(this.#cursor, w0, false);\n        this.#view.setBigUint64(this.#cursor + 8, w1, false);\n        this.#view.setBigUint64(this.#cursor + 16, w2, false);\n        this.#view.setBigUint64(this.#cursor + 24, w3, false);\n        this.#cursor += 32;\n        return this;\n    }\n    /**\n     * Returns a copy of the accumulated bytes (no shared backing buffer).\n     */\n    toBytes(): Uint8Array {\n        return new Uint8Array(this.#buf, 0, this.#cursor).slice();\n    }\n}\n"]}

package/dist/IDXW633A.cjs

@@ -1,32 +0,0 @@
-'use strict';
-
-var YJF4D23A_cjs = require('./YJF4D23A.cjs');
-
-// src/uuid.ts
-var UUID_BYTE_LENGTH = 16;
-var prepareUuidBytes = /* @__PURE__ */ YJF4D23A_cjs.__name((bytes) => {
-  if (bytes.length === 0) {
-    throw new Error("uuid bytes must not be empty");
-  }
-  if (bytes.length === UUID_BYTE_LENGTH) {
-    return new Uint8Array(bytes);
-  }
-  if (bytes.length > UUID_BYTE_LENGTH) {
-    return Uint8Array.from(bytes.subarray(0, UUID_BYTE_LENGTH));
-  }
-  const padded = new Uint8Array(UUID_BYTE_LENGTH);
-  padded.set(bytes);
-  return padded;
-}, "prepareUuidBytes");
-var formatUuidFrom16Bytes = /* @__PURE__ */ YJF4D23A_cjs.__name((working, version) => {
-  const versionBits = version === 4 ? 64 : 80;
-  working[6] = working[6] & 15 | versionBits;
-  working[8] = working[8] & 63 | 128;
-  const hex = Array.from(working, (b) => b.toString(16).padStart(2, "0"));
-  return hex.slice(0, 4).join("") + "-" + hex.slice(4, 6).join("") + "-" + hex.slice(6, 8).join("") + "-" + hex.slice(8, 10).join("") + "-" + hex.slice(10, 16).join("");
-}, "formatUuidFrom16Bytes");
-var uuidFromBytes = /* @__PURE__ */ YJF4D23A_cjs.__name((bytes, version = 4) => formatUuidFrom16Bytes(prepareUuidBytes(bytes), version), "uuidFromBytes");
-
-exports.uuidFromBytes = uuidFromBytes;
-//# sourceMappingURL=IDXW633A.cjs.map
-//# sourceMappingURL=IDXW633A.cjs.map

package/dist/IDXW633A.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/uuid.ts"],"names":["UUID_BYTE_LENGTH","prepareUuidBytes","bytes","length","Error","Uint8Array","from","subarray","padded","set","formatUuidFrom16Bytes","__name","working","version","versionBits","hex","Array","b","toString","padStart","slice","join","uuidFromBytes"],"mappings":";;;;;AAAA,IAAMA,gBAAAA,GAAmB,EAAA;AAIzB,IAAMC,gBAAAA,wCAAoBC,KAAAA,KAAAA;AACtB,EAAA,IAAIA,KAAAA,CAAMC,WAAW,CAAA,EAAG;AACpB,IAAA,MAAM,IAAIC,MAAM,8BAAA,CAAA;AACpB,EAAA;AAEA,EAAA,IAAIF,KAAAA,CAAMC,WAAWH,gBAAAA,EAAkB;AACnC,IAAA,OAAO,IAAIK,WAAWH,KAAAA,CAAAA;AAC1B,EAAA;AAEA,EAAA,IAAIA,KAAAA,CAAMC,SAASH,gBAAAA,EAAkB;AACjC,IAAA,OAAOK,WAAWC,IAAAA,CAAKJ,KAAAA,CAAMK,QAAAA,CAAS,CAAA,EAAGP,gBAAAA,CAAAA,CAAAA;AAC7C,EAAA;AAEA,EAAA,MAAMQ,MAAAA,GAAS,IAAIH,UAAAA,CAAWL,gBAAAA,CAAAA;AAC9BQ,EAAAA,MAAAA,CAAOC,IAAIP,KAAAA,CAAAA;AACX,EAAA,OAAOM,MAAAA;AACX,CAAA,EAhByB,kBAAA,CAAA;AAkBzB,IAAME,qBAAAA,mBAAwBC,mBAAA,CAAA,CAACC,OAAAA,EAAqBC,OAAAA,KAAAA;AAChD,EAAA,MAAMC,WAAAA,GAAcD,OAAAA,KAAY,CAAA,GAAI,EAAA,GAAO,EAAA;AAE3CD,EAAAA,OAAAA,CAAQ,CAAA,CAAA,GAAMA,OAAAA,CAAQ,CAAA,IAAM,EAAA,GAAQE,WAAAA;AACpCF,EAAAA,OAAAA,CAAQ,CAAA,CAAA,GAAMA,OAAAA,CAAQ,CAAA,IAAM,EAAA,GAAQ,GAAA;AAEpC,EAAA,MAAMG,GAAAA,GAAMC,KAAAA,CAAMV,IAAAA,CAAKM,OAAAA,EAAS,CAACK,CAAAA,KAAMA,CAAAA,CAAEC,QAAAA,CAAS,EAAA,CAAA,CAAIC,QAAAA,CAAS,CAAA,EAAG,GAAA,CAAA,CAAA;AAClE,EAAA,OACIJ,IAAIK,KAAAA,CAAM,CAAA,EAAG,CAAA,CAAA,CAAGC,IAAAA,CAAK,EAAA,CAAA,GACrB,GAAA,GACAN,IAAIK,KAAAA,CAAM,CAAA,EAAG,CAAA,CAAA,CAAGC,IAAAA,CAAK,EAAA,CAAA,GACrB,GAAA,GACAN,IAAIK,KAAAA,CAAM,CAAA,EAAG,CAAA,CAAA,CAAGC,KAAK,EAAA,CAAA,GACrB,MACAN,GAAAA,CAAIK,KAAAA,CAAM,GAAG,EAAA,CAAA,CAAIC,KAAK,EAAA,CAAA,GACtB,MACAN,GAAAA,CAAIK,KAAAA,CAAM,IAAI,EAAA,CAAA,CAAIC,KAAK,EAAA,CAAA;AAE/B,CAAA,EAlB8B,uBAAA,CAAA;AAyBvB,IAAMC,aAAAA,mBAAgBX,mBAAA,CAAA,CAACT,KAAAA,EAAmBW,OAAAA,GAAuB,CAAA,KACpEH,sBAAsBT,gBAAAA,CAAiBC,KAAAA,CAAAA,EAAQW,OAAAA,CAAAA,EADtB,eAAA","file":"IDXW633A.cjs","sourcesContent":["const UUID_BYTE_LENGTH = 16;\n\nexport type UuidVersion = 4 | 5;\n\nconst prepareUuidBytes = (bytes: Uint8Array): Uint8Array => {\n    if (bytes.length === 0) {\n        throw new Error('uuid bytes must not be empty');\n    }\n\n    if (bytes.length === UUID_BYTE_LENGTH) {\n        return new Uint8Array(bytes);\n    }\n\n    if (bytes.length > UUID_BYTE_LENGTH) {\n        return Uint8Array.from(bytes.subarray(0, UUID_BYTE_LENGTH));\n    }\n\n    const padded = new Uint8Array(UUID_BYTE_LENGTH);\n    padded.set(bytes);\n    return padded;\n};\n\nconst formatUuidFrom16Bytes = (working: Uint8Array, version: UuidVersion): string => {\n    const versionBits = version === 4 ? 0x40 : 0x50;\n    // Set version (4 or 5) and variant (10xx)\n    working[6] = (working[6]! & 0x0f) | versionBits;\n    working[8] = (working[8]! & 0x3f) | 0x80;\n\n    const hex = Array.from(working, (b) => b.toString(16).padStart(2, '0'));\n    return (\n        hex.slice(0, 4).join('') +\n        '-' +\n        hex.slice(4, 6).join('') +\n        '-' +\n        hex.slice(6, 8).join('') +\n        '-' +\n        hex.slice(8, 10).join('') +\n        '-' +\n        hex.slice(10, 16).join('')\n    );\n};\n\n/**\n * Converts bytes into an RFC 4122 UUID string. Inputs longer than 16 bytes use\n * the first 16; shorter inputs are zero-padded on the right. Empty input throws.\n * Default `version` is 4 (UUID v4); pass `5` for name-based hashes, etc.\n */\nexport const uuidFromBytes = (bytes: Uint8Array, version: UuidVersion = 4): string =>\n    formatUuidFrom16Bytes(prepareUuidBytes(bytes), version);\n"]}

package/dist/YJF4D23A.cjs

@@ -1,8 +0,0 @@
-'use strict';
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-exports.__name = __name;
-//# sourceMappingURL=YJF4D23A.cjs.map
-//# sourceMappingURL=YJF4D23A.cjs.map

package/dist/YJF4D23A.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"YJF4D23A.cjs"}

package/dist/byte-codec.cjs

@@ -1,13 +0,0 @@
-'use strict';
-
-var DSXMRHUH_cjs = require('./DSXMRHUH.cjs');
-require('./YJF4D23A.cjs');
-
-
-
-Object.defineProperty(exports, "ByteCodec", {
-  enumerable: true,
-  get: function () { return DSXMRHUH_cjs.ByteCodec; }
-});
-//# sourceMappingURL=byte-codec.cjs.map
-//# sourceMappingURL=byte-codec.cjs.map

package/dist/byte-codec.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"byte-codec.cjs"}

package/dist/index.cjs

@@ -1,178 +0,0 @@
-'use strict';
-
-var DSXMRHUH_cjs = require('./DSXMRHUH.cjs');
-var IDXW633A_cjs = require('./IDXW633A.cjs');
-var YJF4D23A_cjs = require('./YJF4D23A.cjs');
-
-// src/index.ts
-var base58regex = /^[A-HJ-NP-Za-km-z1-9]*$/;
-var base64regex = /^[A-Za-z0-9+/]*={0,2}$/;
-var hexStringRegex = /^(0x)?[0-9A-Fa-f]*$/;
-function isBase58(address) {
-  return base58regex.test(address);
-}
-YJF4D23A_cjs.__name(isBase58, "isBase58");
-function isBase64(address) {
-  return base64regex.test(address);
-}
-YJF4D23A_cjs.__name(isBase64, "isBase64");
-function isHexString(value, length) {
-  if (typeof value !== "string" || !value.match(hexStringRegex)) {
-    return false;
-  }
-  if (length && value.length !== 2 + 2 * length) {
-    return false;
-  }
-  return true;
-}
-YJF4D23A_cjs.__name(isHexString, "isHexString");
-function hexZeroPad(value, length) {
-  if (!isHexString(value)) {
-    throw new Error(`invalid hex string: ${value}`);
-  }
-  if (value.length > 2 * length + 2) {
-    throw new Error("value out of range");
-  }
-  return `0x${trim0x(value).padStart(2 * length, "0")}`;
-}
-YJF4D23A_cjs.__name(hexZeroPad, "hexZeroPad");
-function trim0x(str) {
-  return str.replace(/^0x/, "");
-}
-YJF4D23A_cjs.__name(trim0x, "trim0x");
-function ensure0xPrefixed(str) {
-  return `0x${trim0x(str)}`;
-}
-YJF4D23A_cjs.__name(ensure0xPrefixed, "ensure0xPrefixed");
-function trimLeadingZeros(hexString) {
-  let withoutPrefix = trim0x(hexString);
-  withoutPrefix = withoutPrefix.replace(/^0+/, "");
-  return ensure0xPrefixed(withoutPrefix);
-}
-YJF4D23A_cjs.__name(trimLeadingZeros, "trimLeadingZeros");
-function hexToUint8Array(hexString) {
-  return Uint8Array.from(Buffer.from(trim0x(hexString), "hex"));
-}
-YJF4D23A_cjs.__name(hexToUint8Array, "hexToUint8Array");
-function hexToAscii(hex) {
-  if (!isHexString(hex)) {
-    throw new Error(`Invalid hex string ${hex}`);
-  }
-  let str = "";
-  let i = 0;
-  const l = hex.length;
-  if (hex.startsWith("0x")) {
-    i = 2;
-  }
-  for (; i < l; i += 2) {
-    const code = parseInt(hex.slice(i, i + 2), 16);
-    str += String.fromCharCode(code);
-  }
-  return str;
-}
-YJF4D23A_cjs.__name(hexToAscii, "hexToAscii");
-function stringToUint8Array(str) {
-  const value = str.replace(/^0x/i, "");
-  const len = value.length + 1 - (value.length + 1) % 2;
-  return Uint8Array.from(Buffer.from(value.padStart(len, "0"), "hex"));
-}
-YJF4D23A_cjs.__name(stringToUint8Array, "stringToUint8Array");
-function hexToBytes(hex) {
-  const value = hex.replace(/^0x/i, "");
-  const len = value.length + 1 - (value.length + 1) % 2;
-  return Uint8Array.from(Buffer.from(value.padStart(len, "0"), "hex"));
-}
-YJF4D23A_cjs.__name(hexToBytes, "hexToBytes");
-function bytesToHex(bytes) {
-  return Buffer.from(bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes).toString("hex");
-}
-YJF4D23A_cjs.__name(bytesToHex, "bytesToHex");
-function bytesToHexPrefixed(bytes) {
-  return ensure0xPrefixed(bytesToHex(bytes));
-}
-YJF4D23A_cjs.__name(bytesToHexPrefixed, "bytesToHexPrefixed");
-function bytesToBase64(bytes) {
-  return Buffer.from(bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes).toString("base64");
-}
-YJF4D23A_cjs.__name(bytesToBase64, "bytesToBase64");
-function base64ToBytes(base64) {
-  return Uint8Array.from(Buffer.from(base64, "base64"));
-}
-YJF4D23A_cjs.__name(base64ToBytes, "base64ToBytes");
-function hexToBase64(hexString) {
-  const hex = trim0x(hexString);
-  if (!/^[0-9a-fA-F]+$/.test(hex)) {
-    throw new Error(`Invalid hex string: ${hexString}`);
-  }
-  if (hex.length % 2 !== 0) {
-    throw new Error("Hex string must have an even length");
-  }
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-  }
-  const base64String = Buffer.from(bytes).toString("base64");
-  return base64String;
-}
-YJF4D23A_cjs.__name(hexToBase64, "hexToBase64");
-function base64ToHex(base64String) {
-  if (!/^[A-Za-z0-9+/=]*$/.test(base64String)) {
-    throw new Error(`Invalid base64 string: ${base64String}`);
-  }
-  return `0x${Buffer.from(base64String, "base64").toString("hex")}`;
-}
-YJF4D23A_cjs.__name(base64ToHex, "base64ToHex");
-function padString(str, length, left, padding = "0") {
-  const diff = length - str.length;
-  let result = str;
-  if (diff > 0) {
-    const pad = padding.repeat(diff);
-    result = left ? pad + str : str + pad;
-  }
-  return result;
-}
-YJF4D23A_cjs.__name(padString, "padString");
-function padLeft(str, length, padding = "0") {
-  return padString(str, length, true, padding);
-}
-YJF4D23A_cjs.__name(padLeft, "padLeft");
-function calcByteLength(str, byteSize = 8) {
-  const { length } = str;
-  const remainder = length % byteSize;
-  return remainder ? (length - remainder) / byteSize * byteSize + byteSize : length;
-}
-YJF4D23A_cjs.__name(calcByteLength, "calcByteLength");
-function padAlignHex(str, byteSize = 8, padding = "0") {
-  const trimmed = trim0x(str);
-  return padLeft(trimmed, calcByteLength(trimmed, byteSize), padding);
-}
-YJF4D23A_cjs.__name(padAlignHex, "padAlignHex");
-
-Object.defineProperty(exports, "ByteCodec", {
-  enumerable: true,
-  get: function () { return DSXMRHUH_cjs.ByteCodec; }
-});
-Object.defineProperty(exports, "uuidFromBytes", {
-  enumerable: true,
-  get: function () { return IDXW633A_cjs.uuidFromBytes; }
-});
-exports.base64ToBytes = base64ToBytes;
-exports.base64ToHex = base64ToHex;
-exports.bytesToBase64 = bytesToBase64;
-exports.bytesToHex = bytesToHex;
-exports.bytesToHexPrefixed = bytesToHexPrefixed;
-exports.ensure0xPrefixed = ensure0xPrefixed;
-exports.hexToAscii = hexToAscii;
-exports.hexToBase64 = hexToBase64;
-exports.hexToBytes = hexToBytes;
-exports.hexToUint8Array = hexToUint8Array;
-exports.hexZeroPad = hexZeroPad;
-exports.isBase58 = isBase58;
-exports.isBase64 = isBase64;
-exports.isHexString = isHexString;
-exports.padAlignHex = padAlignHex;
-exports.stringToUint8Array = stringToUint8Array;
-exports.trim0x = trim0x;
-exports.trimLeadingZeros = trimLeadingZeros;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"names":["base58regex","base64regex","hexStringRegex","isBase58","address","test","isBase64","isHexString","value","length","match","hexZeroPad","Error","trim0x","padStart","str","replace","ensure0xPrefixed","trimLeadingZeros","hexString","withoutPrefix","hexToUint8Array","Uint8Array","from","Buffer","hexToAscii","hex","i","l","startsWith","code","parseInt","slice","String","fromCharCode","stringToUint8Array","len","hexToBytes","bytesToHex","bytes","ArrayBuffer","toString","bytesToHexPrefixed","bytesToBase64","base64ToBytes","base64","hexToBase64","substr","base64String","base64ToHex","padString","left","padding","diff","result","pad","repeat","padLeft","calcByteLength","byteSize","remainder","padAlignHex","trimmed"],"mappings":"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","file":"index.cjs","sourcesContent":["export * from './byte-codec';\nexport * from './uuid';\n\nexport type HexString = `0x${string}`;\n\nconst base58regex = /^[A-HJ-NP-Za-km-z1-9]*$/;\nconst base64regex = /^[A-Za-z0-9+/]*={0,2}$/;\nconst hexStringRegex = /^(0x)?[0-9A-Fa-f]*$/;\n\nexport function isBase58(address: string): boolean {\n    return base58regex.test(address);\n}\n\nexport function isBase64(address: string): boolean {\n    return base64regex.test(address);\n}\n\nexport function isHexString(value: any, length?: number): value is HexString {\n    if (typeof value !== 'string' || !value.match(hexStringRegex)) {\n        return false;\n    }\n    if (length && value.length !== 2 + 2 * length) {\n        return false;\n    }\n    return true;\n}\n\nexport function hexZeroPad(value: string, length: number): HexString {\n    if (!isHexString(value)) {\n        throw new Error(`invalid hex string: ${value}`);\n    }\n\n    if (value.length > 2 * length + 2) {\n        throw new Error('value out of range');\n    }\n\n    return `0x${trim0x(value).padStart(2 * length, '0')}`;\n}\n\nexport function trim0x(str: string): string {\n    return str.replace(/^0x/, '');\n}\n\nexport function ensure0xPrefixed(str: string): HexString {\n    return `0x${trim0x(str)}`;\n}\n\nexport function trimLeadingZeros(hexString: string): HexString {\n    // Remove the '0x' prefix\n    let withoutPrefix = trim0x(hexString);\n\n    // Trim leading zeros\n    withoutPrefix = withoutPrefix.replace(/^0+/, '');\n\n    // Add back the '0x' prefix\n    return ensure0xPrefixed(withoutPrefix);\n}\n\nexport function hexToUint8Array(hexString: string): Uint8Array {\n    return Uint8Array.from(Buffer.from(trim0x(hexString), 'hex'));\n}\n\nexport function hexToAscii(hex: string): string {\n    if (!isHexString(hex)) {\n        throw new Error(`Invalid hex string ${hex}`);\n    }\n\n    let str = '';\n    let i = 0;\n    const l = hex.length;\n    if (hex.startsWith('0x')) {\n        i = 2;\n    }\n    for (; i < l; i += 2) {\n        const code = parseInt(hex.slice(i, i + 2), 16);\n        str += String.fromCharCode(code);\n    }\n\n    return str;\n}\n\nexport function stringToUint8Array(str: string): Uint8Array {\n    const value = str.replace(/^0x/i, '');\n    const len = value.length + 1 - ((value.length + 1) % 2);\n    return Uint8Array.from(Buffer.from(value.padStart(len, '0'), 'hex'));\n}\n\n/**\n * A function to convert hex string to Uint8Array (not prefixed)\n * @param hex hex string\n * @returns Uint8Array\n */\nexport function hexToBytes(hex: string): Uint8Array {\n    const value = hex.replace(/^0x/i, '');\n    const len = value.length + 1 - ((value.length + 1) % 2);\n    return Uint8Array.from(Buffer.from(value.padStart(len, '0'), 'hex'));\n}\n\nexport function bytesToHex(bytes: Uint8Array | ArrayBuffer): string {\n    return Buffer.from(bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes).toString(\n        'hex',\n    );\n}\n\n/**\n * 0x prefixed hex string from Uint8Array\n * @param bytes\n */\nexport function bytesToHexPrefixed(bytes: Uint8Array | ArrayBuffer): HexString {\n    return ensure0xPrefixed(bytesToHex(bytes));\n}\n\nexport function bytesToBase64(bytes: Uint8Array | ArrayBuffer): string {\n    return Buffer.from(bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes).toString(\n        'base64',\n    );\n}\n\nexport function base64ToBytes(base64: string): Uint8Array {\n    return Uint8Array.from(Buffer.from(base64, 'base64'));\n}\n\nexport function hexToBase64(hexString: string): string {\n    const hex = trim0x(hexString);\n    // Validate that the input is a valid hex string\n    if (!/^[0-9a-fA-F]+$/.test(hex)) {\n        throw new Error(`Invalid hex string: ${hexString}`);\n    }\n\n    // Ensure the hex string has an even length\n    if (hex.length % 2 !== 0) {\n        throw new Error('Hex string must have an even length');\n    }\n\n    // Convert hex string to a byte array\n    const bytes = new Uint8Array(hex.length / 2);\n    for (let i = 0; i < hex.length; i += 2) {\n        bytes[i / 2] = parseInt(hex.substr(i, 2), 16);\n    }\n\n    // Convert the byte array to a base64 string\n    const base64String = Buffer.from(bytes).toString('base64');\n\n    return base64String;\n}\n\nexport function base64ToHex(base64String: string): HexString {\n    if (!/^[A-Za-z0-9+/=]*$/.test(base64String)) {\n        throw new Error(`Invalid base64 string: ${base64String}`);\n    }\n    return `0x${Buffer.from(base64String, 'base64').toString('hex')}`;\n}\n\nfunction padString(str: string, length: number, left: boolean, padding = '0') {\n    const diff = length - str.length;\n    let result = str;\n    if (diff > 0) {\n        const pad = padding.repeat(diff);\n        result = left ? pad + str : str + pad;\n    }\n    return result;\n}\n\nfunction padLeft(str: string, length: number, padding = '0') {\n    return padString(str, length, true, padding);\n}\nfunction calcByteLength(str: string, byteSize = 8) {\n    const { length } = str;\n    const remainder = length % byteSize;\n    return remainder ? ((length - remainder) / byteSize) * byteSize + byteSize : length;\n}\n\n/**\n * Pads a hex string on the left so its length is a multiple of `byteSize`.\n * Used to align hex strings.\n * @param str Hex string.\n * @param byteSize Group size to align to, in hex chars (default: 8).\n * @param padding Left-pad character (default: '0').\n * @returns Hex string left-padded to a multiple of `byteSize`.\n */\nexport function padAlignHex(str: string, byteSize = 8, padding = '0') {\n    const trimmed = trim0x(str);\n    return padLeft(trimmed, calcByteLength(trimmed, byteSize), padding);\n}\n"]}

package/dist/uuid.cjs

@@ -1,13 +0,0 @@
-'use strict';
-
-var IDXW633A_cjs = require('./IDXW633A.cjs');
-require('./YJF4D23A.cjs');
-
-
-
-Object.defineProperty(exports, "uuidFromBytes", {
-  enumerable: true,
-  get: function () { return IDXW633A_cjs.uuidFromBytes; }
-});
-//# sourceMappingURL=uuid.cjs.map
-//# sourceMappingURL=uuid.cjs.map

package/dist/uuid.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"uuid.cjs"}