@metamask/utils 6.1.0 → 7.0.0

package/CHANGELOG.md

@@ -6,6 +6,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [7.0.0]
+### Added
+- Add `getKnownPropertyNames` function ([#111](https://github.com/MetaMask/utils/pull/111))
+
+### Changed
+- **BREAKING:** Build the package as both CJS and ESM ([#115](https://github.com/MetaMask/utils/pull/115), [#124](https://github.com/MetaMask/utils/pull/124))
+  - It's no longer possible to import from the `dist` folder. Everything must be imported from `@metamask/utils`.
+- Bump `semver` to `^7.5.4` ([#123](https://github.com/MetaMask/utils/pull/123))
+
+## [6.2.0]
+### Added
+- Add address related utils ([#112](https://github.com/MetaMask/utils/pull/112))
+  - `isValidHexAddress` has been added to check the validity of an hex address
+  - `getChecksumAddress` has been added to calculate the ERC-55 mixed-case checksum of an hex address
+  - `isValidChecksumAddress` has been added to check the validity of an ERC-55 mixed-case checksum address
+
 ## [6.1.0]
 ### Added
 - Add optional `destroy` method to `Keyring` type ([#108](https://github.com/MetaMask/utils/pull/108))
@@ -158,7 +174,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Initial release
 
-[Unreleased]: https://github.com/MetaMask/utils/compare/v6.1.0...HEAD
+[Unreleased]: https://github.com/MetaMask/utils/compare/v7.0.0...HEAD
+[7.0.0]: https://github.com/MetaMask/utils/compare/v6.2.0...v7.0.0
+[6.2.0]: https://github.com/MetaMask/utils/compare/v6.1.0...v6.2.0
 [6.1.0]: https://github.com/MetaMask/utils/compare/v6.0.1...v6.1.0
 [6.0.1]: https://github.com/MetaMask/utils/compare/v6.0.0...v6.0.1
 [6.0.0]: https://github.com/MetaMask/utils/compare/v5.0.2...v6.0.0

package/dist/cjs/assert.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AssertionError: function() {
+        return AssertionError;
+    },
+    assert: function() {
+        return assert;
+    },
+    assertStruct: function() {
+        return assertStruct;
+    },
+    assertExhaustive: function() {
+        return assertExhaustive;
+    }
+});
+const _superstruct = require("superstruct");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Type guard for determining whether the given value is an error object with a
+ * `message` property, such as an instance of Error.
+ *
+ * @param error - The object to check.
+ * @returns True or false, depending on the result.
+ */ function isErrorWithMessage(error) {
+    return typeof error === 'object' && error !== null && 'message' in error;
+}
+/**
+ * Check if a value is a constructor, i.e., a function that can be called with
+ * the `new` keyword.
+ *
+ * @param fn - The value to check.
+ * @returns `true` if the value is a constructor, or `false` otherwise.
+ */ function isConstructable(fn) {
+    /* istanbul ignore next */ return Boolean(typeof fn?.prototype?.constructor?.name === 'string');
+}
+/**
+ * Get the error message from an unknown error object. If the error object has
+ * a `message` property, that property is returned. Otherwise, the stringified
+ * error object is returned.
+ *
+ * @param error - The error object to get the message from.
+ * @returns The error message.
+ */ function getErrorMessage(error) {
+    const message = isErrorWithMessage(error) ? error.message : String(error);
+    // If the error ends with a period, remove it, as we'll add our own period.
+    if (message.endsWith('.')) {
+        return message.slice(0, -1);
+    }
+    return message;
+}
+/**
+ * Initialise an {@link AssertionErrorConstructor} error.
+ *
+ * @param ErrorWrapper - The error class to use.
+ * @param message - The error message.
+ * @returns The error object.
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
+function getError(ErrorWrapper, message) {
+    if (isConstructable(ErrorWrapper)) {
+        return new ErrorWrapper({
+            message
+        });
+    }
+    return ErrorWrapper({
+        message
+    });
+}
+class AssertionError extends Error {
+    constructor(options){
+        super(options.message);
+        _define_property(this, "code", 'ERR_ASSERTION');
+    }
+}
+function assert(value, message = 'Assertion failed.', // eslint-disable-next-line @typescript-eslint/naming-convention
+ErrorWrapper = AssertionError) {
+    if (!value) {
+        if (message instanceof Error) {
+            throw message;
+        }
+        throw getError(ErrorWrapper, message);
+    }
+}
+function assertStruct(value, struct, errorPrefix = 'Assertion failed', // eslint-disable-next-line @typescript-eslint/naming-convention
+ErrorWrapper = AssertionError) {
+    try {
+        (0, _superstruct.assert)(value, struct);
+    } catch (error) {
+        throw getError(ErrorWrapper, `${errorPrefix}: ${getErrorMessage(error)}.`);
+    }
+}
+function assertExhaustive(_object) {
+    throw new Error('Invalid branch reached. Should be detected during compilation.');
+}
+
+//# sourceMappingURL=assert.js.map

package/dist/cjs/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/assert.ts"],"sourcesContent":["import type { Struct } from 'superstruct';\nimport { assert as assertSuperstruct } from 'superstruct';\n\nexport type AssertionErrorConstructor =\n  | (new (args: { message: string }) => Error)\n  | ((args: { message: string }) => Error);\n\n/**\n * Type guard for determining whether the given value is an error object with a\n * `message` property, such as an instance of Error.\n *\n * @param error - The object to check.\n * @returns True or false, depending on the result.\n */\nfunction isErrorWithMessage(error: unknown): error is { message: string } {\n  return typeof error === 'object' && error !== null && 'message' in error;\n}\n\n/**\n * Check if a value is a constructor, i.e., a function that can be called with\n * the `new` keyword.\n *\n * @param fn - The value to check.\n * @returns `true` if the value is a constructor, or `false` otherwise.\n */\nfunction isConstructable(\n  fn: AssertionErrorConstructor,\n): fn is new (args: { message: string }) => Error {\n  /* istanbul ignore next */\n  return Boolean(typeof fn?.prototype?.constructor?.name === 'string');\n}\n\n/**\n * Get the error message from an unknown error object. If the error object has\n * a `message` property, that property is returned. Otherwise, the stringified\n * error object is returned.\n *\n * @param error - The error object to get the message from.\n * @returns The error message.\n */\nfunction getErrorMessage(error: unknown): string {\n  const message = isErrorWithMessage(error) ? error.message : String(error);\n\n  // If the error ends with a period, remove it, as we'll add our own period.\n  if (message.endsWith('.')) {\n    return message.slice(0, -1);\n  }\n\n  return message;\n}\n\n/**\n * Initialise an {@link AssertionErrorConstructor} error.\n *\n * @param ErrorWrapper - The error class to use.\n * @param message - The error message.\n * @returns The error object.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction getError(ErrorWrapper: AssertionErrorConstructor, message: string) {\n  if (isConstructable(ErrorWrapper)) {\n    return new ErrorWrapper({\n      message,\n    });\n  }\n  return ErrorWrapper({\n    message,\n  });\n}\n\n/**\n * The default error class that is thrown if an assertion fails.\n */\nexport class AssertionError extends Error {\n  readonly code = 'ERR_ASSERTION';\n\n  constructor(options: { message: string }) {\n    super(options.message);\n  }\n}\n\n/**\n * Same as Node.js assert.\n * If the value is falsy, throws an error, does nothing otherwise.\n *\n * @throws {@link AssertionError} If value is falsy.\n * @param value - The test that should be truthy to pass.\n * @param message - Message to be passed to {@link AssertionError} or an\n * {@link Error} instance to throw.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}. If a custom error class is provided for\n * the `message` argument, this argument is ignored.\n */\nexport function assert(\n  value: any,\n  message: string | Error = 'Assertion failed.',\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper: AssertionErrorConstructor = AssertionError,\n): asserts value {\n  if (!value) {\n    if (message instanceof Error) {\n      throw message;\n    }\n\n    throw getError(ErrorWrapper, message);\n  }\n}\n\n/**\n * Assert a value against a Superstruct struct.\n *\n * @param value - The value to validate.\n * @param struct - The struct to validate against.\n * @param errorPrefix - A prefix to add to the error message. Defaults to\n * \"Assertion failed\".\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the value is not valid.\n */\nexport function assertStruct<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  errorPrefix = 'Assertion failed',\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper: AssertionErrorConstructor = AssertionError,\n): asserts value is Type {\n  try {\n    assertSuperstruct(value, struct);\n  } catch (error) {\n    throw getError(ErrorWrapper, `${errorPrefix}: ${getErrorMessage(error)}.`);\n  }\n}\n\n/**\n * Use in the default case of a switch that you want to be fully exhaustive.\n * Using this function forces the compiler to enforce exhaustivity during\n * compile-time.\n *\n * @example\n * ```\n * const number = 1;\n * switch (number) {\n *   case 0:\n *     ...\n *   case 1:\n *     ...\n *   default:\n *     assertExhaustive(snapPrefix);\n * }\n * ```\n * @param _object - The object on which the switch is being operated.\n */\nexport function assertExhaustive(_object: never): never {\n  throw new Error(\n    'Invalid branch reached. Should be detected during compilation.',\n  );\n}\n"],"names":["AssertionError","assert","assertStruct","assertExhaustive","isErrorWithMessage","error","isConstructable","fn","Boolean","prototype","constructor","name","getErrorMessage","message","String","endsWith","slice","getError","ErrorWrapper","Error","options","code","value","struct","errorPrefix","assertSuperstruct","_object"],"mappings":";;;;;;;;;;;IAyEaA,cAAc;eAAdA;;IAoBGC,MAAM;eAANA;;IA0BAC,YAAY;eAAZA;;IAiCAC,gBAAgB;eAAhBA;;;6BAvJ4B;;;;;;;;;;;;;;AAM5C;;;;;;CAMC,GACD,SAASC,mBAAmBC,KAAc;IACxC,OAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,aAAaA;AACrE;AAEA;;;;;;CAMC,GACD,SAASC,gBACPC,EAA6B;IAE7B,wBAAwB,GACxB,OAAOC,QAAQ,OAAOD,IAAIE,WAAWC,aAAaC,SAAS;AAC7D;AAEA;;;;;;;CAOC,GACD,SAASC,gBAAgBP,KAAc;IACrC,MAAMQ,UAAUT,mBAAmBC,SAASA,MAAMQ,OAAO,GAAGC,OAAOT;IAEnE,2EAA2E;IAC3E,IAAIQ,QAAQE,QAAQ,CAAC,MAAM;QACzB,OAAOF,QAAQG,KAAK,CAAC,GAAG,CAAC;IAC3B;IAEA,OAAOH;AACT;AAEA;;;;;;CAMC,GACD,gEAAgE;AAChE,SAASI,SAASC,YAAuC,EAAEL,OAAe;IACxE,IAAIP,gBAAgBY,eAAe;QACjC,OAAO,IAAIA,aAAa;YACtBL;QACF;IACF;IACA,OAAOK,aAAa;QAClBL;IACF;AACF;AAKO,MAAMb,uBAAuBmB;IAGlCT,YAAYU,OAA4B,CAAE;QACxC,KAAK,CAACA,QAAQP,OAAO;QAHvB,uBAASQ,QAAO;IAIhB;AACF;AAcO,SAASpB,OACdqB,KAAU,EACVT,UAA0B,mBAAmB,EAC7C,gEAAgE;AAChEK,eAA0ClB,cAAc;IAExD,IAAI,CAACsB,OAAO;QACV,IAAIT,mBAAmBM,OAAO;YAC5B,MAAMN;QACR;QAEA,MAAMI,SAASC,cAAcL;IAC/B;AACF;AAaO,SAASX,aACdoB,KAAc,EACdC,MAA4B,EAC5BC,cAAc,kBAAkB,EAChC,gEAAgE;AAChEN,eAA0ClB,cAAc;IAExD,IAAI;QACFyB,IAAAA,mBAAiB,EAACH,OAAOC;IAC3B,EAAE,OAAOlB,OAAO;QACd,MAAMY,SAASC,cAAc,CAAC,EAAEM,YAAY,EAAE,EAAEZ,gBAAgBP,OAAO,CAAC,CAAC;IAC3E;AACF;AAqBO,SAASF,iBAAiBuB,OAAc;IAC7C,MAAM,IAAIP,MACR;AAEJ"}

package/dist/cjs/base64.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "base64", {
+    enumerable: true,
+    get: function() {
+        return base64;
+    }
+});
+const _superstruct = require("superstruct");
+const _assert = require("./assert");
+const base64 = (struct, options = {})=>{
+    const paddingRequired = options.paddingRequired ?? false;
+    const characterSet = options.characterSet ?? 'base64';
+    let letters;
+    if (characterSet === 'base64') {
+        letters = String.raw`[A-Za-z0-9+\/]`;
+    } else {
+        (0, _assert.assert)(characterSet === 'base64url');
+        letters = String.raw`[-_A-Za-z0-9]`;
+    }
+    let re;
+    if (paddingRequired) {
+        re = new RegExp(`^(?:${letters}{4})*(?:${letters}{3}=|${letters}{2}==)?$`, 'u');
+    } else {
+        re = new RegExp(`^(?:${letters}{4})*(?:${letters}{2,3}|${letters}{3}=|${letters}{2}==)?$`, 'u');
+    }
+    return (0, _superstruct.pattern)(struct, re);
+};
+
+//# sourceMappingURL=base64.js.map

package/dist/cjs/base64.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/base64.ts"],"sourcesContent":["import type { Struct } from 'superstruct';\nimport { pattern } from 'superstruct';\n\nimport { assert } from './assert';\n\nexport type Base64Options = {\n  /**\n   * Is the `=` padding at the end required or not.\n   *\n   * @default false\n   */\n  // Padding is optional in RFC 4648, that's why the default value is false\n  paddingRequired?: boolean;\n  /**\n   * Which character set should be used.\n   * The sets are based on {@link https://datatracker.ietf.org/doc/html/rfc4648 RFC 4648}.\n   *\n   * @default 'base64'\n   */\n  characterSet?: 'base64' | 'base64url';\n};\n\n/**\n * Ensure that a provided string-based struct is valid base64.\n *\n * @param struct - The string based struct.\n * @param options - Optional options to specialize base64 validation. See {@link Base64Options} documentation.\n * @returns A superstruct validating base64.\n */\nexport const base64 = <Type extends string, Schema>(\n  struct: Struct<Type, Schema>,\n  options: Base64Options = {},\n) => {\n  const paddingRequired = options.paddingRequired ?? false;\n  const characterSet = options.characterSet ?? 'base64';\n\n  let letters: string;\n  if (characterSet === 'base64') {\n    letters = String.raw`[A-Za-z0-9+\\/]`;\n  } else {\n    assert(characterSet === 'base64url');\n    letters = String.raw`[-_A-Za-z0-9]`;\n  }\n\n  let re: RegExp;\n  if (paddingRequired) {\n    re = new RegExp(\n      `^(?:${letters}{4})*(?:${letters}{3}=|${letters}{2}==)?$`,\n      'u',\n    );\n  } else {\n    re = new RegExp(\n      `^(?:${letters}{4})*(?:${letters}{2,3}|${letters}{3}=|${letters}{2}==)?$`,\n      'u',\n    );\n  }\n\n  return pattern(struct, re);\n};\n"],"names":["base64","struct","options","paddingRequired","characterSet","letters","String","raw","assert","re","RegExp","pattern"],"mappings":";;;;+BA6BaA;;;eAAAA;;;6BA5BW;wBAED;AA0BhB,MAAMA,SAAS,CACpBC,QACAC,UAAyB,CAAC,CAAC;IAE3B,MAAMC,kBAAkBD,QAAQC,eAAe,IAAI;IACnD,MAAMC,eAAeF,QAAQE,YAAY,IAAI;IAE7C,IAAIC;IACJ,IAAID,iBAAiB,UAAU;QAC7BC,UAAUC,OAAOC,GAAG,CAAC,cAAc,CAAC;IACtC,OAAO;QACLC,IAAAA,cAAM,EAACJ,iBAAiB;QACxBC,UAAUC,OAAOC,GAAG,CAAC,aAAa,CAAC;IACrC;IAEA,IAAIE;IACJ,IAAIN,iBAAiB;QACnBM,KAAK,IAAIC,OACP,CAAC,IAAI,EAAEL,QAAQ,QAAQ,EAAEA,QAAQ,KAAK,EAAEA,QAAQ,QAAQ,CAAC,EACzD;IAEJ,OAAO;QACLI,KAAK,IAAIC,OACP,CAAC,IAAI,EAAEL,QAAQ,QAAQ,EAAEA,QAAQ,MAAM,EAAEA,QAAQ,KAAK,EAAEA,QAAQ,QAAQ,CAAC,EACzE;IAEJ;IAEA,OAAOM,IAAAA,oBAAO,EAACV,QAAQQ;AACzB"}

package/dist/cjs/bytes.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isBytes: function() {
+        return isBytes;
+    },
+    assertIsBytes: function() {
+        return assertIsBytes;
+    },
+    bytesToHex: function() {
+        return bytesToHex;
+    },
+    bytesToBigInt: function() {
+        return bytesToBigInt;
+    },
+    bytesToSignedBigInt: function() {
+        return bytesToSignedBigInt;
+    },
+    bytesToNumber: function() {
+        return bytesToNumber;
+    },
+    bytesToString: function() {
+        return bytesToString;
+    },
+    hexToBytes: function() {
+        return hexToBytes;
+    },
+    bigIntToBytes: function() {
+        return bigIntToBytes;
+    },
+    signedBigIntToBytes: function() {
+        return signedBigIntToBytes;
+    },
+    numberToBytes: function() {
+        return numberToBytes;
+    },
+    stringToBytes: function() {
+        return stringToBytes;
+    },
+    valueToBytes: function() {
+        return valueToBytes;
+    },
+    concatBytes: function() {
+        return concatBytes;
+    },
+    createDataView: function() {
+        return createDataView;
+    }
+});
+const _assert = require("./assert");
+const _hex = require("./hex");
+// '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();
+function isBytes(value) {
+    return value instanceof Uint8Array;
+}
+function assertIsBytes(value) {
+    (0, _assert.assert)(isBytes(value), 'Value must be a Uint8Array.');
+}
+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++){
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        hexadecimal[i] = lookupTable[bytes[i]];
+    }
+    return (0, _hex.add0x)(hexadecimal.join(''));
+}
+function bytesToBigInt(bytes) {
+    assertIsBytes(bytes);
+    const hexadecimal = bytesToHex(bytes);
+    return BigInt(hexadecimal);
+}
+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);
+}
+function bytesToNumber(bytes) {
+    assertIsBytes(bytes);
+    const bigint = bytesToBigInt(bytes);
+    (0, _assert.assert)(bigint <= BigInt(Number.MAX_SAFE_INTEGER), 'Number is not a safe integer. Use `bytesToBigInt` instead.');
+    return Number(bigint);
+}
+function bytesToString(bytes) {
+    assertIsBytes(bytes);
+    return new TextDecoder().decode(bytes);
+}
+function hexToBytes(value) {
+    // "0x" is often used as empty byte array.
+    if (value?.toLowerCase?.() === '0x') {
+        return new Uint8Array();
+    }
+    (0, _hex.assertIsHexString)(value);
+    // Remove the `0x` prefix if it exists, and pad the string to have an even
+    // number of characters.
+    const strippedValue = (0, _hex.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;
+}
+function bigIntToBytes(value) {
+    (0, _assert.assert)(typeof value === 'bigint', 'Value must be a bigint.');
+    (0, _assert.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) {
+    (0, _assert.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 signedBigIntToBytes(value, byteLength) {
+    (0, _assert.assert)(typeof value === 'bigint', 'Value must be a bigint.');
+    (0, _assert.assert)(typeof byteLength === 'number', 'Byte length must be a number.');
+    (0, _assert.assert)(byteLength > 0, 'Byte length must be greater than 0.');
+    (0, _assert.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();
+}
+function numberToBytes(value) {
+    (0, _assert.assert)(typeof value === 'number', 'Value must be a number.');
+    (0, _assert.assert)(value >= 0, 'Value must be a non-negative number.');
+    (0, _assert.assert)(Number.isSafeInteger(value), 'Value is not a safe integer. Use `bigIntToBytes` instead.');
+    const hexadecimal = value.toString(16);
+    return hexToBytes(hexadecimal);
+}
+function stringToBytes(value) {
+    (0, _assert.assert)(typeof value === 'string', 'Value must be a string.');
+    return new TextEncoder().encode(value);
+}
+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 (isBytes(value)) {
+        return value;
+    }
+    throw new TypeError(`Unsupported value type: "${typeof value}".`);
+}
+function concatBytes(values) {
+    const normalizedValues = new Array(values.length);
+    let byteLength = 0;
+    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++){
+        // 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);
+        offset += normalizedValues[i].length;
+    }
+    return bytes;
+}
+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
+    if (typeof Buffer !== 'undefined' && bytes instanceof Buffer) {
+        const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+        return new DataView(buffer);
+    }
+    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+
+//# sourceMappingURL=bytes.js.map

package/dist/cjs/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":["isBytes","assertIsBytes","bytesToHex","bytesToBigInt","bytesToSignedBigInt","bytesToNumber","bytesToString","hexToBytes","bigIntToBytes","signedBigIntToBytes","numberToBytes","stringToBytes","valueToBytes","concatBytes","createDataView","HEX_MINIMUM_NUMBER_CHARACTER","HEX_MAXIMUM_NUMBER_CHARACTER","HEX_CHARACTER_OFFSET","getPrecomputedHexValuesBuilder","lookupTable","length","i","push","toString","padStart","getPrecomputedHexValues","value","Uint8Array","assert","bytes","hexadecimal","Array","add0x","join","BigInt","byte","asIntN","bigint","Number","MAX_SAFE_INTEGER","TextDecoder","decode","toLowerCase","assertIsHexString","strippedValue","remove0x","normalizedValue","c1","charCodeAt","c2","n1","n2","bigIntFits","mask","byteLength","numberValue","asUintN","reverse","isSafeInteger","TextEncoder","encode","startsWith","TypeError","values","normalizedValues","offset","set","Buffer","buffer","slice","byteOffset","DataView"],"mappings":"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"}

package/dist/cjs/checksum.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ChecksumStruct", {
+    enumerable: true,
+    get: function() {
+        return ChecksumStruct;
+    }
+});
+const _superstruct = require("superstruct");
+const _base64 = require("./base64");
+const ChecksumStruct = (0, _superstruct.size)((0, _base64.base64)((0, _superstruct.string)(), {
+    paddingRequired: true
+}), 44, 44);
+
+//# sourceMappingURL=checksum.js.map

package/dist/cjs/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":["ChecksumStruct","size","base64","string","paddingRequired"],"mappings":";;;;+BAIaA;;;eAAAA;;;6BAJgB;wBAEN;AAEhB,MAAMA,iBAAiBC,IAAAA,iBAAI,EAChCC,IAAAA,cAAM,EAACC,IAAAA,mBAAM,KAAI;IAAEC,iBAAiB;AAAK,IACzC,IACA"}

package/dist/cjs/coercers.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createNumber: function() {
+        return createNumber;
+    },
+    createBigInt: function() {
+        return createBigInt;
+    },
+    createBytes: function() {
+        return createBytes;
+    },
+    createHex: function() {
+        return createHex;
+    }
+});
+const _superstruct = require("superstruct");
+const _assert = require("./assert");
+const _bytes = require("./bytes");
+const _hex = require("./hex");
+const NumberLikeStruct = (0, _superstruct.union)([
+    (0, _superstruct.number)(),
+    (0, _superstruct.bigint)(),
+    (0, _superstruct.string)(),
+    _hex.StrictHexStruct
+]);
+const NumberCoercer = (0, _superstruct.coerce)((0, _superstruct.number)(), NumberLikeStruct, Number);
+const BigIntCoercer = (0, _superstruct.coerce)((0, _superstruct.bigint)(), NumberLikeStruct, BigInt);
+const BytesLikeStruct = (0, _superstruct.union)([
+    _hex.StrictHexStruct,
+    (0, _superstruct.instance)(Uint8Array)
+]);
+const BytesCoercer = (0, _superstruct.coerce)((0, _superstruct.instance)(Uint8Array), (0, _superstruct.union)([
+    _hex.StrictHexStruct
+]), _bytes.hexToBytes);
+const HexCoercer = (0, _superstruct.coerce)(_hex.StrictHexStruct, (0, _superstruct.instance)(Uint8Array), _bytes.bytesToHex);
+function createNumber(value) {
+    try {
+        const result = (0, _superstruct.create)(value, NumberCoercer);
+        (0, _assert.assert)(Number.isFinite(result), `Expected a number-like value, got "${value}".`);
+        return result;
+    } catch (error) {
+        if (error instanceof _superstruct.StructError) {
+            throw new Error(`Expected a number-like value, got "${value}".`);
+        }
+        /* istanbul ignore next */ throw error;
+    }
+}
+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.create)(value, BigIntCoercer);
+    } catch (error) {
+        if (error instanceof _superstruct.StructError) {
+            throw new Error(`Expected a number-like value, got "${String(error.value)}".`);
+        }
+        /* istanbul ignore next */ throw error;
+    }
+}
+function createBytes(value) {
+    if (typeof value === 'string' && value.toLowerCase() === '0x') {
+        return new Uint8Array();
+    }
+    try {
+        return (0, _superstruct.create)(value, BytesCoercer);
+    } catch (error) {
+        if (error instanceof _superstruct.StructError) {
+            throw new Error(`Expected a bytes-like value, got "${String(error.value)}".`);
+        }
+        /* istanbul ignore next */ throw error;
+    }
+}
+function createHex(value) {
+    if (value instanceof Uint8Array && value.length === 0 || typeof value === 'string' && value.toLowerCase() === '0x') {
+        return '0x';
+    }
+    try {
+        return (0, _superstruct.create)(value, HexCoercer);
+    } catch (error) {
+        if (error instanceof _superstruct.StructError) {
+            throw new Error(`Expected a bytes-like value, got "${String(error.value)}".`);
+        }
+        /* istanbul ignore next */ throw error;
+    }
+}
+
+//# sourceMappingURL=coercers.js.map

package/dist/cjs/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":["createNumber","createBigInt","createBytes","createHex","NumberLikeStruct","union","number","bigint","string","StrictHexStruct","NumberCoercer","coerce","Number","BigIntCoercer","BigInt","BytesLikeStruct","instance","Uint8Array","BytesCoercer","hexToBytes","HexCoercer","bytesToHex","value","result","create","assert","isFinite","error","StructError","Error","String","toLowerCase","length"],"mappings":";;;;;;;;;;;IA0DgBA,YAAY;eAAZA;;IA0CAC,YAAY;eAAZA;;IAoCAC,WAAW;eAAXA;;IAsCAC,SAAS;eAATA;;;6BApKT;wBAEgB;uBACgB;qBAEP;AAEhC,MAAMC,mBAAmBC,IAAAA,kBAAK,EAAC;IAACC,IAAAA,mBAAM;IAAIC,IAAAA,mBAAM;IAAIC,IAAAA,mBAAM;IAAIC,oBAAe;CAAC;AAC9E,MAAMC,gBAAgBC,IAAAA,mBAAM,EAACL,IAAAA,mBAAM,KAAIF,kBAAkBQ;AACzD,MAAMC,gBAAgBF,IAAAA,mBAAM,EAACJ,IAAAA,mBAAM,KAAIH,kBAAkBU;AAEzD,MAAMC,kBAAkBV,IAAAA,kBAAK,EAAC;IAACI,oBAAe;IAAEO,IAAAA,qBAAQ,EAACC;CAAY;AACrE,MAAMC,eAAeP,IAAAA,mBAAM,EACzBK,IAAAA,qBAAQ,EAACC,aACTZ,IAAAA,kBAAK,EAAC;IAACI,oBAAe;CAAC,GACvBU,iBAAU;AAGZ,MAAMC,aAAaT,IAAAA,mBAAM,EAACF,oBAAe,EAAEO,IAAAA,qBAAQ,EAACC,aAAaI,iBAAU;AA8BpE,SAASrB,aAAasB,KAAiB;IAC5C,IAAI;QACF,MAAMC,SAASC,IAAAA,mBAAM,EAACF,OAAOZ;QAE7Be,IAAAA,cAAM,EACJb,OAAOc,QAAQ,CAACH,SAChB,CAAC,mCAAmC,EAAED,MAAM,EAAE,CAAC;QAGjD,OAAOC;IACT,EAAE,OAAOI,OAAO;QACd,IAAIA,iBAAiBC,wBAAW,EAAE;YAChC,MAAM,IAAIC,MAAM,CAAC,mCAAmC,EAAEP,MAAM,EAAE,CAAC;QACjE;QAEA,wBAAwB,GACxB,MAAMK;IACR;AACF;AAwBO,SAAS1B,aAAaqB,KAAiB;IAC5C,IAAI;QACF,2EAA2E;QAC3E,mDAAmD;QACnD,OAAOE,IAAAA,mBAAM,EAACF,OAAOT;IACvB,EAAE,OAAOc,OAAO;QACd,IAAIA,iBAAiBC,wBAAW,EAAE;YAChC,MAAM,IAAIC,MACR,CAAC,mCAAmC,EAAEC,OAAOH,MAAML,KAAK,EAAE,EAAE,CAAC;QAEjE;QAEA,wBAAwB,GACxB,MAAMK;IACR;AACF;AAqBO,SAASzB,YAAYoB,KAAgB;IAC1C,IAAI,OAAOA,UAAU,YAAYA,MAAMS,WAAW,OAAO,MAAM;QAC7D,OAAO,IAAId;IACb;IAEA,IAAI;QACF,OAAOO,IAAAA,mBAAM,EAACF,OAAOJ;IACvB,EAAE,OAAOS,OAAO;QACd,IAAIA,iBAAiBC,wBAAW,EAAE;YAChC,MAAM,IAAIC,MACR,CAAC,kCAAkC,EAAEC,OAAOH,MAAML,KAAK,EAAE,EAAE,CAAC;QAEhE;QAEA,wBAAwB,GACxB,MAAMK;IACR;AACF;AAqBO,SAASxB,UAAUmB,KAAgB;IACxC,IACE,AAACA,iBAAiBL,cAAcK,MAAMU,MAAM,KAAK,KAChD,OAAOV,UAAU,YAAYA,MAAMS,WAAW,OAAO,MACtD;QACA,OAAO;IACT;IAEA,IAAI;QACF,OAAOP,IAAAA,mBAAM,EAACF,OAAOF;IACvB,EAAE,OAAOO,OAAO;QACd,IAAIA,iBAAiBC,wBAAW,EAAE;YAChC,MAAM,IAAIC,MACR,CAAC,kCAAkC,EAAEC,OAAOH,MAAML,KAAK,EAAE,EAAE,CAAC;QAEhE;QAEA,wBAAwB,GACxB,MAAMK;IACR;AACF"}