@metamask/utils 6.2.0 → 7.0.0

package/dist/{bytes.js → esm/bytes.js}

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDataView = exports.concatBytes = exports.valueToBytes = exports.stringToBytes = exports.numberToBytes = exports.signedBigIntToBytes = exports.bigIntToBytes = exports.hexToBytes = exports.bytesToString = exports.bytesToNumber = exports.bytesToSignedBigInt = exports.bytesToBigInt = exports.bytesToHex = exports.assertIsBytes = exports.isBytes = void 0;
-const assert_1 = require("./assert");
-const hex_1 = require("./hex");
+import { assert } from './assert';
+import { add0x, assertIsHexString, remove0x } from './hex';
 // '0'.charCodeAt(0) === 48
 const HEX_MINIMUM_NUMBER_CHARACTER = 48;
 // '9'.charCodeAt(0) === 57
@@ -21,16 +18,15 @@ const HEX_CHARACTER_OFFSET = 87;
  * elements long.
  *
  * @returns A function that returns the lookup table.
- */
-function getPrecomputedHexValuesBuilder() {
+ */ 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 () => {
+    return ()=>{
         if (lookupTable.length === 0) {
-            for (let i = 0; i < 256; i++) {
+            for(let i = 0; i < 256; i++){
                 lookupTable.push(i.toString(16).padStart(2, '0'));
             }
         }
@@ -40,48 +36,41 @@ function getPrecomputedHexValuesBuilder() {
 /**
  * Function implementation of the {@link getPrecomputedHexValuesBuilder}
  * function.
- */
-const getPrecomputedHexValues = getPrecomputedHexValuesBuilder();
+ */ const getPrecomputedHexValues = getPrecomputedHexValuesBuilder();
 /**
  * Check if a value is a `Uint8Array`.
  *
  * @param value - The value to check.
  * @returns Whether the value is a `Uint8Array`.
- */
-function isBytes(value) {
+ */ export function isBytes(value) {
     return value instanceof Uint8Array;
 }
-exports.isBytes = isBytes;
 /**
  * Assert that a value is a `Uint8Array`.
  *
  * @param value - The value to check.
  * @throws If the value is not a `Uint8Array`.
- */
-function assertIsBytes(value) {
-    (0, assert_1.assert)(isBytes(value), 'Value must be a Uint8Array.');
+ */ export function assertIsBytes(value) {
+    assert(isBytes(value), 'Value must be a Uint8Array.');
 }
-exports.assertIsBytes = assertIsBytes;
 /**
  * Convert a `Uint8Array` to a hexadecimal string.
  *
  * @param bytes - The bytes to convert to a hexadecimal string.
  * @returns The hexadecimal string.
- */
-function bytesToHex(bytes) {
+ */ 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++) {
+    for(let i = 0; i < bytes.length; i++){
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         hexadecimal[i] = lookupTable[bytes[i]];
     }
-    return (0, hex_1.add0x)(hexadecimal.join(''));
+    return add0x(hexadecimal.join(''));
 }
-exports.bytesToHex = bytesToHex;
 /**
  * Convert a `Uint8Array` to a `bigint`.
  *
@@ -91,13 +80,11 @@ exports.bytesToHex = bytesToHex;
  *
  * @param bytes - The bytes to convert to a `bigint`.
  * @returns The `bigint`.
- */
-function bytesToBigInt(bytes) {
+ */ export function bytesToBigInt(bytes) {
     assertIsBytes(bytes);
     const hexadecimal = bytesToHex(bytes);
     return BigInt(hexadecimal);
 }
-exports.bytesToBigInt = bytesToBigInt;
 /**
  * Convert a `Uint8Array` to a signed `bigint`. This assumes that the bytes are
  * encoded in two's complement.
@@ -108,17 +95,15 @@ exports.bytesToBigInt = bytesToBigInt;
  * @see https://en.wikipedia.org/wiki/Two%27s_complement
  * @param bytes - The bytes to convert to a signed `bigint`.
  * @returns The signed `bigint`.
- */
-function bytesToSignedBigInt(bytes) {
+ */ export function bytesToSignedBigInt(bytes) {
     assertIsBytes(bytes);
     let value = BigInt(0);
-    for (const byte of bytes) {
+    for (const byte of bytes){
         // eslint-disable-next-line no-bitwise
         value = (value << BigInt(8)) + BigInt(byte);
     }
     return BigInt.asIntN(bytes.length * 8, value);
 }
-exports.bytesToSignedBigInt = bytesToSignedBigInt;
 /**
  * Convert a `Uint8Array` to a `number`.
  *
@@ -127,25 +112,21 @@ exports.bytesToSignedBigInt = bytesToSignedBigInt;
  * @param bytes - The bytes to convert to a number.
  * @returns The number.
  * @throws If the resulting number is not a safe integer.
- */
-function bytesToNumber(bytes) {
+ */ export function bytesToNumber(bytes) {
     assertIsBytes(bytes);
     const bigint = bytesToBigInt(bytes);
-    (0, assert_1.assert)(bigint <= BigInt(Number.MAX_SAFE_INTEGER), 'Number is not a safe integer. Use `bytesToBigInt` instead.');
+    assert(bigint <= BigInt(Number.MAX_SAFE_INTEGER), 'Number is not a safe integer. Use `bytesToBigInt` instead.');
     return Number(bigint);
 }
-exports.bytesToNumber = bytesToNumber;
 /**
  * Convert a UTF-8 encoded `Uint8Array` to a `string`.
  *
  * @param bytes - The bytes to convert to a string.
  * @returns The string.
- */
-function bytesToString(bytes) {
+ */ export function bytesToString(bytes) {
     assertIsBytes(bytes);
     return new TextDecoder().decode(bytes);
 }
-exports.bytesToString = bytesToString;
 /**
  * Convert a hexadecimal string to a `Uint8Array`. The string can optionally be
  * prefixed with `0x`. It accepts even and odd length strings.
@@ -154,37 +135,29 @@ exports.bytesToString = bytesToString;
  *
  * @param value - The hexadecimal string to convert to bytes.
  * @returns The bytes as `Uint8Array`.
- */
-function hexToBytes(value) {
+ */ export function hexToBytes(value) {
     // "0x" is often used as empty byte array.
     if (value?.toLowerCase?.() === '0x') {
         return new Uint8Array();
     }
-    (0, hex_1.assertIsHexString)(value);
+    assertIsHexString(value);
     // Remove the `0x` prefix if it exists, and pad the string to have an even
     // number of characters.
-    const strippedValue = (0, hex_1.remove0x)(value).toLowerCase();
+    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++) {
+    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);
+        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;
 }
-exports.hexToBytes = hexToBytes;
 /**
  * Convert a `bigint` to a `Uint8Array`.
  *
@@ -193,28 +166,23 @@ exports.hexToBytes = hexToBytes;
  *
  * @param value - The bigint to convert to bytes.
  * @returns The bytes as `Uint8Array`.
- */
-function bigIntToBytes(value) {
-    (0, assert_1.assert)(typeof value === 'bigint', 'Value must be a bigint.');
-    (0, assert_1.assert)(value >= BigInt(0), 'Value must be a non-negative bigint.');
+ */ 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);
 }
-exports.bigIntToBytes = bigIntToBytes;
 /**
  * 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) {
-    (0, assert_1.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 */
-}
+ */ 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.
@@ -228,50 +196,44 @@ function bigIntFits(value, bytes) {
  * is larger than the maximum value that can be represented by the given length,
  * an error is thrown.
  * @returns The bytes as `Uint8Array`.
- */
-function signedBigIntToBytes(value, byteLength) {
-    (0, assert_1.assert)(typeof value === 'bigint', 'Value must be a bigint.');
-    (0, assert_1.assert)(typeof byteLength === 'number', 'Byte length must be a number.');
-    (0, assert_1.assert)(byteLength > 0, 'Byte length must be greater than 0.');
-    (0, assert_1.assert)(bigIntFits(value, byteLength), 'Byte length is too small to represent the given value.');
+ */ 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++) {
+    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();
 }
-exports.signedBigIntToBytes = signedBigIntToBytes;
 /**
  * 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.
- */
-function numberToBytes(value) {
-    (0, assert_1.assert)(typeof value === 'number', 'Value must be a number.');
-    (0, assert_1.assert)(value >= 0, 'Value must be a non-negative number.');
-    (0, assert_1.assert)(Number.isSafeInteger(value), 'Value is not a safe integer. Use `bigIntToBytes` instead.');
+ */ 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);
 }
-exports.numberToBytes = numberToBytes;
 /**
  * Convert a `string` to a UTF-8 encoded `Uint8Array`.
  *
  * @param value - The string to convert to bytes.
  * @returns The bytes as `Uint8Array`.
- */
-function stringToBytes(value) {
-    (0, assert_1.assert)(typeof value === 'string', 'Value must be a string.');
+ */ export function stringToBytes(value) {
+    assert(typeof value === 'string', 'Value must be a string.');
     return new TextEncoder().encode(value);
 }
-exports.stringToBytes = stringToBytes;
 /**
  * Convert a byte-like value to a `Uint8Array`. The value can be a `Uint8Array`,
  * a `bigint`, a `number`, or a `string`.
@@ -292,8 +254,7 @@ exports.stringToBytes = stringToBytes;
  *
  * @param value - The value to convert to bytes.
  * @returns The bytes as `Uint8Array`.
- */
-function valueToBytes(value) {
+ */ export function valueToBytes(value) {
     if (typeof value === 'bigint') {
         return bigIntToBytes(value);
     }
@@ -311,7 +272,6 @@ function valueToBytes(value) {
     }
     throw new TypeError(`Unsupported value type: "${typeof value}".`);
 }
-exports.valueToBytes = valueToBytes;
 /**
  * Concatenate multiple byte-like values into a single `Uint8Array`. The values
  * can be `Uint8Array`, `bigint`, `number`, or `string`. This uses
@@ -320,18 +280,17 @@ exports.valueToBytes = valueToBytes;
  *
  * @param values - The values to concatenate.
  * @returns The concatenated bytes as `Uint8Array`.
- */
-function concatBytes(values) {
+ */ export function concatBytes(values) {
     const normalizedValues = new Array(values.length);
     let byteLength = 0;
-    for (let i = 0; i < values.length; i++) {
+    for(let i = 0; i < values.length; i++){
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const value = valueToBytes(values[i]);
         normalizedValues[i] = value;
         byteLength += value.length;
     }
     const bytes = new Uint8Array(byteLength);
-    for (let i = 0, offset = 0; i < normalizedValues.length; i++) {
+    for(let i = 0, offset = 0; i < normalizedValues.length; i++){
         // 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(normalizedValues[i], offset);
@@ -339,7 +298,6 @@ function concatBytes(values) {
     }
     return bytes;
 }
-exports.concatBytes = concatBytes;
 /**
  * Create a {@link DataView} from a {@link Uint8Array}. This is a convenience
  * function that avoids having to create a {@link DataView} manually, which
@@ -361,8 +319,7 @@ exports.concatBytes = concatBytes;
  * ```
  * @param bytes - The bytes to create the {@link DataView} from.
  * @returns The {@link DataView}.
- */
-function createDataView(bytes) {
+ */ 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.
@@ -373,5 +330,5 @@ function createDataView(bytes) {
     }
     return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
 }
-exports.createDataView = createDataView;
+
 //# sourceMappingURL=bytes.js.map

package/dist/esm/bytes.js.map

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

package/dist/esm/checksum.js

@@ -0,0 +1,7 @@
+import { size, string } from 'superstruct';
+import { base64 } from './base64';
+export const ChecksumStruct = size(base64(string(), {
+    paddingRequired: true
+}), 44, 44);
+
+//# sourceMappingURL=checksum.js.map

package/dist/esm/checksum.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/checksum.ts"],"sourcesContent":["import { size, string } from 'superstruct';\n\nimport { base64 } from './base64';\n\nexport const ChecksumStruct = size(\n  base64(string(), { paddingRequired: true }),\n  44,\n  44,\n);\n"],"names":["size","string","base64","ChecksumStruct","paddingRequired"],"mappings":"AAAA,SAASA,IAAI,EAAEC,MAAM,QAAQ,cAAc;AAE3C,SAASC,MAAM,QAAQ,WAAW;AAElC,OAAO,MAAMC,iBAAiBH,KAC5BE,OAAOD,UAAU;IAAEG,iBAAiB;AAAK,IACzC,IACA,IACA"}

package/dist/{coercers.js → esm/coercers.js}

@@ -1,16 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHex = exports.createBytes = exports.createBigInt = exports.createNumber = void 0;
-const superstruct_1 = require("superstruct");
-const assert_1 = require("./assert");
-const bytes_1 = require("./bytes");
-const hex_1 = require("./hex");
-const NumberLikeStruct = (0, superstruct_1.union)([(0, superstruct_1.number)(), (0, superstruct_1.bigint)(), (0, superstruct_1.string)(), hex_1.StrictHexStruct]);
-const NumberCoercer = (0, superstruct_1.coerce)((0, superstruct_1.number)(), NumberLikeStruct, Number);
-const BigIntCoercer = (0, superstruct_1.coerce)((0, superstruct_1.bigint)(), NumberLikeStruct, BigInt);
-const BytesLikeStruct = (0, superstruct_1.union)([hex_1.StrictHexStruct, (0, superstruct_1.instance)(Uint8Array)]);
-const BytesCoercer = (0, superstruct_1.coerce)((0, superstruct_1.instance)(Uint8Array), (0, superstruct_1.union)([hex_1.StrictHexStruct]), bytes_1.hexToBytes);
-const HexCoercer = (0, superstruct_1.coerce)(hex_1.StrictHexStruct, (0, superstruct_1.instance)(Uint8Array), bytes_1.bytesToHex);
+import { bigint, coerce, create, instance, number, string, StructError, union } from 'superstruct';
+import { assert } from './assert';
+import { bytesToHex, hexToBytes } from './bytes';
+import { StrictHexStruct } from './hex';
+const NumberLikeStruct = union([
+    number(),
+    bigint(),
+    string(),
+    StrictHexStruct
+]);
+const NumberCoercer = coerce(number(), NumberLikeStruct, Number);
+const BigIntCoercer = coerce(bigint(), NumberLikeStruct, BigInt);
+const BytesLikeStruct = union([
+    StrictHexStruct,
+    instance(Uint8Array)
+]);
+const BytesCoercer = coerce(instance(Uint8Array), union([
+    StrictHexStruct
+]), hexToBytes);
+const HexCoercer = coerce(StrictHexStruct, instance(Uint8Array), bytesToHex);
 /**
  * Create a number from a number-like value.
  *
@@ -35,22 +42,18 @@ const HexCoercer = (0, superstruct_1.coerce)(hex_1.StrictHexStruct, (0, superstr
  * @returns The created number.
  * @throws If the value is not a number-like value, or if the resulting number
  * is `NaN` or `Infinity`.
- */
-function createNumber(value) {
+ */ export function createNumber(value) {
     try {
-        const result = (0, superstruct_1.create)(value, NumberCoercer);
-        (0, assert_1.assert)(Number.isFinite(result), `Expected a number-like value, got "${value}".`);
+        const result = create(value, NumberCoercer);
+        assert(Number.isFinite(result), `Expected a number-like value, got "${value}".`);
         return result;
-    }
-    catch (error) {
-        if (error instanceof superstruct_1.StructError) {
+    } catch (error) {
+        if (error instanceof StructError) {
             throw new Error(`Expected a number-like value, got "${value}".`);
         }
-        /* istanbul ignore next */
-        throw error;
+        /* istanbul ignore next */ throw error;
     }
 }
-exports.createNumber = createNumber;
 /**
  * Create a `bigint` from a number-like value.
  *
@@ -72,22 +75,18 @@ exports.createNumber = createNumber;
  * @param value - The value to create the bigint from.
  * @returns The created bigint.
  * @throws If the value is not a number-like value.
- */
-function createBigInt(value) {
+ */ export function createBigInt(value) {
     try {
         // The `BigInt` constructor throws if the value is not a number-like value.
         // There is no need to validate the value manually.
-        return (0, superstruct_1.create)(value, BigIntCoercer);
-    }
-    catch (error) {
-        if (error instanceof superstruct_1.StructError) {
+        return create(value, BigIntCoercer);
+    } catch (error) {
+        if (error instanceof StructError) {
             throw new Error(`Expected a number-like value, got "${String(error.value)}".`);
         }
-        /* istanbul ignore next */
-        throw error;
+        /* istanbul ignore next */ throw error;
     }
 }
-exports.createBigInt = createBigInt;
 /**
  * Create a byte array from a bytes-like value.
  *
@@ -106,23 +105,19 @@ exports.createBigInt = createBigInt;
  * @param value - The value to create the byte array from.
  * @returns The created byte array.
  * @throws If the value is not a bytes-like value.
- */
-function createBytes(value) {
+ */ export function createBytes(value) {
     if (typeof value === 'string' && value.toLowerCase() === '0x') {
         return new Uint8Array();
     }
     try {
-        return (0, superstruct_1.create)(value, BytesCoercer);
-    }
-    catch (error) {
-        if (error instanceof superstruct_1.StructError) {
+        return create(value, BytesCoercer);
+    } catch (error) {
+        if (error instanceof StructError) {
             throw new Error(`Expected a bytes-like value, got "${String(error.value)}".`);
         }
-        /* istanbul ignore next */
-        throw error;
+        /* istanbul ignore next */ throw error;
     }
 }
-exports.createBytes = createBytes;
 /**
  * Create a hexadecimal string from a bytes-like value.
  *
@@ -141,22 +136,18 @@ exports.createBytes = createBytes;
  * @param value - The value to create the hex string from.
  * @returns The created hex string.
  * @throws If the value is not a bytes-like value.
- */
-function createHex(value) {
-    if ((value instanceof Uint8Array && value.length === 0) ||
-        (typeof value === 'string' && value.toLowerCase() === '0x')) {
+ */ export function createHex(value) {
+    if (value instanceof Uint8Array && value.length === 0 || typeof value === 'string' && value.toLowerCase() === '0x') {
         return '0x';
     }
     try {
-        return (0, superstruct_1.create)(value, HexCoercer);
-    }
-    catch (error) {
-        if (error instanceof superstruct_1.StructError) {
+        return create(value, HexCoercer);
+    } catch (error) {
+        if (error instanceof StructError) {
             throw new Error(`Expected a bytes-like value, got "${String(error.value)}".`);
         }
-        /* istanbul ignore next */
-        throw error;
+        /* istanbul ignore next */ throw error;
     }
 }
-exports.createHex = createHex;
+
 //# sourceMappingURL=coercers.js.map

package/dist/esm/coercers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/coercers.ts"],"sourcesContent":["import type { Infer } from 'superstruct';\nimport {\n  bigint,\n  coerce,\n  create,\n  instance,\n  number,\n  string,\n  StructError,\n  union,\n} from 'superstruct';\n\nimport { assert } from './assert';\nimport { bytesToHex, hexToBytes } from './bytes';\nimport type { Hex } from './hex';\nimport { StrictHexStruct } from './hex';\n\nconst NumberLikeStruct = union([number(), bigint(), string(), StrictHexStruct]);\nconst NumberCoercer = coerce(number(), NumberLikeStruct, Number);\nconst BigIntCoercer = coerce(bigint(), NumberLikeStruct, BigInt);\n\nconst BytesLikeStruct = union([StrictHexStruct, instance(Uint8Array)]);\nconst BytesCoercer = coerce(\n  instance(Uint8Array),\n  union([StrictHexStruct]),\n  hexToBytes,\n);\n\nconst HexCoercer = coerce(StrictHexStruct, instance(Uint8Array), bytesToHex);\n\nexport type NumberLike = Infer<typeof NumberLikeStruct>;\nexport type BytesLike = Infer<typeof BytesLikeStruct>;\n\n/**\n * Create a number from a number-like value.\n *\n * - If the value is a number, it is returned as-is.\n * - If the value is a `bigint`, it is converted to a number.\n * - If the value is a string, it is interpreted as a decimal number.\n * - If the value is a hex string (i.e., it starts with \"0x\"), it is\n * interpreted as a hexadecimal number.\n *\n * This validates that the value is a number-like value, and that the resulting\n * number is not `NaN` or `Infinity`.\n *\n * @example\n * ```typescript\n * const value = createNumber('0x010203');\n * console.log(value); // 66051\n *\n * const otherValue = createNumber(123n);\n * console.log(otherValue); // 123\n * ```\n * @param value - The value to create the number from.\n * @returns The created number.\n * @throws If the value is not a number-like value, or if the resulting number\n * is `NaN` or `Infinity`.\n */\nexport function createNumber(value: NumberLike): number {\n  try {\n    const result = create(value, NumberCoercer);\n\n    assert(\n      Number.isFinite(result),\n      `Expected a number-like value, got \"${value}\".`,\n    );\n\n    return result;\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw new Error(`Expected a number-like value, got \"${value}\".`);\n    }\n\n    /* istanbul ignore next */\n    throw error;\n  }\n}\n\n/**\n * Create a `bigint` from a number-like value.\n *\n * - If the value is a number, it is converted to a `bigint`.\n * - If the value is a `bigint`, it is returned as-is.\n * - If the value is a string, it is interpreted as a decimal number and\n * converted to a `bigint`.\n * - If the value is a hex string (i.e., it starts with \"0x\"), it is\n * interpreted as a hexadecimal number and converted to a `bigint`.\n *\n * @example\n * ```typescript\n * const value = createBigInt('0x010203');\n * console.log(value); // 16909060n\n *\n * const otherValue = createBigInt(123);\n * console.log(otherValue); // 123n\n * ```\n * @param value - The value to create the bigint from.\n * @returns The created bigint.\n * @throws If the value is not a number-like value.\n */\nexport function createBigInt(value: NumberLike): bigint {\n  try {\n    // The `BigInt` constructor throws if the value is not a number-like value.\n    // There is no need to validate the value manually.\n    return create(value, BigIntCoercer);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw new Error(\n        `Expected a number-like value, got \"${String(error.value)}\".`,\n      );\n    }\n\n    /* istanbul ignore next */\n    throw error;\n  }\n}\n\n/**\n * Create a byte array from a bytes-like value.\n *\n * - If the value is a byte array, it is returned as-is.\n * - If the value is a hex string (i.e., it starts with \"0x\"), it is interpreted\n * as a hexadecimal number and converted to a byte array.\n *\n * @example\n * ```typescript\n * const value = createBytes('0x010203');\n * console.log(value); // Uint8Array [ 1, 2, 3 ]\n *\n * const otherValue = createBytes('0x010203');\n * console.log(otherValue); // Uint8Array [ 1, 2, 3 ]\n * ```\n * @param value - The value to create the byte array from.\n * @returns The created byte array.\n * @throws If the value is not a bytes-like value.\n */\nexport function createBytes(value: BytesLike): Uint8Array {\n  if (typeof value === 'string' && value.toLowerCase() === '0x') {\n    return new Uint8Array();\n  }\n\n  try {\n    return create(value, BytesCoercer);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw new Error(\n        `Expected a bytes-like value, got \"${String(error.value)}\".`,\n      );\n    }\n\n    /* istanbul ignore next */\n    throw error;\n  }\n}\n\n/**\n * Create a hexadecimal string from a bytes-like value.\n *\n * - If the value is a hex string (i.e., it starts with \"0x\"), it is returned\n * as-is.\n * - If the value is a `Uint8Array`, it is converted to a hex string.\n *\n * @example\n * ```typescript\n * const value = createHex(new Uint8Array([1, 2, 3]));\n * console.log(value); // '0x010203'\n *\n * const otherValue = createHex('0x010203');\n * console.log(otherValue); // '0x010203'\n * ```\n * @param value - The value to create the hex string from.\n * @returns The created hex string.\n * @throws If the value is not a bytes-like value.\n */\nexport function createHex(value: BytesLike): Hex {\n  if (\n    (value instanceof Uint8Array && value.length === 0) ||\n    (typeof value === 'string' && value.toLowerCase() === '0x')\n  ) {\n    return '0x';\n  }\n\n  try {\n    return create(value, HexCoercer);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw new Error(\n        `Expected a bytes-like value, got \"${String(error.value)}\".`,\n      );\n    }\n\n    /* istanbul ignore next */\n    throw error;\n  }\n}\n"],"names":["bigint","coerce","create","instance","number","string","StructError","union","assert","bytesToHex","hexToBytes","StrictHexStruct","NumberLikeStruct","NumberCoercer","Number","BigIntCoercer","BigInt","BytesLikeStruct","Uint8Array","BytesCoercer","HexCoercer","createNumber","value","result","isFinite","error","Error","createBigInt","String","createBytes","toLowerCase","createHex","length"],"mappings":"AACA,SACEA,MAAM,EACNC,MAAM,EACNC,MAAM,EACNC,QAAQ,EACRC,MAAM,EACNC,MAAM,EACNC,WAAW,EACXC,KAAK,QACA,cAAc;AAErB,SAASC,MAAM,QAAQ,WAAW;AAClC,SAASC,UAAU,EAAEC,UAAU,QAAQ,UAAU;AAEjD,SAASC,eAAe,QAAQ,QAAQ;AAExC,MAAMC,mBAAmBL,MAAM;IAACH;IAAUJ;IAAUK;IAAUM;CAAgB;AAC9E,MAAME,gBAAgBZ,OAAOG,UAAUQ,kBAAkBE;AACzD,MAAMC,gBAAgBd,OAAOD,UAAUY,kBAAkBI;AAEzD,MAAMC,kBAAkBV,MAAM;IAACI;IAAiBR,SAASe;CAAY;AACrE,MAAMC,eAAelB,OACnBE,SAASe,aACTX,MAAM;IAACI;CAAgB,GACvBD;AAGF,MAAMU,aAAanB,OAAOU,iBAAiBR,SAASe,aAAaT;AAKjE;;;;;;;;;;;;;;;;;;;;;;;;CAwBC,GACD,OAAO,SAASY,aAAaC,KAAiB;IAC5C,IAAI;QACF,MAAMC,SAASrB,OAAOoB,OAAOT;QAE7BL,OACEM,OAAOU,QAAQ,CAACD,SAChB,CAAC,mCAAmC,EAAED,MAAM,EAAE,CAAC;QAGjD,OAAOC;IACT,EAAE,OAAOE,OAAO;QACd,IAAIA,iBAAiBnB,aAAa;YAChC,MAAM,IAAIoB,MAAM,CAAC,mCAAmC,EAAEJ,MAAM,EAAE,CAAC;QACjE;QAEA,wBAAwB,GACxB,MAAMG;IACR;AACF;AAEA;;;;;;;;;;;;;;;;;;;;;CAqBC,GACD,OAAO,SAASE,aAAaL,KAAiB;IAC5C,IAAI;QACF,2EAA2E;QAC3E,mDAAmD;QACnD,OAAOpB,OAAOoB,OAAOP;IACvB,EAAE,OAAOU,OAAO;QACd,IAAIA,iBAAiBnB,aAAa;YAChC,MAAM,IAAIoB,MACR,CAAC,mCAAmC,EAAEE,OAAOH,MAAMH,KAAK,EAAE,EAAE,CAAC;QAEjE;QAEA,wBAAwB,GACxB,MAAMG;IACR;AACF;AAEA;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,SAASI,YAAYP,KAAgB;IAC1C,IAAI,OAAOA,UAAU,YAAYA,MAAMQ,WAAW,OAAO,MAAM;QAC7D,OAAO,IAAIZ;IACb;IAEA,IAAI;QACF,OAAOhB,OAAOoB,OAAOH;IACvB,EAAE,OAAOM,OAAO;QACd,IAAIA,iBAAiBnB,aAAa;YAChC,MAAM,IAAIoB,MACR,CAAC,kCAAkC,EAAEE,OAAOH,MAAMH,KAAK,EAAE,EAAE,CAAC;QAEhE;QAEA,wBAAwB,GACxB,MAAMG;IACR;AACF;AAEA;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,SAASM,UAAUT,KAAgB;IACxC,IACE,AAACA,iBAAiBJ,cAAcI,MAAMU,MAAM,KAAK,KAChD,OAAOV,UAAU,YAAYA,MAAMQ,WAAW,OAAO,MACtD;QACA,OAAO;IACT;IAEA,IAAI;QACF,OAAO5B,OAAOoB,OAAOF;IACvB,EAAE,OAAOK,OAAO;QACd,IAAIA,iBAAiBnB,aAAa;YAChC,MAAM,IAAIoB,MACR,CAAC,kCAAkC,EAAEE,OAAOH,MAAMH,KAAK,EAAE,EAAE,CAAC;QAEhE;QAEA,wBAAwB,GACxB,MAAMG;IACR;AACF"}