@metamask/utils 8.0.0 → 8.2.0

package/dist/cjs/versions.js

@@ -1,79 +0,0 @@
-"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, {
-    VersionStruct: function() {
-        return VersionStruct;
-    },
-    VersionRangeStruct: function() {
-        return VersionRangeStruct;
-    },
-    isValidSemVerVersion: function() {
-        return isValidSemVerVersion;
-    },
-    isValidSemVerRange: function() {
-        return isValidSemVerRange;
-    },
-    assertIsSemVerVersion: function() {
-        return assertIsSemVerVersion;
-    },
-    assertIsSemVerRange: function() {
-        return assertIsSemVerRange;
-    },
-    gtVersion: function() {
-        return gtVersion;
-    },
-    gtRange: function() {
-        return gtRange;
-    },
-    satisfiesVersionRange: function() {
-        return satisfiesVersionRange;
-    }
-});
-const _semver = require("semver");
-const _superstruct = require("superstruct");
-const _assert = require("./assert");
-const VersionStruct = (0, _superstruct.refine)((0, _superstruct.string)(), 'Version', (value)=>{
-    if ((0, _semver.valid)(value) === null) {
-        return `Expected SemVer version, got "${value}"`;
-    }
-    return true;
-});
-const VersionRangeStruct = (0, _superstruct.refine)((0, _superstruct.string)(), 'Version range', (value)=>{
-    if ((0, _semver.validRange)(value) === null) {
-        return `Expected SemVer range, got "${value}"`;
-    }
-    return true;
-});
-function isValidSemVerVersion(version) {
-    return (0, _superstruct.is)(version, VersionStruct);
-}
-function isValidSemVerRange(versionRange) {
-    return (0, _superstruct.is)(versionRange, VersionRangeStruct);
-}
-function assertIsSemVerVersion(version) {
-    (0, _assert.assertStruct)(version, VersionStruct);
-}
-function assertIsSemVerRange(range) {
-    (0, _assert.assertStruct)(range, VersionRangeStruct);
-}
-function gtVersion(version1, version2) {
-    return (0, _semver.gt)(version1, version2);
-}
-function gtRange(version, range) {
-    return (0, _semver.gtr)(version, range);
-}
-function satisfiesVersionRange(version, versionRange) {
-    return (0, _semver.satisfies)(version, versionRange, {
-        includePrerelease: true
-    });
-}
-
-//# sourceMappingURL=versions.js.map

package/dist/cjs/versions.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/versions.ts"],"sourcesContent":["import {\n  gt as gtSemver,\n  gtr as gtrSemver,\n  satisfies as satisfiesSemver,\n  valid as validSemVerVersion,\n  validRange as validSemVerRange,\n} from 'semver';\nimport type { Struct } from 'superstruct';\nimport { is, refine, string } from 'superstruct';\n\nimport { assertStruct } from './assert';\nimport type { Opaque } from './opaque';\n\n/**\n * {@link https://codemix.com/opaque-types-in-javascript/ Opaque} type for SemVer ranges.\n *\n * @example Use {@link assertIsSemVerRange} and {@link isValidSemVerRange} to cast to proper type.\n * ```typescript\n * const unsafeRange: string = dataFromUser();\n * assertIsSemVerRange(unsafeRange);\n * unsafeRange\n * // ^? SemVerRange\n * ```\n * @example If you know what you're doing and want to side-step type safety, casting from a string works correctly.\n * ```typescript\n * const unsafeRange: string = dataFromUser();\n * unsafeRange as SemVerRange;\n * // ^? SemVerRange\n * ```\n * @see {@link assertIsSemVerRange}\n * @see {@link isValidSemVerRange}\n */\nexport type SemVerRange = Opaque<string, typeof semVerRange>;\ndeclare const semVerRange: unique symbol;\n\n/**\n * {@link https://codemix.com/opaque-types-in-javascript/ Opaque} type for singular SemVer version.\n *\n * @example Use {@link assertIsSemVerVersion} and {@link isValidSemVerVersion} to cast to proper type.\n * ```typescript\n * const unsafeVersion: string = dataFromUser();\n * assertIsSemVerVersion(unsafeRange);\n * unsafeVersion\n * // ^? SemVerVersion\n * ```\n * @example If you know what you're doing and want to side-step type safety, casting from a string works correctly.\n * ```typescript\n * const unsafeVersion: string = dataFromUser();\n * unsafeRange as SemVerVersion;\n * // ^? SemVerVersion\n * ```\n * @see {@link assertIsSemVerVersion}\n * @see {@link isValidSemVerVersion}\n */\nexport type SemVerVersion = Opaque<string, typeof semVerVersion>;\ndeclare const semVerVersion: unique symbol;\n\n/**\n * A struct for validating a version string.\n */\nexport const VersionStruct = refine<SemVerVersion, null>(\n  string() as unknown as Struct<SemVerVersion, null>,\n  'Version',\n  (value) => {\n    if (validSemVerVersion(value) === null) {\n      return `Expected SemVer version, got \"${value}\"`;\n    }\n    return true;\n  },\n);\n\nexport const VersionRangeStruct = refine<SemVerRange, null>(\n  string() as unknown as Struct<SemVerRange, null>,\n  'Version range',\n  (value) => {\n    if (validSemVerRange(value) === null) {\n      return `Expected SemVer range, got \"${value}\"`;\n    }\n    return true;\n  },\n);\n\n/**\n * Checks whether a SemVer version is valid.\n *\n * @param version - A potential version.\n * @returns `true` if the version is valid, and `false` otherwise.\n */\nexport function isValidSemVerVersion(\n  version: unknown,\n): version is SemVerVersion {\n  return is(version, VersionStruct);\n}\n\n/**\n * Checks whether a SemVer version range is valid.\n *\n * @param versionRange - A potential version range.\n * @returns `true` if the version range is valid, and `false` otherwise.\n */\nexport function isValidSemVerRange(\n  versionRange: unknown,\n): versionRange is SemVerRange {\n  return is(versionRange, VersionRangeStruct);\n}\n\n/**\n * Asserts that a value is a valid concrete SemVer version.\n *\n * @param version - A potential SemVer concrete version.\n */\nexport function assertIsSemVerVersion(\n  version: unknown,\n): asserts version is SemVerVersion {\n  assertStruct(version, VersionStruct);\n}\n\n/**\n * Asserts that a value is a valid SemVer range.\n *\n * @param range - A potential SemVer range.\n */\nexport function assertIsSemVerRange(\n  range: unknown,\n): asserts range is SemVerRange {\n  assertStruct(range, VersionRangeStruct);\n}\n\n/**\n * Checks whether a SemVer version is greater than another.\n *\n * @param version1 - The left-hand version.\n * @param version2 - The right-hand version.\n * @returns `version1 > version2`.\n */\nexport function gtVersion(\n  version1: SemVerVersion,\n  version2: SemVerVersion,\n): boolean {\n  return gtSemver(version1, version2);\n}\n\n/**\n * Checks whether a SemVer version is greater than all possibilities in a range.\n *\n * @param version - A SemvVer version.\n * @param range - The range to check against.\n * @returns `version > range`.\n */\nexport function gtRange(version: SemVerVersion, range: SemVerRange): boolean {\n  return gtrSemver(version, range);\n}\n\n/**\n * Returns whether a SemVer version satisfies a SemVer range.\n *\n * @param version - The SemVer version to check.\n * @param versionRange - The SemVer version range to check against.\n * @returns Whether the version satisfied the version range.\n */\nexport function satisfiesVersionRange(\n  version: SemVerVersion,\n  versionRange: SemVerRange,\n): boolean {\n  return satisfiesSemver(version, versionRange, {\n    includePrerelease: true,\n  });\n}\n"],"names":["VersionStruct","VersionRangeStruct","isValidSemVerVersion","isValidSemVerRange","assertIsSemVerVersion","assertIsSemVerRange","gtVersion","gtRange","satisfiesVersionRange","refine","string","value","validSemVerVersion","validSemVerRange","version","is","versionRange","assertStruct","range","version1","version2","gtSemver","gtrSemver","satisfiesSemver","includePrerelease"],"mappings":";;;;;;;;;;;IA4DaA,aAAa;eAAbA;;IAWAC,kBAAkB;eAAlBA;;IAiBGC,oBAAoB;eAApBA;;IAYAC,kBAAkB;eAAlBA;;IAWAC,qBAAqB;eAArBA;;IAWAC,mBAAmB;eAAnBA;;IAaAC,SAAS;eAATA;;IAcAC,OAAO;eAAPA;;IAWAC,qBAAqB;eAArBA;;;wBA1JT;6BAE4B;wBAEN;AAkDtB,MAAMR,gBAAgBS,IAAAA,mBAAM,EACjCC,IAAAA,mBAAM,KACN,WACA,CAACC;IACC,IAAIC,IAAAA,aAAkB,EAACD,WAAW,MAAM;QACtC,OAAO,CAAC,8BAA8B,EAAEA,MAAM,CAAC,CAAC;IAClD;IACA,OAAO;AACT;AAGK,MAAMV,qBAAqBQ,IAAAA,mBAAM,EACtCC,IAAAA,mBAAM,KACN,iBACA,CAACC;IACC,IAAIE,IAAAA,kBAAgB,EAACF,WAAW,MAAM;QACpC,OAAO,CAAC,4BAA4B,EAAEA,MAAM,CAAC,CAAC;IAChD;IACA,OAAO;AACT;AASK,SAAST,qBACdY,OAAgB;IAEhB,OAAOC,IAAAA,eAAE,EAACD,SAASd;AACrB;AAQO,SAASG,mBACda,YAAqB;IAErB,OAAOD,IAAAA,eAAE,EAACC,cAAcf;AAC1B;AAOO,SAASG,sBACdU,OAAgB;IAEhBG,IAAAA,oBAAY,EAACH,SAASd;AACxB;AAOO,SAASK,oBACda,KAAc;IAEdD,IAAAA,oBAAY,EAACC,OAAOjB;AACtB;AASO,SAASK,UACda,QAAuB,EACvBC,QAAuB;IAEvB,OAAOC,IAAAA,UAAQ,EAACF,UAAUC;AAC5B;AASO,SAASb,QAAQO,OAAsB,EAAEI,KAAkB;IAChE,OAAOI,IAAAA,WAAS,EAACR,SAASI;AAC5B;AASO,SAASV,sBACdM,OAAsB,EACtBE,YAAyB;IAEzB,OAAOO,IAAAA,iBAAe,EAACT,SAASE,cAAc;QAC5CQ,mBAAmB;IACrB;AACF"}

package/dist/esm/assert.js

@@ -1,133 +0,0 @@
-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;
-}
-import { assert as assertSuperstruct } from 'superstruct';
-/**
- * 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
-    });
-}
-/**
- * The default error class that is thrown if an assertion fails.
- */ export class AssertionError extends Error {
-    constructor(options){
-        super(options.message);
-        _define_property(this, "code", 'ERR_ASSERTION');
-    }
-}
-/**
- * Same as Node.js assert.
- * If the value is falsy, throws an error, does nothing otherwise.
- *
- * @throws {@link AssertionError} If value is falsy.
- * @param value - The test that should be truthy to pass.
- * @param message - Message to be passed to {@link AssertionError} or an
- * {@link Error} instance to throw.
- * @param ErrorWrapper - The error class to throw if the assertion fails.
- * Defaults to {@link AssertionError}. If a custom error class is provided for
- * the `message` argument, this argument is ignored.
- */ export 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);
-    }
-}
-/**
- * Assert a value against a Superstruct struct.
- *
- * @param value - The value to validate.
- * @param struct - The struct to validate against.
- * @param errorPrefix - A prefix to add to the error message. Defaults to
- * "Assertion failed".
- * @param ErrorWrapper - The error class to throw if the assertion fails.
- * Defaults to {@link AssertionError}.
- * @throws If the value is not valid.
- */ export function assertStruct(value, struct, errorPrefix = 'Assertion failed', // eslint-disable-next-line @typescript-eslint/naming-convention
-ErrorWrapper = AssertionError) {
-    try {
-        assertSuperstruct(value, struct);
-    } catch (error) {
-        throw getError(ErrorWrapper, `${errorPrefix}: ${getErrorMessage(error)}.`);
-    }
-}
-/**
- * Use in the default case of a switch that you want to be fully exhaustive.
- * Using this function forces the compiler to enforce exhaustivity during
- * compile-time.
- *
- * @example
- * ```
- * const number = 1;
- * switch (number) {
- *   case 0:
- *     ...
- *   case 1:
- *     ...
- *   default:
- *     assertExhaustive(snapPrefix);
- * }
- * ```
- * @param _object - The object on which the switch is being operated.
- */ export function assertExhaustive(_object) {
-    throw new Error('Invalid branch reached. Should be detected during compilation.');
-}
-
-//# sourceMappingURL=assert.js.map

package/dist/esm/assert.js.map

@@ -1 +0,0 @@
-{"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":["assert","assertSuperstruct","isErrorWithMessage","error","isConstructable","fn","Boolean","prototype","constructor","name","getErrorMessage","message","String","endsWith","slice","getError","ErrorWrapper","AssertionError","Error","options","code","value","assertStruct","struct","errorPrefix","assertExhaustive","_object"],"mappings":";;;;;;;;;;;;;AACA,SAASA,UAAUC,iBAAiB,QAAQ,cAAc;AAM1D;;;;;;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;AAEA;;CAEC,GACD,OAAO,MAAMM,uBAAuBC;IAGlCV,YAAYW,OAA4B,CAAE;QACxC,KAAK,CAACA,QAAQR,OAAO;QAHvB,uBAASS,QAAO;IAIhB;AACF;AAEA;;;;;;;;;;;CAWC,GACD,OAAO,SAASpB,OACdqB,KAAU,EACVV,UAA0B,mBAAmB,EAC7C,gEAAgE;AAChEK,eAA0CC,cAAc;IAExD,IAAI,CAACI,OAAO;QACV,IAAIV,mBAAmBO,OAAO;YAC5B,MAAMP;QACR;QAEA,MAAMI,SAASC,cAAcL;IAC/B;AACF;AAEA;;;;;;;;;;CAUC,GACD,OAAO,SAASW,aACdD,KAAc,EACdE,MAA4B,EAC5BC,cAAc,kBAAkB,EAChC,gEAAgE;AAChER,eAA0CC,cAAc;IAExD,IAAI;QACFhB,kBAAkBoB,OAAOE;IAC3B,EAAE,OAAOpB,OAAO;QACd,MAAMY,SAASC,cAAc,CAAC,EAAEQ,YAAY,EAAE,EAAEd,gBAAgBP,OAAO,CAAC,CAAC;IAC3E;AACF;AAEA;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,SAASsB,iBAAiBC,OAAc;IAC7C,MAAM,IAAIR,MACR;AAEJ"}

package/dist/esm/base64.js

@@ -1,28 +0,0 @@
-import { pattern } from 'superstruct';
-import { assert } from './assert';
-/**
- * Ensure that a provided string-based struct is valid base64.
- *
- * @param struct - The string based struct.
- * @param options - Optional options to specialize base64 validation. See {@link Base64Options} documentation.
- * @returns A superstruct validating base64.
- */ export 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 {
-        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 pattern(struct, re);
-};
-
-//# sourceMappingURL=base64.js.map

package/dist/esm/base64.js.map

@@ -1 +0,0 @@
-{"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":["pattern","assert","base64","struct","options","paddingRequired","characterSet","letters","String","raw","re","RegExp"],"mappings":"AACA,SAASA,OAAO,QAAQ,cAAc;AAEtC,SAASC,MAAM,QAAQ,WAAW;AAmBlC;;;;;;CAMC,GACD,OAAO,MAAMC,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;QACLR,OAAOK,iBAAiB;QACxBC,UAAUC,OAAOC,GAAG,CAAC,aAAa,CAAC;IACrC;IAEA,IAAIC;IACJ,IAAIL,iBAAiB;QACnBK,KAAK,IAAIC,OACP,CAAC,IAAI,EAAEJ,QAAQ,QAAQ,EAAEA,QAAQ,KAAK,EAAEA,QAAQ,QAAQ,CAAC,EACzD;IAEJ,OAAO;QACLG,KAAK,IAAIC,OACP,CAAC,IAAI,EAAEJ,QAAQ,QAAQ,EAAEA,QAAQ,MAAM,EAAEA,QAAQ,KAAK,EAAEA,QAAQ,QAAQ,CAAC,EACzE;IAEJ;IAEA,OAAOP,QAAQG,QAAQO;AACzB,EAAE"}

package/dist/esm/bytes.js

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

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