@metamask/utils 8.3.0 → 8.5.0

package/dist/chunk-THNLGEXV.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/time.ts"],"sourcesContent":["/**\n * Common duration constants, in milliseconds.\n */\nexport enum Duration {\n  /**\n   * A millisecond.\n   */\n  Millisecond = 1,\n\n  /**\n   * A second, in milliseconds.\n   */\n  Second = 1000, // Millisecond * 1000\n\n  /**\n   * A minute, in milliseconds.\n   */\n  Minute = 60_000, // Second * 60\n\n  /**\n   * An hour, in milliseconds.\n   */\n  Hour = 3_600_000, // Minute * 60\n\n  /**\n   * A day, in milliseconds.\n   */\n  Day = 86_400_000, // Hour * 24\n\n  /**\n   * A week, in milliseconds.\n   */\n  Week = 604_800_000, // Day * 7\n\n  /**\n   * A year, in milliseconds.\n   */\n  Year = 31_536_000_000, // Day * 365\n}\n\nconst isNonNegativeInteger = (number: number) =>\n  Number.isInteger(number) && number >= 0;\n\nconst assertIsNonNegativeInteger = (number: number, name: string) => {\n  if (!isNonNegativeInteger(number)) {\n    throw new Error(\n      `\"${name}\" must be a non-negative integer. Received: \"${number}\".`,\n    );\n  }\n};\n\n/**\n * Calculates the millisecond value of the specified number of units of time.\n *\n * @param count - The number of units of time.\n * @param duration - The unit of time to count.\n * @returns The count multiplied by the specified duration.\n */\nexport function inMilliseconds(count: number, duration: Duration): number {\n  assertIsNonNegativeInteger(count, 'count');\n  return count * duration;\n}\n\n/**\n * Gets the milliseconds since a particular Unix epoch timestamp.\n *\n * @param timestamp - A Unix millisecond timestamp.\n * @returns The number of milliseconds elapsed since the specified timestamp.\n */\nexport function timeSince(timestamp: number): number {\n  assertIsNonNegativeInteger(timestamp, 'timestamp');\n  return Date.now() - timestamp;\n}\n"],"mappings":";AAGO,IAAK,WAAL,kBAAKA,cAAL;AAIL,EAAAA,oBAAA,iBAAc,KAAd;AAKA,EAAAA,oBAAA,YAAS,OAAT;AAKA,EAAAA,oBAAA,YAAS,OAAT;AAKA,EAAAA,oBAAA,UAAO,QAAP;AAKA,EAAAA,oBAAA,SAAM,SAAN;AAKA,EAAAA,oBAAA,UAAO,UAAP;AAKA,EAAAA,oBAAA,UAAO,WAAP;AAlCU,SAAAA;AAAA,GAAA;AAqCZ,IAAM,uBAAuB,CAAC,WAC5B,OAAO,UAAU,MAAM,KAAK,UAAU;AAExC,IAAM,6BAA6B,CAAC,QAAgB,SAAiB;AACnE,MAAI,CAAC,qBAAqB,MAAM,GAAG;AACjC,UAAM,IAAI;AAAA,MACR,IAAI,IAAI,gDAAgD,MAAM;AAAA,IAChE;AAAA,EACF;AACF;AASO,SAAS,eAAe,OAAe,UAA4B;AACxE,6BAA2B,OAAO,OAAO;AACzC,SAAO,QAAQ;AACjB;AAQO,SAAS,UAAU,WAA2B;AACnD,6BAA2B,WAAW,WAAW;AACjD,SAAO,KAAK,IAAI,IAAI;AACtB;","names":["Duration"]}

package/dist/chunk-U7ZUGCE7.js

@@ -1,75 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/caip-types.ts
-var _superstruct = require('superstruct');
-var CAIP_CHAIN_ID_REGEX = /^(?<namespace>[-a-z0-9]{3,8}):(?<reference>[-_a-zA-Z0-9]{1,32})$/u;
-var CAIP_NAMESPACE_REGEX = /^[-a-z0-9]{3,8}$/u;
-var CAIP_REFERENCE_REGEX = /^[-_a-zA-Z0-9]{1,32}$/u;
-var CAIP_ACCOUNT_ID_REGEX = /^(?<chainId>(?<namespace>[-a-z0-9]{3,8}):(?<reference>[-_a-zA-Z0-9]{1,32})):(?<accountAddress>[-.%a-zA-Z0-9]{1,128})$/u;
-var CAIP_ACCOUNT_ADDRESS_REGEX = /^[-.%a-zA-Z0-9]{1,128}$/u;
-var CaipChainIdStruct = _superstruct.pattern.call(void 0, _superstruct.string.call(void 0, ), CAIP_CHAIN_ID_REGEX);
-var CaipNamespaceStruct = _superstruct.pattern.call(void 0, _superstruct.string.call(void 0, ), CAIP_NAMESPACE_REGEX);
-var CaipReferenceStruct = _superstruct.pattern.call(void 0, _superstruct.string.call(void 0, ), CAIP_REFERENCE_REGEX);
-var CaipAccountIdStruct = _superstruct.pattern.call(void 0, _superstruct.string.call(void 0, ), CAIP_ACCOUNT_ID_REGEX);
-var CaipAccountAddressStruct = _superstruct.pattern.call(void 0, 
-  _superstruct.string.call(void 0, ),
-  CAIP_ACCOUNT_ADDRESS_REGEX
-);
-function isCaipChainId(value) {
-  return _superstruct.is.call(void 0, value, CaipChainIdStruct);
-}
-function isCaipNamespace(value) {
-  return _superstruct.is.call(void 0, value, CaipNamespaceStruct);
-}
-function isCaipReference(value) {
-  return _superstruct.is.call(void 0, value, CaipReferenceStruct);
-}
-function isCaipAccountId(value) {
-  return _superstruct.is.call(void 0, value, CaipAccountIdStruct);
-}
-function isCaipAccountAddress(value) {
-  return _superstruct.is.call(void 0, value, CaipAccountAddressStruct);
-}
-function parseCaipChainId(caipChainId) {
-  const match = CAIP_CHAIN_ID_REGEX.exec(caipChainId);
-  if (!_optionalChain([match, 'optionalAccess', _ => _.groups])) {
-    throw new Error("Invalid CAIP chain ID.");
-  }
-  return {
-    namespace: match.groups.namespace,
-    reference: match.groups.reference
-  };
-}
-function parseCaipAccountId(caipAccountId) {
-  const match = CAIP_ACCOUNT_ID_REGEX.exec(caipAccountId);
-  if (!_optionalChain([match, 'optionalAccess', _2 => _2.groups])) {
-    throw new Error("Invalid CAIP account ID.");
-  }
-  return {
-    address: match.groups.accountAddress,
-    chainId: match.groups.chainId,
-    chain: {
-      namespace: match.groups.namespace,
-      reference: match.groups.reference
-    }
-  };
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.CAIP_CHAIN_ID_REGEX = CAIP_CHAIN_ID_REGEX; exports.CAIP_NAMESPACE_REGEX = CAIP_NAMESPACE_REGEX; exports.CAIP_REFERENCE_REGEX = CAIP_REFERENCE_REGEX; exports.CAIP_ACCOUNT_ID_REGEX = CAIP_ACCOUNT_ID_REGEX; exports.CAIP_ACCOUNT_ADDRESS_REGEX = CAIP_ACCOUNT_ADDRESS_REGEX; exports.CaipChainIdStruct = CaipChainIdStruct; exports.CaipNamespaceStruct = CaipNamespaceStruct; exports.CaipReferenceStruct = CaipReferenceStruct; exports.CaipAccountIdStruct = CaipAccountIdStruct; exports.CaipAccountAddressStruct = CaipAccountAddressStruct; exports.isCaipChainId = isCaipChainId; exports.isCaipNamespace = isCaipNamespace; exports.isCaipReference = isCaipReference; exports.isCaipAccountId = isCaipAccountId; exports.isCaipAccountAddress = isCaipAccountAddress; exports.parseCaipChainId = parseCaipChainId; exports.parseCaipAccountId = parseCaipAccountId;
-//# sourceMappingURL=chunk-U7ZUGCE7.js.map

package/dist/chunk-U7ZUGCE7.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/caip-types.ts"],"names":[],"mappings":";AACA,SAAS,IAAI,SAAS,cAAc;AAE7B,IAAM,sBACX;AAEK,IAAM,uBAAuB;AAE7B,IAAM,uBAAuB;AAE7B,IAAM,wBACX;AAEK,IAAM,6BAA6B;AAKnC,IAAM,oBAAoB,QAAQ,OAAO,GAAG,mBAAmB;AAM/D,IAAM,sBAAsB,QAAQ,OAAO,GAAG,oBAAoB;AAMlE,IAAM,sBAAsB,QAAQ,OAAO,GAAG,oBAAoB;AAMlE,IAAM,sBAAsB,QAAQ,OAAO,GAAG,qBAAqB;AAMnE,IAAM,2BAA2B;AAAA,EACtC,OAAO;AAAA,EACP;AACF;AASO,SAAS,cAAc,OAAsC;AAClE,SAAO,GAAG,OAAO,iBAAiB;AACpC;AAQO,SAAS,gBAAgB,OAAwC;AACtE,SAAO,GAAG,OAAO,mBAAmB;AACtC;AAQO,SAAS,gBAAgB,OAAwC;AACtE,SAAO,GAAG,OAAO,mBAAmB;AACtC;AAQO,SAAS,gBAAgB,OAAwC;AACtE,SAAO,GAAG,OAAO,mBAAmB;AACtC;AAQO,SAAS,qBACd,OAC6B;AAC7B,SAAO,GAAG,OAAO,wBAAwB;AAC3C;AASO,SAAS,iBAAiB,aAG/B;AACA,QAAM,QAAQ,oBAAoB,KAAK,WAAW;AAClD,MAAI,CAAC,OAAO,QAAQ;AAClB,UAAM,IAAI,MAAM,wBAAwB;AAAA,EAC1C;AAEA,SAAO;AAAA,IACL,WAAW,MAAM,OAAO;AAAA,IACxB,WAAW,MAAM,OAAO;AAAA,EAC1B;AACF;AASO,SAAS,mBAAmB,eAIjC;AACA,QAAM,QAAQ,sBAAsB,KAAK,aAAa;AACtD,MAAI,CAAC,OAAO,QAAQ;AAClB,UAAM,IAAI,MAAM,0BAA0B;AAAA,EAC5C;AAEA,SAAO;AAAA,IACL,SAAS,MAAM,OAAO;AAAA,IACtB,SAAS,MAAM,OAAO;AAAA,IACtB,OAAO;AAAA,MACL,WAAW,MAAM,OAAO;AAAA,MACxB,WAAW,MAAM,OAAO;AAAA,IAC1B;AAAA,EACF;AACF","sourcesContent":["import type { Infer } from 'superstruct';\nimport { is, pattern, string } from 'superstruct';\n\nexport const CAIP_CHAIN_ID_REGEX =\n  /^(?<namespace>[-a-z0-9]{3,8}):(?<reference>[-_a-zA-Z0-9]{1,32})$/u;\n\nexport const CAIP_NAMESPACE_REGEX = /^[-a-z0-9]{3,8}$/u;\n\nexport const CAIP_REFERENCE_REGEX = /^[-_a-zA-Z0-9]{1,32}$/u;\n\nexport const CAIP_ACCOUNT_ID_REGEX =\n  /^(?<chainId>(?<namespace>[-a-z0-9]{3,8}):(?<reference>[-_a-zA-Z0-9]{1,32})):(?<accountAddress>[-.%a-zA-Z0-9]{1,128})$/u;\n\nexport const CAIP_ACCOUNT_ADDRESS_REGEX = /^[-.%a-zA-Z0-9]{1,128}$/u;\n\n/**\n * A CAIP-2 chain ID, i.e., a human-readable namespace and reference.\n */\nexport const CaipChainIdStruct = pattern(string(), CAIP_CHAIN_ID_REGEX);\nexport type CaipChainId = `${string}:${string}`;\n\n/**\n * A CAIP-2 namespace, i.e., the first part of a CAIP chain ID.\n */\nexport const CaipNamespaceStruct = pattern(string(), CAIP_NAMESPACE_REGEX);\nexport type CaipNamespace = Infer<typeof CaipNamespaceStruct>;\n\n/**\n * A CAIP-2 reference, i.e., the second part of a CAIP chain ID.\n */\nexport const CaipReferenceStruct = pattern(string(), CAIP_REFERENCE_REGEX);\nexport type CaipReference = Infer<typeof CaipReferenceStruct>;\n\n/**\n * A CAIP-10 account ID, i.e., a human-readable namespace, reference, and account address.\n */\nexport const CaipAccountIdStruct = pattern(string(), CAIP_ACCOUNT_ID_REGEX);\nexport type CaipAccountId = `${string}:${string}:${string}`;\n\n/**\n * A CAIP-10 account address, i.e., the third part of the CAIP account ID.\n */\nexport const CaipAccountAddressStruct = pattern(\n  string(),\n  CAIP_ACCOUNT_ADDRESS_REGEX,\n);\nexport type CaipAccountAddress = Infer<typeof CaipAccountAddressStruct>;\n\n/**\n * Check if the given value is a {@link CaipChainId}.\n *\n * @param value - The value to check.\n * @returns Whether the value is a {@link CaipChainId}.\n */\nexport function isCaipChainId(value: unknown): value is CaipChainId {\n  return is(value, CaipChainIdStruct);\n}\n\n/**\n * Check if the given value is a {@link CaipNamespace}.\n *\n * @param value - The value to check.\n * @returns Whether the value is a {@link CaipNamespace}.\n */\nexport function isCaipNamespace(value: unknown): value is CaipNamespace {\n  return is(value, CaipNamespaceStruct);\n}\n\n/**\n * Check if the given value is a {@link CaipReference}.\n *\n * @param value - The value to check.\n * @returns Whether the value is a {@link CaipReference}.\n */\nexport function isCaipReference(value: unknown): value is CaipReference {\n  return is(value, CaipReferenceStruct);\n}\n\n/**\n * Check if the given value is a {@link CaipAccountId}.\n *\n * @param value - The value to check.\n * @returns Whether the value is a {@link CaipAccountId}.\n */\nexport function isCaipAccountId(value: unknown): value is CaipAccountId {\n  return is(value, CaipAccountIdStruct);\n}\n\n/**\n * Check if a value is a {@link CaipAccountAddress}.\n *\n * @param value - The value to validate.\n * @returns True if the value is a valid {@link CaipAccountAddress}.\n */\nexport function isCaipAccountAddress(\n  value: unknown,\n): value is CaipAccountAddress {\n  return is(value, CaipAccountAddressStruct);\n}\n\n/**\n * Parse a CAIP-2 chain ID to an object containing the namespace and reference.\n * This validates the CAIP-2 chain ID before parsing it.\n *\n * @param caipChainId - The CAIP-2 chain ID to validate and parse.\n * @returns The parsed CAIP-2 chain ID.\n */\nexport function parseCaipChainId(caipChainId: CaipChainId): {\n  namespace: CaipNamespace;\n  reference: CaipReference;\n} {\n  const match = CAIP_CHAIN_ID_REGEX.exec(caipChainId);\n  if (!match?.groups) {\n    throw new Error('Invalid CAIP chain ID.');\n  }\n\n  return {\n    namespace: match.groups.namespace as CaipNamespace,\n    reference: match.groups.reference as CaipReference,\n  };\n}\n\n/**\n * Parse an CAIP-10 account ID to an object containing the chain ID, parsed chain ID, and account address.\n * This validates the CAIP-10 account ID before parsing it.\n *\n * @param caipAccountId - The CAIP-10 account ID to validate and parse.\n * @returns The parsed CAIP-10 account ID.\n */\nexport function parseCaipAccountId(caipAccountId: CaipAccountId): {\n  address: CaipAccountAddress;\n  chainId: CaipChainId;\n  chain: { namespace: CaipNamespace; reference: CaipReference };\n} {\n  const match = CAIP_ACCOUNT_ID_REGEX.exec(caipAccountId);\n  if (!match?.groups) {\n    throw new Error('Invalid CAIP account ID.');\n  }\n\n  return {\n    address: match.groups.accountAddress as CaipAccountAddress,\n    chainId: match.groups.chainId as CaipChainId,\n    chain: {\n      namespace: match.groups.namespace as CaipNamespace,\n      reference: match.groups.reference as CaipReference,\n    },\n  };\n}\n"]}

package/dist/chunk-UOTVU7OQ.js

@@ -1 +0,0 @@
-"use strict";//# sourceMappingURL=chunk-UOTVU7OQ.js.map

package/dist/chunk-UOTVU7OQ.js.map

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

package/dist/chunk-VA2DRBDE.mjs

@@ -1,273 +0,0 @@
-import {
-  assert
-} from "./chunk-74DGVJVE.mjs";
-
-// src/hex.ts
-import { keccak_256 as keccak256 } from "@noble/hashes/sha3";
-import { is, pattern, string } from "superstruct";
-
-// src/bytes.ts
-import { base64 } from "@scure/base";
-var HEX_MINIMUM_NUMBER_CHARACTER = 48;
-var HEX_MAXIMUM_NUMBER_CHARACTER = 58;
-var HEX_CHARACTER_OFFSET = 87;
-function getPrecomputedHexValuesBuilder() {
-  const lookupTable = [];
-  return () => {
-    if (lookupTable.length === 0) {
-      for (let i = 0; i < 256; i++) {
-        lookupTable.push(i.toString(16).padStart(2, "0"));
-      }
-    }
-    return lookupTable;
-  };
-}
-var getPrecomputedHexValues = getPrecomputedHexValuesBuilder();
-function isBytes(value) {
-  return value instanceof Uint8Array;
-}
-function assertIsBytes(value) {
-  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++) {
-    hexadecimal[i] = lookupTable[bytes[i]];
-  }
-  return 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) {
-    value = (value << BigInt(8)) + BigInt(byte);
-  }
-  return BigInt.asIntN(bytes.length * 8, value);
-}
-function bytesToNumber(bytes) {
-  assertIsBytes(bytes);
-  const bigint = bytesToBigInt(bytes);
-  assert(
-    bigint <= BigInt(Number.MAX_SAFE_INTEGER),
-    "Number is not a safe integer. Use `bytesToBigInt` instead."
-  );
-  return Number(bigint);
-}
-function bytesToString(bytes) {
-  assertIsBytes(bytes);
-  return new TextDecoder().decode(bytes);
-}
-function bytesToBase64(bytes) {
-  assertIsBytes(bytes);
-  return base64.encode(bytes);
-}
-function hexToBytes(value) {
-  if (value?.toLowerCase?.() === "0x") {
-    return new Uint8Array();
-  }
-  assertIsHexString(value);
-  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++) {
-    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) {
-  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);
-}
-function bigIntFits(value, bytes) {
-  assert(bytes > 0);
-  const mask = value >> BigInt(31);
-  return !((~value & mask) + (value & ~mask) >> BigInt(bytes * 8 + ~0));
-}
-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."
-  );
-  let numberValue = value;
-  const bytes = new Uint8Array(byteLength);
-  for (let i = 0; i < bytes.length; i++) {
-    bytes[i] = Number(BigInt.asUintN(8, numberValue));
-    numberValue >>= BigInt(8);
-  }
-  return bytes.reverse();
-}
-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);
-}
-function stringToBytes(value) {
-  assert(typeof value === "string", "Value must be a string.");
-  return new TextEncoder().encode(value);
-}
-function base64ToBytes(value) {
-  assert(typeof value === "string", "Value must be a string.");
-  return base64.decode(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++) {
-    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++) {
-    bytes.set(normalizedValues[i], offset);
-    offset += normalizedValues[i].length;
-  }
-  return bytes;
-}
-function createDataView(bytes) {
-  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);
-}
-
-// src/hex.ts
-var HexStruct = pattern(string(), /^(?:0x)?[0-9a-f]+$/iu);
-var StrictHexStruct = pattern(string(), /^0x[0-9a-f]+$/iu);
-var HexAddressStruct = pattern(
-  string(),
-  /^0x[0-9a-f]{40}$/u
-);
-var HexChecksumAddressStruct = pattern(
-  string(),
-  /^0x[0-9a-fA-F]{40}$/u
-);
-function isHexString(value) {
-  return is(value, HexStruct);
-}
-function isStrictHexString(value) {
-  return is(value, StrictHexStruct);
-}
-function assertIsHexString(value) {
-  assert(isHexString(value), "Value must be a hexadecimal string.");
-}
-function assertIsStrictHexString(value) {
-  assert(
-    isStrictHexString(value),
-    'Value must be a hexadecimal string, starting with "0x".'
-  );
-}
-function isValidHexAddress(possibleAddress) {
-  return is(possibleAddress, HexAddressStruct) || isValidChecksumAddress(possibleAddress);
-}
-function getChecksumAddress(address) {
-  assert(is(address, HexChecksumAddressStruct), "Invalid hex address.");
-  const unPrefixed = remove0x(address.toLowerCase());
-  const unPrefixedHash = remove0x(bytesToHex(keccak256(unPrefixed)));
-  return `0x${unPrefixed.split("").map((character, nibbleIndex) => {
-    const hashCharacter = unPrefixedHash[nibbleIndex];
-    assert(is(hashCharacter, string()), "Hash shorter than address.");
-    return parseInt(hashCharacter, 16) > 7 ? character.toUpperCase() : character;
-  }).join("")}`;
-}
-function isValidChecksumAddress(possibleChecksum) {
-  if (!is(possibleChecksum, HexChecksumAddressStruct)) {
-    return false;
-  }
-  return getChecksumAddress(possibleChecksum) === possibleChecksum;
-}
-function add0x(hexadecimal) {
-  if (hexadecimal.startsWith("0x")) {
-    return hexadecimal;
-  }
-  if (hexadecimal.startsWith("0X")) {
-    return `0x${hexadecimal.substring(2)}`;
-  }
-  return `0x${hexadecimal}`;
-}
-function remove0x(hexadecimal) {
-  if (hexadecimal.startsWith("0x") || hexadecimal.startsWith("0X")) {
-    return hexadecimal.substring(2);
-  }
-  return hexadecimal;
-}
-
-export {
-  HexStruct,
-  StrictHexStruct,
-  HexAddressStruct,
-  HexChecksumAddressStruct,
-  isHexString,
-  isStrictHexString,
-  assertIsHexString,
-  assertIsStrictHexString,
-  isValidHexAddress,
-  getChecksumAddress,
-  isValidChecksumAddress,
-  add0x,
-  remove0x,
-  isBytes,
-  assertIsBytes,
-  bytesToHex,
-  bytesToBigInt,
-  bytesToSignedBigInt,
-  bytesToNumber,
-  bytesToString,
-  bytesToBase64,
-  hexToBytes,
-  bigIntToBytes,
-  signedBigIntToBytes,
-  numberToBytes,
-  stringToBytes,
-  base64ToBytes,
-  valueToBytes,
-  concatBytes,
-  createDataView
-};
-//# sourceMappingURL=chunk-VA2DRBDE.mjs.map

package/dist/chunk-VA2DRBDE.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/hex.ts","../src/bytes.ts"],"sourcesContent":["import { keccak_256 as keccak256 } from '@noble/hashes/sha3';\nimport type { Struct } from 'superstruct';\nimport { is, pattern, string } from 'superstruct';\n\nimport { assert } from './assert';\nimport { bytesToHex } from './bytes';\n\nexport type Hex = `0x${string}`;\n\nexport const HexStruct = pattern(string(), /^(?:0x)?[0-9a-f]+$/iu);\nexport const StrictHexStruct = pattern(string(), /^0x[0-9a-f]+$/iu) as Struct<\n  Hex,\n  null\n>;\nexport const HexAddressStruct = pattern(\n  string(),\n  /^0x[0-9a-f]{40}$/u,\n) as Struct<Hex, null>;\nexport const HexChecksumAddressStruct = pattern(\n  string(),\n  /^0x[0-9a-fA-F]{40}$/u,\n) as Struct<Hex, null>;\n\n/**\n * Check if a string is a valid hex string.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid hex string.\n */\nexport function isHexString(value: unknown): value is string {\n  return is(value, HexStruct);\n}\n\n/**\n * Strictly check if a string is a valid hex string. A valid hex string must\n * start with the \"0x\"-prefix.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid hex string.\n */\nexport function isStrictHexString(value: unknown): value is Hex {\n  return is(value, StrictHexStruct);\n}\n\n/**\n * Assert that a value is a valid hex string.\n *\n * @param value - The value to check.\n * @throws If the value is not a valid hex string.\n */\nexport function assertIsHexString(value: unknown): asserts value is string {\n  assert(isHexString(value), 'Value must be a hexadecimal string.');\n}\n\n/**\n * Assert that a value is a valid hex string. A valid hex string must start with\n * the \"0x\"-prefix.\n *\n * @param value - The value to check.\n * @throws If the value is not a valid hex string.\n */\nexport function assertIsStrictHexString(value: unknown): asserts value is Hex {\n  assert(\n    isStrictHexString(value),\n    'Value must be a hexadecimal string, starting with \"0x\".',\n  );\n}\n\n/**\n * Validate that the passed prefixed hex string is an all-lowercase\n * hex address, or a valid mixed-case checksum address.\n *\n * @param possibleAddress - Input parameter to check against.\n * @returns Whether or not the input is a valid hex address.\n */\nexport function isValidHexAddress(possibleAddress: Hex) {\n  return (\n    is(possibleAddress, HexAddressStruct) ||\n    isValidChecksumAddress(possibleAddress)\n  );\n}\n\n/**\n * Encode a passed hex string as an ERC-55 mixed-case checksum address.\n *\n * @param address - The hex address to encode.\n * @returns The address encoded according to ERC-55.\n * @see https://eips.ethereum.org/EIPS/eip-55\n */\nexport function getChecksumAddress(address: Hex) {\n  assert(is(address, HexChecksumAddressStruct), 'Invalid hex address.');\n  const unPrefixed = remove0x(address.toLowerCase());\n  const unPrefixedHash = remove0x(bytesToHex(keccak256(unPrefixed)));\n  return `0x${unPrefixed\n    .split('')\n    .map((character, nibbleIndex) => {\n      const hashCharacter = unPrefixedHash[nibbleIndex];\n      assert(is(hashCharacter, string()), 'Hash shorter than address.');\n      return parseInt(hashCharacter, 16) > 7\n        ? character.toUpperCase()\n        : character;\n    })\n    .join('')}`;\n}\n\n/**\n * Validate that the passed hex string is a valid ERC-55 mixed-case\n * checksum address.\n *\n * @param possibleChecksum - The hex address to check.\n * @returns True if the address is a checksum address.\n */\nexport function isValidChecksumAddress(possibleChecksum: Hex) {\n  if (!is(possibleChecksum, HexChecksumAddressStruct)) {\n    return false;\n  }\n\n  return getChecksumAddress(possibleChecksum) === possibleChecksum;\n}\n\n/**\n * Add the `0x`-prefix to a hexadecimal string. If the string already has the\n * prefix, it is returned as-is.\n *\n * @param hexadecimal - The hexadecimal string to add the prefix to.\n * @returns The prefixed hexadecimal string.\n */\nexport function add0x(hexadecimal: string): Hex {\n  if (hexadecimal.startsWith('0x')) {\n    return hexadecimal as Hex;\n  }\n\n  if (hexadecimal.startsWith('0X')) {\n    return `0x${hexadecimal.substring(2)}`;\n  }\n\n  return `0x${hexadecimal}`;\n}\n\n/**\n * Remove the `0x`-prefix from a hexadecimal string. If the string doesn't have\n * the prefix, it is returned as-is.\n *\n * @param hexadecimal - The hexadecimal string to remove the prefix from.\n * @returns The un-prefixed hexadecimal string.\n */\nexport function remove0x(hexadecimal: string): string {\n  if (hexadecimal.startsWith('0x') || hexadecimal.startsWith('0X')) {\n    return hexadecimal.substring(2);\n  }\n\n  return hexadecimal;\n}\n","import { base64 } from '@scure/base';\n\nimport { 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 `Uint8Array` to a base64 encoded string.\n *\n * @param bytes - The bytes to convert to a base64 encoded string.\n * @returns The base64 encoded string.\n */\nexport function bytesToBase64(bytes: Uint8Array): string {\n  assertIsBytes(bytes);\n\n  return base64.encode(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 base64 encoded string to a `Uint8Array`.\n *\n * @param value - The base64 encoded string to convert to bytes.\n * @returns The bytes as `Uint8Array`.\n */\nexport function base64ToBytes(value: string): Uint8Array {\n  assert(typeof value === 'string', 'Value must be a string.');\n\n  return base64.decode(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"],"mappings":"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","names":[]}

package/dist/chunk-VFXTVNXN.js

@@ -1,44 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-var _chunkQEPVHEP7js = require('./chunk-QEPVHEP7.js');
-
-
-var _chunk6ZDHSOUVjs = require('./chunk-6ZDHSOUV.js');
-
-// src/number.ts
-var numberToHex = (value) => {
-  _chunk6ZDHSOUVjs.assert.call(void 0, typeof value === "number", "Value must be a number.");
-  _chunk6ZDHSOUVjs.assert.call(void 0, value >= 0, "Value must be a non-negative number.");
-  _chunk6ZDHSOUVjs.assert.call(void 0, 
-    Number.isSafeInteger(value),
-    "Value is not a safe integer. Use `bigIntToHex` instead."
-  );
-  return _chunkQEPVHEP7js.add0x.call(void 0, value.toString(16));
-};
-var bigIntToHex = (value) => {
-  _chunk6ZDHSOUVjs.assert.call(void 0, typeof value === "bigint", "Value must be a bigint.");
-  _chunk6ZDHSOUVjs.assert.call(void 0, value >= 0, "Value must be a non-negative bigint.");
-  return _chunkQEPVHEP7js.add0x.call(void 0, value.toString(16));
-};
-var hexToNumber = (value) => {
-  _chunkQEPVHEP7js.assertIsHexString.call(void 0, value);
-  const numberValue = parseInt(value, 16);
-  _chunk6ZDHSOUVjs.assert.call(void 0, 
-    Number.isSafeInteger(numberValue),
-    "Value is not a safe integer. Use `hexToBigInt` instead."
-  );
-  return numberValue;
-};
-var hexToBigInt = (value) => {
-  _chunkQEPVHEP7js.assertIsHexString.call(void 0, value);
-  return BigInt(_chunkQEPVHEP7js.add0x.call(void 0, value));
-};
-
-
-
-
-
-
-exports.numberToHex = numberToHex; exports.bigIntToHex = bigIntToHex; exports.hexToNumber = hexToNumber; exports.hexToBigInt = hexToBigInt;
-//# sourceMappingURL=chunk-VFXTVNXN.js.map

package/dist/chunk-VFXTVNXN.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/number.ts"],"names":[],"mappings":";;;;;;;;;AAoBO,IAAM,cAAc,CAAC,UAA0B;AACpD,SAAO,OAAO,UAAU,UAAU,yBAAyB;AAC3D,SAAO,SAAS,GAAG,sCAAsC;AACzD;AAAA,IACE,OAAO,cAAc,KAAK;AAAA,IAC1B;AAAA,EACF;AAEA,SAAO,MAAM,MAAM,SAAS,EAAE,CAAC;AACjC;AAkBO,IAAM,cAAc,CAAC,UAA0B;AACpD,SAAO,OAAO,UAAU,UAAU,yBAAyB;AAC3D,SAAO,SAAS,GAAG,sCAAsC;AAEzD,SAAO,MAAM,MAAM,SAAS,EAAE,CAAC;AACjC;AAqBO,IAAM,cAAc,CAAC,UAA0B;AACpD,oBAAkB,KAAK;AAIvB,QAAM,cAAc,SAAS,OAAO,EAAE;AAEtC;AAAA,IACE,OAAO,cAAc,WAAW;AAAA,IAChC;AAAA,EACF;AAEA,SAAO;AACT;AAkBO,IAAM,cAAc,CAAC,UAA0B;AACpD,oBAAkB,KAAK;AAGvB,SAAO,OAAO,MAAM,KAAK,CAAC;AAC5B","sourcesContent":["import { assert } from './assert';\nimport { add0x, assertIsHexString } from './hex';\n\n/**\n * Convert a number to a hexadecimal string. This verifies that the number is a\n * non-negative safe integer.\n *\n * To convert a `bigint` to a hexadecimal string instead, use\n * {@link bigIntToHex}.\n *\n * @example\n * ```typescript\n * numberToHex(0); // '0x0'\n * numberToHex(1); // '0x1'\n * numberToHex(16); // '0x10'\n * ```\n * @param value - The number to convert to a hexadecimal string.\n * @returns The hexadecimal string, with the \"0x\"-prefix.\n * @throws If the number is not a non-negative safe integer.\n */\nexport const numberToHex = (value: number): string => {\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 `bigIntToHex` instead.',\n  );\n\n  return add0x(value.toString(16));\n};\n\n/**\n * Convert a `bigint` to a hexadecimal string. This verifies that the `bigint`\n * is a non-negative integer.\n *\n * To convert a number to a hexadecimal string instead, use {@link numberToHex}.\n *\n * @example\n * ```typescript\n * bigIntToHex(0n); // '0x0'\n * bigIntToHex(1n); // '0x1'\n * bigIntToHex(16n); // '0x10'\n * ```\n * @param value - The `bigint` to convert to a hexadecimal string.\n * @returns The hexadecimal string, with the \"0x\"-prefix.\n * @throws If the `bigint` is not a non-negative integer.\n */\nexport const bigIntToHex = (value: bigint): string => {\n  assert(typeof value === 'bigint', 'Value must be a bigint.');\n  assert(value >= 0, 'Value must be a non-negative bigint.');\n\n  return add0x(value.toString(16));\n};\n\n/**\n * Convert a hexadecimal string to a number. This verifies that the string is a\n * valid hex string, and that the resulting number is a safe integer. Both\n * \"0x\"-prefixed and unprefixed strings are supported.\n *\n * To convert a hexadecimal string to a `bigint` instead, use\n * {@link hexToBigInt}.\n *\n * @example\n * ```typescript\n * hexToNumber('0x0'); // 0\n * hexToNumber('0x1'); // 1\n * hexToNumber('0x10'); // 16\n * ```\n * @param value - The hexadecimal string to convert to a number.\n * @returns The number.\n * @throws If the value is not a valid hexadecimal string, or if the resulting\n * number is not a safe integer.\n */\nexport const hexToNumber = (value: string): number => {\n  assertIsHexString(value);\n\n  // `parseInt` accepts values without the \"0x\"-prefix, whereas `Number` does\n  // not. Using this is slightly faster than `Number(add0x(value))`.\n  const numberValue = parseInt(value, 16);\n\n  assert(\n    Number.isSafeInteger(numberValue),\n    'Value is not a safe integer. Use `hexToBigInt` instead.',\n  );\n\n  return numberValue;\n};\n\n/**\n * Convert a hexadecimal string to a `bigint`. This verifies that the string is\n * a valid hex string. Both \"0x\"-prefixed and unprefixed strings are supported.\n *\n * To convert a hexadecimal string to a number instead, use {@link hexToNumber}.\n *\n * @example\n * ```typescript\n * hexToBigInt('0x0'); // 0n\n * hexToBigInt('0x1'); // 1n\n * hexToBigInt('0x10'); // 16n\n * ```\n * @param value - The hexadecimal string to convert to a `bigint`.\n * @returns The `bigint`.\n * @throws If the value is not a valid hexadecimal string.\n */\nexport const hexToBigInt = (value: string): bigint => {\n  assertIsHexString(value);\n\n  // The `BigInt` constructor requires the \"0x\"-prefix to parse a hex string.\n  return BigInt(add0x(value));\n};\n"]}

package/dist/chunk-WA4DHIND.mjs

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-WA4DHIND.mjs.map

package/dist/chunk-WA4DHIND.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-X66SUIEF.mjs

@@ -1,25 +0,0 @@
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-
-export {
-  __privateGet,
-  __privateAdd,
-  __privateSet
-};
-//# sourceMappingURL=chunk-X66SUIEF.mjs.map

package/dist/chunk-X66SUIEF.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-XYGUOY6N.mjs

@@ -1,55 +0,0 @@
-import {
-  isNullOrUndefined,
-  isObject
-} from "./chunk-H4YFDLB7.mjs";
-
-// src/errors.ts
-import { ErrorWithCause } from "pony-cause";
-function isError(error) {
-  return error instanceof Error || isObject(error) && error.constructor.name === "Error";
-}
-function isErrorWithCode(error) {
-  return typeof error === "object" && error !== null && "code" in error;
-}
-function isErrorWithMessage(error) {
-  return typeof error === "object" && error !== null && "message" in error;
-}
-function isErrorWithStack(error) {
-  return typeof error === "object" && error !== null && "stack" in error;
-}
-function getErrorMessage(error) {
-  if (isErrorWithMessage(error) && typeof error.message === "string") {
-    return error.message;
-  }
-  if (isNullOrUndefined(error)) {
-    return "";
-  }
-  return String(error);
-}
-function wrapError(originalError, message) {
-  if (isError(originalError)) {
-    let error;
-    if (Error.length === 2) {
-      error = new Error(message, { cause: originalError });
-    } else {
-      error = new ErrorWithCause(message, { cause: originalError });
-    }
-    if (isErrorWithCode(originalError)) {
-      error.code = originalError.code;
-    }
-    return error;
-  }
-  if (message.length > 0) {
-    return new Error(`${String(originalError)}: ${message}`);
-  }
-  return new Error(String(originalError));
-}
-
-export {
-  isErrorWithCode,
-  isErrorWithMessage,
-  isErrorWithStack,
-  getErrorMessage,
-  wrapError
-};
-//# sourceMappingURL=chunk-XYGUOY6N.mjs.map

package/dist/chunk-XYGUOY6N.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/errors.ts"],"sourcesContent":["import { ErrorWithCause } from 'pony-cause';\n\nimport { isNullOrUndefined, isObject } from './misc';\n\n/**\n * Type guard for determining whether the given value is an instance of Error.\n * For errors generated via `fs.promises`, `error instanceof Error` won't work,\n * so we have to come up with another way of testing.\n *\n * @param error - The object to check.\n * @returns A boolean.\n */\nfunction isError(error: unknown): error is Error {\n  return (\n    error instanceof Error ||\n    (isObject(error) && error.constructor.name === 'Error')\n  );\n}\n\n/**\n * Type guard for determining whether the given value is an error object with a\n * `code` property such as the type of error that Node throws for filesystem\n * operations, etc.\n *\n * @param error - The object to check.\n * @returns A boolean.\n */\nexport function isErrorWithCode(error: unknown): error is { code: string } {\n  return typeof error === 'object' && error !== null && 'code' in error;\n}\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 A boolean.\n */\nexport function isErrorWithMessage(\n  error: unknown,\n): error is { message: string } {\n  return typeof error === 'object' && error !== null && 'message' in error;\n}\n\n/**\n * Type guard for determining whether the given value is an error object with a\n * `stack` property, such as an instance of Error.\n *\n * @param error - The object to check.\n * @returns A boolean.\n */\nexport function isErrorWithStack(error: unknown): error is { stack: string } {\n  return typeof error === 'object' && error !== null && 'stack' in error;\n}\n\n/**\n * Attempts to obtain the message from a possible error object, defaulting to an\n * empty string if it is impossible to do so.\n *\n * @param error - The possible error to get the message from.\n * @returns The message if `error` is an object with a `message` property;\n * the string version of `error` if it is not `undefined` or `null`; otherwise\n * an empty string.\n */\nexport function getErrorMessage(error: unknown): string {\n  if (isErrorWithMessage(error) && typeof error.message === 'string') {\n    return error.message;\n  }\n\n  if (isNullOrUndefined(error)) {\n    return '';\n  }\n\n  return String(error);\n}\n\n/**\n * Builds a new error object, linking it to the original error via the `cause`\n * property if it is an Error.\n *\n * This function is useful to reframe error messages in general, but is\n * _critical_ when interacting with any of Node's filesystem functions as\n * provided via `fs.promises`, because these do not produce stack traces in the\n * case of an I/O error (see <https://github.com/nodejs/node/issues/30944>).\n *\n * @param originalError - The error to be wrapped (something throwable).\n * @param message - The desired message of the new error.\n * @returns A new error object.\n */\nexport function wrapError<Throwable>(\n  originalError: Throwable,\n  message: string,\n): Error & { code?: string } {\n  if (isError(originalError)) {\n    let error: Error & { code?: string };\n    if (Error.length === 2) {\n      // for some reason `tsserver` is not complaining that the\n      // Error constructor doesn't support a second argument in the editor,\n      // but `tsc` does. Error causes are not supported by our current tsc target (ES2020, we need ES2022 to make this work)\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      error = new Error(message, { cause: originalError });\n    } else {\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      error = new ErrorWithCause(message, { cause: originalError });\n    }\n\n    if (isErrorWithCode(originalError)) {\n      error.code = originalError.code;\n    }\n\n    return error;\n  }\n\n  if (message.length > 0) {\n    return new Error(`${String(originalError)}: ${message}`);\n  }\n\n  return new Error(String(originalError));\n}\n"],"mappings":";;;;;;AAAA,SAAS,sBAAsB;AAY/B,SAAS,QAAQ,OAAgC;AAC/C,SACE,iBAAiB,SAChB,SAAS,KAAK,KAAK,MAAM,YAAY,SAAS;AAEnD;AAUO,SAAS,gBAAgB,OAA2C;AACzE,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU;AAClE;AASO,SAAS,mBACd,OAC8B;AAC9B,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,aAAa;AACrE;AASO,SAAS,iBAAiB,OAA4C;AAC3E,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,WAAW;AACnE;AAWO,SAAS,gBAAgB,OAAwB;AACtD,MAAI,mBAAmB,KAAK,KAAK,OAAO,MAAM,YAAY,UAAU;AAClE,WAAO,MAAM;AAAA,EACf;AAEA,MAAI,kBAAkB,KAAK,GAAG;AAC5B,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,KAAK;AACrB;AAeO,SAAS,UACd,eACA,SAC2B;AAC3B,MAAI,QAAQ,aAAa,GAAG;AAC1B,QAAI;AACJ,QAAI,MAAM,WAAW,GAAG;AAMtB,cAAQ,IAAI,MAAM,SAAS,EAAE,OAAO,cAAc,CAAC;AAAA,IACrD,OAAO;AAGL,cAAQ,IAAI,eAAe,SAAS,EAAE,OAAO,cAAc,CAAC;AAAA,IAC9D;AAEA,QAAI,gBAAgB,aAAa,GAAG;AAClC,YAAM,OAAO,cAAc;AAAA,IAC7B;AAEA,WAAO;AAAA,EACT;AAEA,MAAI,QAAQ,SAAS,GAAG;AACtB,WAAO,IAAI,MAAM,GAAG,OAAO,aAAa,CAAC,KAAK,OAAO,EAAE;AAAA,EACzD;AAEA,SAAO,IAAI,MAAM,OAAO,aAAa,CAAC;AACxC;","names":[]}