@metamask-previews/byte-utils 0.0.0-preview-f64052a

package/dist/__fixtures__/numbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numbers.d.ts","sourceRoot":"","sources":["../../src/__fixtures__/numbers.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa;;;;GAmDzB,CAAC"}

package/dist/__fixtures__/numbers.js

@@ -0,0 +1,53 @@
+export const NUMBER_VALUES = [
+    {
+        number: 0,
+        bigint: BigInt(0),
+        hexadecimal: '0x0',
+    },
+    {
+        number: 1,
+        bigint: BigInt(1),
+        hexadecimal: '0x1',
+    },
+    {
+        number: 16,
+        bigint: BigInt(16),
+        hexadecimal: '0x10',
+    },
+    {
+        number: 255,
+        bigint: BigInt(255),
+        hexadecimal: '0xff',
+    },
+    {
+        number: 256,
+        bigint: BigInt(256),
+        hexadecimal: '0x100',
+    },
+    {
+        number: 65535,
+        bigint: BigInt(65535),
+        hexadecimal: '0xffff',
+    },
+    {
+        number: 65536,
+        bigint: BigInt(65536),
+        hexadecimal: '0x10000',
+    },
+    {
+        number: 4294967295,
+        bigint: BigInt(4294967295),
+        hexadecimal: '0xffffffff',
+    },
+    {
+        number: 4294967296,
+        bigint: BigInt(4294967296),
+        hexadecimal: '0x100000000',
+    },
+    {
+        number: 9007199254740991,
+        bigint: BigInt(9007199254740991),
+        hexadecimal: '0x1fffffffffffff',
+    },
+];
+//# sourceMappingURL=numbers.js.map

package/dist/__fixtures__/numbers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"numbers.js","sourceRoot":"","sources":["../../src/__fixtures__/numbers.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B;QACE,MAAM,EAAE,CAAC;QACT,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QACjB,WAAW,EAAE,KAAK;KACnB;IACD;QACE,MAAM,EAAE,CAAC;QACT,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QACjB,WAAW,EAAE,KAAK;KACnB;IACD;QACE,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;QAClB,WAAW,EAAE,MAAM;KACpB;IACD;QACE,MAAM,EAAE,GAAG;QACX,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC;QACnB,WAAW,EAAE,MAAM;KACpB;IACD;QACE,MAAM,EAAE,GAAG;QACX,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC;QACnB,WAAW,EAAE,OAAO;KACrB;IACD;QACE,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC;QACrB,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC;QACrB,WAAW,EAAE,SAAS;KACvB;IACD;QACE,MAAM,EAAE,UAAU;QAClB,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC;QAC1B,WAAW,EAAE,YAAY;KAC1B;IACD;QACE,MAAM,EAAE,UAAU;QAClB,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC;QAC1B,WAAW,EAAE,aAAa;KAC3B;IACD;QACE,MAAM,EAAE,gBAAgB;QACxB,MAAM,EAAE,MAAM,CAAC,gBAAgB,CAAC;QAChC,WAAW,EAAE,kBAAkB;KAChC;CACF,CAAC","sourcesContent":["export const NUMBER_VALUES = [\n  {\n    number: 0,\n    bigint: BigInt(0),\n    hexadecimal: '0x0',\n  },\n  {\n    number: 1,\n    bigint: BigInt(1),\n    hexadecimal: '0x1',\n  },\n  {\n    number: 16,\n    bigint: BigInt(16),\n    hexadecimal: '0x10',\n  },\n  {\n    number: 255,\n    bigint: BigInt(255),\n    hexadecimal: '0xff',\n  },\n  {\n    number: 256,\n    bigint: BigInt(256),\n    hexadecimal: '0x100',\n  },\n  {\n    number: 65535,\n    bigint: BigInt(65535),\n    hexadecimal: '0xffff',\n  },\n  {\n    number: 65536,\n    bigint: BigInt(65536),\n    hexadecimal: '0x10000',\n  },\n  {\n    number: 4294967295,\n    bigint: BigInt(4294967295),\n    hexadecimal: '0xffffffff',\n  },\n  {\n    number: 4294967296,\n    bigint: BigInt(4294967296),\n    hexadecimal: '0x100000000',\n  },\n  {\n    number: 9007199254740991,\n    bigint: BigInt(9007199254740991),\n    hexadecimal: '0x1fffffffffffff',\n  },\n];\n"]}

package/dist/bytes.d.ts

@@ -0,0 +1,198 @@
+import type { Hex } from './hex.js';
+export type Bytes = bigint | number | string | Uint8Array;
+/**
+ * Check if a value is a `Uint8Array`.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a `Uint8Array`.
+ */
+export declare function isBytes(value: unknown): value is Uint8Array;
+/**
+ * Assert that a value is a `Uint8Array`.
+ *
+ * @param value - The value to check.
+ * @throws If the value is not a `Uint8Array`.
+ */
+export declare function assertIsBytes(value: unknown): asserts value is Uint8Array;
+/**
+ * Convert a `Uint8Array` to a hexadecimal string.
+ *
+ * @param bytes - The bytes to convert to a hexadecimal string.
+ * @returns The hexadecimal string.
+ */
+export declare function bytesToHex(bytes: Uint8Array): Hex;
+/**
+ * Convert a `Uint8Array` to a `bigint`.
+ *
+ * To convert a `Uint8Array` to a `number` instead, use {@link bytesToNumber}.
+ * To convert a two's complement encoded `Uint8Array` to a `bigint`, use
+ * {@link bytesToSignedBigInt}.
+ *
+ * @param bytes - The bytes to convert to a `bigint`.
+ * @returns The `bigint`.
+ */
+export declare function bytesToBigInt(bytes: Uint8Array): bigint;
+/**
+ * Convert a `Uint8Array` to a signed `bigint`. This assumes that the bytes are
+ * encoded in two's complement.
+ *
+ * To convert a `Uint8Array` to an unsigned `bigint` instead, use
+ * {@link bytesToBigInt}.
+ *
+ * @see https://en.wikipedia.org/wiki/Two%27s_complement
+ * @param bytes - The bytes to convert to a signed `bigint`.
+ * @returns The signed `bigint`.
+ */
+export declare function bytesToSignedBigInt(bytes: Uint8Array): bigint;
+/**
+ * Convert a `Uint8Array` to a `number`.
+ *
+ * To convert a `Uint8Array` to a `bigint` instead, use {@link bytesToBigInt}.
+ *
+ * @param bytes - The bytes to convert to a number.
+ * @returns The number.
+ * @throws If the resulting number is not a safe integer.
+ */
+export declare function bytesToNumber(bytes: Uint8Array): number;
+/**
+ * Convert a UTF-8 encoded `Uint8Array` to a `string`.
+ *
+ * @param bytes - The bytes to convert to a string.
+ * @returns The string.
+ */
+export declare function bytesToString(bytes: Uint8Array): string;
+/**
+ * Convert a `Uint8Array` to a base64 encoded string.
+ *
+ * @param bytes - The bytes to convert to a base64 encoded string.
+ * @returns The base64 encoded string.
+ */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/**
+ * Convert a hexadecimal string to a `Uint8Array`. The string can optionally be
+ * prefixed with `0x`. It accepts even and odd length strings.
+ *
+ * If the value is "0x", an empty `Uint8Array` is returned.
+ *
+ * @param value - The hexadecimal string to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+export declare function hexToBytes(value: string): Uint8Array<ArrayBuffer>;
+/**
+ * Convert a `bigint` to a `Uint8Array`.
+ *
+ * This assumes that the `bigint` is an unsigned integer. To convert a signed
+ * `bigint` instead, use {@link signedBigIntToBytes}.
+ *
+ * @param value - The bigint to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+export declare function bigIntToBytes(value: bigint): Uint8Array<ArrayBuffer>;
+/**
+ * Convert a signed `bigint` to a `Uint8Array`. This uses two's complement
+ * encoding to represent negative numbers.
+ *
+ * To convert an unsigned `bigint` to a `Uint8Array` instead, use
+ * {@link bigIntToBytes}.
+ *
+ * @see https://en.wikipedia.org/wiki/Two%27s_complement
+ * @param value - The number to convert to bytes.
+ * @param byteLength - The length of the resulting `Uint8Array`. If the number
+ * is larger than the maximum value that can be represented by the given length,
+ * an error is thrown.
+ * @returns The bytes as `Uint8Array`.
+ */
+export declare function signedBigIntToBytes(value: bigint, byteLength: number): Uint8Array<ArrayBuffer>;
+/**
+ * Convert a `number` to a `Uint8Array`.
+ *
+ * @param value - The number to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ * @throws If the number is not a safe integer.
+ */
+export declare function numberToBytes(value: number): Uint8Array<ArrayBuffer>;
+/**
+ * Convert a `string` to a UTF-8 encoded `Uint8Array`.
+ *
+ * @param value - The string to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+export declare function stringToBytes(value: string): Uint8Array<ArrayBuffer>;
+/**
+ * Convert a base64 encoded string to a `Uint8Array`.
+ *
+ * @param value - The base64 encoded string to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+export declare function base64ToBytes(value: string): Uint8Array<ArrayBuffer>;
+/**
+ * Convert a byte-like value to a `Uint8Array`. The value can be a `Uint8Array`,
+ * a `bigint`, a `number`, or a `string`.
+ *
+ * This will attempt to guess the type of the value based on its type and
+ * contents. For more control over the conversion, use the more specific
+ * conversion functions, such as {@link hexToBytes} or {@link stringToBytes}.
+ *
+ * If the value is a `string`, and it is prefixed with `0x`, it will be
+ * interpreted as a hexadecimal string. Otherwise, it will be interpreted as a
+ * UTF-8 string. To convert a hexadecimal string to bytes without interpreting
+ * it as a UTF-8 string, use {@link hexToBytes} instead.
+ *
+ * If the value is a `bigint`, it is assumed to be unsigned. To convert a signed
+ * `bigint` to bytes, use {@link signedBigIntToBytes} instead.
+ *
+ * If the value is a `Uint8Array`, it will be returned as-is.
+ *
+ * @param value - The value to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+export declare function valueToBytes(value: Bytes): Uint8Array<ArrayBuffer>;
+/**
+ * Concatenate multiple byte-like values into a single `Uint8Array`. The values
+ * can be `Uint8Array`, `bigint`, `number`, or `string`. This uses
+ * {@link valueToBytes} under the hood to convert each value to bytes. Refer to
+ * the documentation of that function for more information.
+ *
+ * @param values - The values to concatenate.
+ * @returns The concatenated bytes as `Uint8Array`.
+ */
+export declare function concatBytes(values: Bytes[]): Uint8Array<ArrayBuffer>;
+/**
+ * Create a {@link DataView} from a {@link Uint8Array}. This is a convenience
+ * function that avoids having to create a {@link DataView} manually, which
+ * requires passing the `byteOffset` and `byteLength` parameters every time.
+ *
+ * Not passing the `byteOffset` and `byteLength` parameters can result in
+ * unexpected behavior when the {@link Uint8Array} is a view of a larger
+ * {@link ArrayBuffer}, e.g., when using {@link Uint8Array.subarray}.
+ *
+ * This function also supports Node.js {@link Buffer}s.
+ *
+ * @example
+ * ```typescript
+ * const bytes = new Uint8Array([1, 2, 3]);
+ *
+ * // This is equivalent to:
+ * // const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+ * const dataView = createDataView(bytes);
+ * ```
+ * @param bytes - The bytes to create the {@link DataView} from.
+ * @returns The {@link DataView}.
+ */
+export declare function createDataView<ArrayBufferImplementation extends ArrayBufferLike>(bytes: Uint8Array<ArrayBufferImplementation>): DataView<ArrayBufferImplementation>;
+/**
+ * Compare two Uint8Arrays using a constant-time style loop to reduce timing
+ * side-channels when comparing sensitive data (e.g., mnemonic bytes, keys,
+ * authentication tags). Does not early-return on the first difference:
+ * work done depends only on the input lengths, so byte content does not affect timing.
+ *
+ * When to use:
+ * - Use for secret or security-sensitive byte comparisons to avoid content-based timing leaks.
+ * - Prefer when inputs are fixed-length (or validated to equal length) at the API boundary.
+ *
+ * @param a - The first Uint8Array to compare.
+ * @param b - The second Uint8Array to compare.
+ * @returns Whether the Uint8Arrays are equal.
+ */
+export declare function areUint8ArraysEqual(a: Uint8Array, b: Uint8Array): boolean;
+//# sourceMappingURL=bytes.d.ts.map

package/dist/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../src/bytes.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAUpC,MAAM,MAAM,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,CAAC;AAwC1D;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAE3D;AAYD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,UAAU,CAEzE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,GAAG,CAgBjD;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAKvD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAU7D;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAWvD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAIvD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAIvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,CAoCjE;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,CAMpE;AAkBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,GACjB,UAAU,CAAC,WAAW,CAAC,CAqBzB;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,CAUpE;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,CAIpE;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,CAIpE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAAC,WAAW,CAAC,CA0BlE;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,UAAU,CAAC,WAAW,CAAC,CAsBpE;AASD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAC5B,yBAAyB,SAAS,eAAe,EAEjD,KAAK,EAAE,UAAU,CAAC,yBAAyB,CAAC,GAC3C,QAAQ,CAAC,yBAAyB,CAAC,CAmBrC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAazE"}

package/dist/bytes.js

@@ -0,0 +1,423 @@
+import { assert } from '@metamask/type-utils';
+import { base64 } from '@scure/base';
+import { add0x, assertIsHexString, remove0x } from './hex.js';
+// '0'.charCodeAt(0) === 48
+const HEX_MINIMUM_NUMBER_CHARACTER = 48;
+// '9'.charCodeAt(0) === 57
+const HEX_MAXIMUM_NUMBER_CHARACTER = 58;
+const HEX_CHARACTER_OFFSET = 87;
+/**
+ * Memoized function that returns an array to be used as a lookup table for
+ * converting bytes to hexadecimal values.
+ *
+ * The array is created lazily and then cached for future use. The benefit of
+ * this approach is that the performance of converting bytes to hex is much
+ * better than if we were to call `toString(16)` on each byte.
+ *
+ * The downside is that the array is created once and then never garbage
+ * collected. This is not a problem in practice because the array is only 256
+ * elements long.
+ *
+ * @returns A function that returns the lookup table.
+ */
+function getPrecomputedHexValuesBuilder() {
+    // To avoid issues with tree shaking, we need to use a function to return the
+    // array. This is because the array is only used in the `bytesToHex` function
+    // and if we were to use a global variable, the array might be removed by the
+    // tree shaker.
+    const lookupTable = [];
+    return () => {
+        if (lookupTable.length === 0) {
+            for (let i = 0; i < 256; i++) {
+                lookupTable.push(i.toString(16).padStart(2, '0'));
+            }
+        }
+        return lookupTable;
+    };
+}
+/**
+ * Function implementation of the {@link getPrecomputedHexValuesBuilder}
+ * function.
+ */
+const getPrecomputedHexValues = getPrecomputedHexValuesBuilder();
+/**
+ * Check if a value is a `Uint8Array`.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a `Uint8Array`.
+ */
+export function isBytes(value) {
+    return value instanceof Uint8Array;
+}
+/**
+ * Check if a value is a `Uint8Array` backed by an `ArrayBuffer`.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a `Uint8Array` backed by an `ArrayBuffer`.
+ */
+function isArrayBufferBytes(value) {
+    return isBytes(value) && value.buffer instanceof ArrayBuffer;
+}
+/**
+ * Assert that a value is a `Uint8Array`.
+ *
+ * @param value - The value to check.
+ * @throws If the value is not a `Uint8Array`.
+ */
+export function assertIsBytes(value) {
+    assert(isBytes(value), 'Value must be a Uint8Array.');
+}
+/**
+ * Convert a `Uint8Array` to a hexadecimal string.
+ *
+ * @param bytes - The bytes to convert to a hexadecimal string.
+ * @returns The hexadecimal string.
+ */
+export function bytesToHex(bytes) {
+    assertIsBytes(bytes);
+    if (bytes.length === 0) {
+        return '0x';
+    }
+    const lookupTable = getPrecomputedHexValues();
+    const hexadecimal = new Array(bytes.length);
+    for (let i = 0; i < bytes.length; i++) {
+        // oxlint-disable-next-line typescript/no-non-null-assertion
+        hexadecimal[i] = lookupTable[bytes[i]];
+    }
+    return add0x(hexadecimal.join(''));
+}
+/**
+ * Convert a `Uint8Array` to a `bigint`.
+ *
+ * To convert a `Uint8Array` to a `number` instead, use {@link bytesToNumber}.
+ * To convert a two's complement encoded `Uint8Array` to a `bigint`, use
+ * {@link bytesToSignedBigInt}.
+ *
+ * @param bytes - The bytes to convert to a `bigint`.
+ * @returns The `bigint`.
+ */
+export function bytesToBigInt(bytes) {
+    assertIsBytes(bytes);
+    const hexadecimal = bytesToHex(bytes);
+    return BigInt(hexadecimal);
+}
+/**
+ * Convert a `Uint8Array` to a signed `bigint`. This assumes that the bytes are
+ * encoded in two's complement.
+ *
+ * To convert a `Uint8Array` to an unsigned `bigint` instead, use
+ * {@link bytesToBigInt}.
+ *
+ * @see https://en.wikipedia.org/wiki/Two%27s_complement
+ * @param bytes - The bytes to convert to a signed `bigint`.
+ * @returns The signed `bigint`.
+ */
+export function bytesToSignedBigInt(bytes) {
+    assertIsBytes(bytes);
+    let value = BigInt(0);
+    for (const byte of bytes) {
+        // eslint-disable-next-line no-bitwise
+        value = (value << BigInt(8)) + BigInt(byte);
+    }
+    return BigInt.asIntN(bytes.length * 8, value);
+}
+/**
+ * Convert a `Uint8Array` to a `number`.
+ *
+ * To convert a `Uint8Array` to a `bigint` instead, use {@link bytesToBigInt}.
+ *
+ * @param bytes - The bytes to convert to a number.
+ * @returns The number.
+ * @throws If the resulting number is not a safe integer.
+ */
+export function bytesToNumber(bytes) {
+    assertIsBytes(bytes);
+    const bigint = bytesToBigInt(bytes);
+    assert(bigint <= BigInt(Number.MAX_SAFE_INTEGER), 'Number is not a safe integer. Use `bytesToBigInt` instead.');
+    return Number(bigint);
+}
+/**
+ * Convert a UTF-8 encoded `Uint8Array` to a `string`.
+ *
+ * @param bytes - The bytes to convert to a string.
+ * @returns The string.
+ */
+export function bytesToString(bytes) {
+    assertIsBytes(bytes);
+    return new TextDecoder().decode(bytes);
+}
+/**
+ * Convert a `Uint8Array` to a base64 encoded string.
+ *
+ * @param bytes - The bytes to convert to a base64 encoded string.
+ * @returns The base64 encoded string.
+ */
+export function bytesToBase64(bytes) {
+    assertIsBytes(bytes);
+    return base64.encode(bytes);
+}
+/**
+ * Convert a hexadecimal string to a `Uint8Array`. The string can optionally be
+ * prefixed with `0x`. It accepts even and odd length strings.
+ *
+ * If the value is "0x", an empty `Uint8Array` is returned.
+ *
+ * @param value - The hexadecimal string to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+export function hexToBytes(value) {
+    // "0x" is often used as empty byte array.
+    if (value?.toLowerCase?.() === '0x') {
+        return new Uint8Array();
+    }
+    assertIsHexString(value);
+    // Remove the `0x` prefix if it exists, and pad the string to have an even
+    // number of characters.
+    const strippedValue = remove0x(value).toLowerCase();
+    const normalizedValue = strippedValue.length % 2 === 0 ? strippedValue : `0${strippedValue}`;
+    const bytes = new Uint8Array(normalizedValue.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        // While this is not the prettiest way to convert a hexadecimal string to a
+        // `Uint8Array`, it is a lot faster than using `parseInt` to convert each
+        // character.
+        const c1 = normalizedValue.charCodeAt(i * 2);
+        const c2 = normalizedValue.charCodeAt(i * 2 + 1);
+        const n1 = c1 -
+            (c1 < HEX_MAXIMUM_NUMBER_CHARACTER
+                ? HEX_MINIMUM_NUMBER_CHARACTER
+                : HEX_CHARACTER_OFFSET);
+        const n2 = c2 -
+            (c2 < HEX_MAXIMUM_NUMBER_CHARACTER
+                ? HEX_MINIMUM_NUMBER_CHARACTER
+                : HEX_CHARACTER_OFFSET);
+        bytes[i] = n1 * 16 + n2;
+    }
+    return bytes;
+}
+/**
+ * Convert a `bigint` to a `Uint8Array`.
+ *
+ * This assumes that the `bigint` is an unsigned integer. To convert a signed
+ * `bigint` instead, use {@link signedBigIntToBytes}.
+ *
+ * @param value - The bigint to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+export function bigIntToBytes(value) {
+    assert(typeof value === 'bigint', 'Value must be a bigint.');
+    assert(value >= BigInt(0), 'Value must be a non-negative bigint.');
+    const hexadecimal = value.toString(16);
+    return hexToBytes(hexadecimal);
+}
+/**
+ * Check if a `bigint` fits in a certain number of bytes.
+ *
+ * @param value - The `bigint` to check.
+ * @param bytes - The number of bytes.
+ * @returns Whether the `bigint` fits in the number of bytes.
+ */
+function bigIntFits(value, bytes) {
+    assert(bytes > 0);
+    /* eslint-disable no-bitwise */
+    const mask = value >> BigInt(31);
+    return !(((~value & mask) + (value & ~mask)) >> BigInt(bytes * 8 + ~0));
+    /* eslint-enable no-bitwise */
+}
+/**
+ * Convert a signed `bigint` to a `Uint8Array`. This uses two's complement
+ * encoding to represent negative numbers.
+ *
+ * To convert an unsigned `bigint` to a `Uint8Array` instead, use
+ * {@link bigIntToBytes}.
+ *
+ * @see https://en.wikipedia.org/wiki/Two%27s_complement
+ * @param value - The number to convert to bytes.
+ * @param byteLength - The length of the resulting `Uint8Array`. If the number
+ * is larger than the maximum value that can be represented by the given length,
+ * an error is thrown.
+ * @returns The bytes as `Uint8Array`.
+ */
+export function signedBigIntToBytes(value, byteLength) {
+    assert(typeof value === 'bigint', 'Value must be a bigint.');
+    assert(typeof byteLength === 'number', 'Byte length must be a number.');
+    assert(byteLength > 0, 'Byte length must be greater than 0.');
+    assert(bigIntFits(value, byteLength), 'Byte length is too small to represent the given value.');
+    // ESLint doesn't like mutating function parameters, so to avoid having to
+    // disable the rule, we create a new variable.
+    let numberValue = value;
+    const bytes = new Uint8Array(byteLength);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = Number(BigInt.asUintN(8, numberValue));
+        // eslint-disable-next-line no-bitwise
+        numberValue >>= BigInt(8);
+    }
+    return bytes.reverse();
+}
+/**
+ * Convert a `number` to a `Uint8Array`.
+ *
+ * @param value - The number to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ * @throws If the number is not a safe integer.
+ */
+export function numberToBytes(value) {
+    assert(typeof value === 'number', 'Value must be a number.');
+    assert(value >= 0, 'Value must be a non-negative number.');
+    assert(Number.isSafeInteger(value), 'Value is not a safe integer. Use `bigIntToBytes` instead.');
+    const hexadecimal = value.toString(16);
+    return hexToBytes(hexadecimal);
+}
+/**
+ * Convert a `string` to a UTF-8 encoded `Uint8Array`.
+ *
+ * @param value - The string to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+export function stringToBytes(value) {
+    assert(typeof value === 'string', 'Value must be a string.');
+    return new TextEncoder().encode(value);
+}
+/**
+ * Convert a base64 encoded string to a `Uint8Array`.
+ *
+ * @param value - The base64 encoded string to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+export function base64ToBytes(value) {
+    assert(typeof value === 'string', 'Value must be a string.');
+    return base64.decode(value);
+}
+/**
+ * Convert a byte-like value to a `Uint8Array`. The value can be a `Uint8Array`,
+ * a `bigint`, a `number`, or a `string`.
+ *
+ * This will attempt to guess the type of the value based on its type and
+ * contents. For more control over the conversion, use the more specific
+ * conversion functions, such as {@link hexToBytes} or {@link stringToBytes}.
+ *
+ * If the value is a `string`, and it is prefixed with `0x`, it will be
+ * interpreted as a hexadecimal string. Otherwise, it will be interpreted as a
+ * UTF-8 string. To convert a hexadecimal string to bytes without interpreting
+ * it as a UTF-8 string, use {@link hexToBytes} instead.
+ *
+ * If the value is a `bigint`, it is assumed to be unsigned. To convert a signed
+ * `bigint` to bytes, use {@link signedBigIntToBytes} instead.
+ *
+ * If the value is a `Uint8Array`, it will be returned as-is.
+ *
+ * @param value - The value to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+export function valueToBytes(value) {
+    if (typeof value === 'bigint') {
+        return bigIntToBytes(value);
+    }
+    if (typeof value === 'number') {
+        return numberToBytes(value);
+    }
+    if (typeof value === 'string') {
+        if (value.startsWith('0x')) {
+            return hexToBytes(value);
+        }
+        return stringToBytes(value);
+    }
+    if (isArrayBufferBytes(value)) {
+        return value;
+    }
+    if (isBytes(value)) {
+        return new Uint8Array(value);
+    }
+    throw new TypeError(`Unsupported value type: "${typeof value}".`);
+}
+/**
+ * Concatenate multiple byte-like values into a single `Uint8Array`. The values
+ * can be `Uint8Array`, `bigint`, `number`, or `string`. This uses
+ * {@link valueToBytes} under the hood to convert each value to bytes. Refer to
+ * the documentation of that function for more information.
+ *
+ * @param values - The values to concatenate.
+ * @returns The concatenated bytes as `Uint8Array`.
+ */
+export function concatBytes(values) {
+    const normalizedValues = new Array(values.length);
+    let byteLength = 0;
+    for (let i = 0; i < values.length; i++) {
+        // oxlint-disable-next-line typescript/no-non-null-assertion
+        const value = valueToBytes(values[i]);
+        normalizedValues[i] = value;
+        byteLength += value.length;
+    }
+    const bytes = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const normalizedValue of normalizedValues) {
+        // While we could simply spread the values into an array and use
+        // `Uint8Array.from`, that is a lot slower than using `Uint8Array.set`.
+        bytes.set(normalizedValue, offset);
+        offset += normalizedValue.length;
+    }
+    return bytes;
+}
+function isBuffer(bytes) {
+    // oxlint-disable-next-line no-undef
+    return typeof Buffer !== 'undefined' && bytes instanceof Buffer;
+}
+/**
+ * Create a {@link DataView} from a {@link Uint8Array}. This is a convenience
+ * function that avoids having to create a {@link DataView} manually, which
+ * requires passing the `byteOffset` and `byteLength` parameters every time.
+ *
+ * Not passing the `byteOffset` and `byteLength` parameters can result in
+ * unexpected behavior when the {@link Uint8Array} is a view of a larger
+ * {@link ArrayBuffer}, e.g., when using {@link Uint8Array.subarray}.
+ *
+ * This function also supports Node.js {@link Buffer}s.
+ *
+ * @example
+ * ```typescript
+ * const bytes = new Uint8Array([1, 2, 3]);
+ *
+ * // This is equivalent to:
+ * // const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+ * const dataView = createDataView(bytes);
+ * ```
+ * @param bytes - The bytes to create the {@link DataView} from.
+ * @returns The {@link DataView}.
+ */
+export function createDataView(bytes) {
+    // To maintain compatibility with Node.js, we need to check if the bytes are
+    // a Buffer. If so, we need to slice the buffer to get the underlying
+    // ArrayBuffer.
+    // eslint-disable-next-line no-restricted-globals, no-undef
+    if (isBuffer(bytes)) {
+        const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+        return new DataView(buffer);
+    }
+    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+/**
+ * Compare two Uint8Arrays using a constant-time style loop to reduce timing
+ * side-channels when comparing sensitive data (e.g., mnemonic bytes, keys,
+ * authentication tags). Does not early-return on the first difference:
+ * work done depends only on the input lengths, so byte content does not affect timing.
+ *
+ * When to use:
+ * - Use for secret or security-sensitive byte comparisons to avoid content-based timing leaks.
+ * - Prefer when inputs are fixed-length (or validated to equal length) at the API boundary.
+ *
+ * @param a - The first Uint8Array to compare.
+ * @param b - The second Uint8Array to compare.
+ * @returns Whether the Uint8Arrays are equal.
+ */
+export function areUint8ArraysEqual(a, b) {
+    // eslint-disable-next-line no-bitwise
+    let diff = a.byteLength ^ b.byteLength;
+    const len = Math.max(a.byteLength, b.byteLength);
+    for (let i = 0; i < len; i++) {
+        const aByte = a[i] ?? 0;
+        const bByte = b[i] ?? 0;
+        // eslint-disable-next-line no-bitwise
+        diff |= aByte ^ bByte;
+    }
+    return diff === 0;
+}
+//# sourceMappingURL=bytes.js.map