@metamask/utils 6.2.0 → 7.1.0

package/dist/cjs/versions.js

@@ -0,0 +1,79 @@
+"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

@@ -0,0 +1 @@
+{"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/{assert.js → esm/assert.js}

@@ -1,15 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertExhaustive = exports.assertStruct = exports.assert = exports.AssertionError = void 0;
-const superstruct_1 = require("superstruct");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+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) {
+ */ function isErrorWithMessage(error) {
     return typeof error === 'object' && error !== null && 'message' in error;
 }
 /**
@@ -18,10 +27,8 @@ function isErrorWithMessage(error) {
  *
  * @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');
+ */ 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
@@ -30,8 +37,7 @@ function isConstructable(fn) {
  *
  * @param error - The error object to get the message from.
  * @returns The error message.
- */
-function getErrorMessage(error) {
+ */ 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('.')) {
@@ -45,28 +51,25 @@ function getErrorMessage(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
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
 function getError(ErrorWrapper, message) {
     if (isConstructable(ErrorWrapper)) {
         return new ErrorWrapper({
-            message,
+            message
         });
     }
     return ErrorWrapper({
-        message,
+        message
     });
 }
 /**
  * The default error class that is thrown if an assertion fails.
- */
-class AssertionError extends Error {
-    constructor(options) {
+ */ export class AssertionError extends Error {
+    constructor(options){
         super(options.message);
-        this.code = 'ERR_ASSERTION';
+        _define_property(this, "code", 'ERR_ASSERTION');
     }
 }
-exports.AssertionError = AssertionError;
 /**
  * Same as Node.js assert.
  * If the value is falsy, throws an error, does nothing otherwise.
@@ -78,9 +81,7 @@ exports.AssertionError = AssertionError;
  * @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.
- */
-function assert(value, message = 'Assertion failed.', 
-// eslint-disable-next-line @typescript-eslint/naming-convention
+ */ export function assert(value, message = 'Assertion failed.', // eslint-disable-next-line @typescript-eslint/naming-convention
 ErrorWrapper = AssertionError) {
     if (!value) {
         if (message instanceof Error) {
@@ -89,7 +90,6 @@ ErrorWrapper = AssertionError) {
         throw getError(ErrorWrapper, message);
     }
 }
-exports.assert = assert;
 /**
  * Assert a value against a Superstruct struct.
  *
@@ -100,18 +100,14 @@ exports.assert = assert;
  * @param ErrorWrapper - The error class to throw if the assertion fails.
  * Defaults to {@link AssertionError}.
  * @throws If the value is not valid.
- */
-function assertStruct(value, struct, errorPrefix = 'Assertion failed', 
-// eslint-disable-next-line @typescript-eslint/naming-convention
+ */ export function assertStruct(value, struct, errorPrefix = 'Assertion failed', // eslint-disable-next-line @typescript-eslint/naming-convention
 ErrorWrapper = AssertionError) {
     try {
-        (0, superstruct_1.assert)(value, struct);
-    }
-    catch (error) {
+        assertSuperstruct(value, struct);
+    } catch (error) {
         throw getError(ErrorWrapper, `${errorPrefix}: ${getErrorMessage(error)}.`);
     }
 }
-exports.assertStruct = assertStruct;
 /**
  * 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
@@ -130,9 +126,8 @@ exports.assertStruct = assertStruct;
  * }
  * ```
  * @param _object - The object on which the switch is being operated.
- */
-function assertExhaustive(_object) {
+ */ export function assertExhaustive(_object) {
     throw new Error('Invalid branch reached. Should be detected during compilation.');
 }
-exports.assertExhaustive = assertExhaustive;
+
 //# sourceMappingURL=assert.js.map

package/dist/esm/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/assert.ts"],"sourcesContent":["import type { Struct } from 'superstruct';\nimport { assert as assertSuperstruct } from 'superstruct';\n\nexport type AssertionErrorConstructor =\n  | (new (args: { message: string }) => Error)\n  | ((args: { message: string }) => Error);\n\n/**\n * Type guard for determining whether the given value is an error object with a\n * `message` property, such as an instance of Error.\n *\n * @param error - The object to check.\n * @returns True or false, depending on the result.\n */\nfunction isErrorWithMessage(error: unknown): error is { message: string } {\n  return typeof error === 'object' && error !== null && 'message' in error;\n}\n\n/**\n * Check if a value is a constructor, i.e., a function that can be called with\n * the `new` keyword.\n *\n * @param fn - The value to check.\n * @returns `true` if the value is a constructor, or `false` otherwise.\n */\nfunction isConstructable(\n  fn: AssertionErrorConstructor,\n): fn is new (args: { message: string }) => Error {\n  /* istanbul ignore next */\n  return Boolean(typeof fn?.prototype?.constructor?.name === 'string');\n}\n\n/**\n * Get the error message from an unknown error object. If the error object has\n * a `message` property, that property is returned. Otherwise, the stringified\n * error object is returned.\n *\n * @param error - The error object to get the message from.\n * @returns The error message.\n */\nfunction getErrorMessage(error: unknown): string {\n  const message = isErrorWithMessage(error) ? error.message : String(error);\n\n  // If the error ends with a period, remove it, as we'll add our own period.\n  if (message.endsWith('.')) {\n    return message.slice(0, -1);\n  }\n\n  return message;\n}\n\n/**\n * Initialise an {@link AssertionErrorConstructor} error.\n *\n * @param ErrorWrapper - The error class to use.\n * @param message - The error message.\n * @returns The error object.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction getError(ErrorWrapper: AssertionErrorConstructor, message: string) {\n  if (isConstructable(ErrorWrapper)) {\n    return new ErrorWrapper({\n      message,\n    });\n  }\n  return ErrorWrapper({\n    message,\n  });\n}\n\n/**\n * The default error class that is thrown if an assertion fails.\n */\nexport class AssertionError extends Error {\n  readonly code = 'ERR_ASSERTION';\n\n  constructor(options: { message: string }) {\n    super(options.message);\n  }\n}\n\n/**\n * Same as Node.js assert.\n * If the value is falsy, throws an error, does nothing otherwise.\n *\n * @throws {@link AssertionError} If value is falsy.\n * @param value - The test that should be truthy to pass.\n * @param message - Message to be passed to {@link AssertionError} or an\n * {@link Error} instance to throw.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}. If a custom error class is provided for\n * the `message` argument, this argument is ignored.\n */\nexport function assert(\n  value: any,\n  message: string | Error = 'Assertion failed.',\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper: AssertionErrorConstructor = AssertionError,\n): asserts value {\n  if (!value) {\n    if (message instanceof Error) {\n      throw message;\n    }\n\n    throw getError(ErrorWrapper, message);\n  }\n}\n\n/**\n * Assert a value against a Superstruct struct.\n *\n * @param value - The value to validate.\n * @param struct - The struct to validate against.\n * @param errorPrefix - A prefix to add to the error message. Defaults to\n * \"Assertion failed\".\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the value is not valid.\n */\nexport function assertStruct<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  errorPrefix = 'Assertion failed',\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper: AssertionErrorConstructor = AssertionError,\n): asserts value is Type {\n  try {\n    assertSuperstruct(value, struct);\n  } catch (error) {\n    throw getError(ErrorWrapper, `${errorPrefix}: ${getErrorMessage(error)}.`);\n  }\n}\n\n/**\n * Use in the default case of a switch that you want to be fully exhaustive.\n * Using this function forces the compiler to enforce exhaustivity during\n * compile-time.\n *\n * @example\n * ```\n * const number = 1;\n * switch (number) {\n *   case 0:\n *     ...\n *   case 1:\n *     ...\n *   default:\n *     assertExhaustive(snapPrefix);\n * }\n * ```\n * @param _object - The object on which the switch is being operated.\n */\nexport function assertExhaustive(_object: never): never {\n  throw new Error(\n    'Invalid branch reached. Should be detected during compilation.',\n  );\n}\n"],"names":["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/{base64.js → esm/base64.js}

@@ -1,34 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.base64 = void 0;
-const superstruct_1 = require("superstruct");
-const assert_1 = require("./assert");
+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.
- */
-const base64 = (struct, options = {}) => {
+ */ 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 {
-        (0, assert_1.assert)(characterSet === 'base64url');
-        letters = String.raw `[-_A-Za-z0-9]`;
+        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 {
+    } else {
         re = new RegExp(`^(?:${letters}{4})*(?:${letters}{2,3}|${letters}{3}=|${letters}{2}==)?$`, 'u');
     }
-    return (0, superstruct_1.pattern)(struct, re);
+    return pattern(struct, re);
 };
-exports.base64 = base64;
+
 //# sourceMappingURL=base64.js.map

package/dist/esm/base64.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/base64.ts"],"sourcesContent":["import type { Struct } from 'superstruct';\nimport { pattern } from 'superstruct';\n\nimport { assert } from './assert';\n\nexport type Base64Options = {\n  /**\n   * Is the `=` padding at the end required or not.\n   *\n   * @default false\n   */\n  // Padding is optional in RFC 4648, that's why the default value is false\n  paddingRequired?: boolean;\n  /**\n   * Which character set should be used.\n   * The sets are based on {@link https://datatracker.ietf.org/doc/html/rfc4648 RFC 4648}.\n   *\n   * @default 'base64'\n   */\n  characterSet?: 'base64' | 'base64url';\n};\n\n/**\n * Ensure that a provided string-based struct is valid base64.\n *\n * @param struct - The string based struct.\n * @param options - Optional options to specialize base64 validation. See {@link Base64Options} documentation.\n * @returns A superstruct validating base64.\n */\nexport const base64 = <Type extends string, Schema>(\n  struct: Struct<Type, Schema>,\n  options: Base64Options = {},\n) => {\n  const paddingRequired = options.paddingRequired ?? false;\n  const characterSet = options.characterSet ?? 'base64';\n\n  let letters: string;\n  if (characterSet === 'base64') {\n    letters = String.raw`[A-Za-z0-9+\\/]`;\n  } else {\n    assert(characterSet === 'base64url');\n    letters = String.raw`[-_A-Za-z0-9]`;\n  }\n\n  let re: RegExp;\n  if (paddingRequired) {\n    re = new RegExp(\n      `^(?:${letters}{4})*(?:${letters}{3}=|${letters}{2}==)?$`,\n      'u',\n    );\n  } else {\n    re = new RegExp(\n      `^(?:${letters}{4})*(?:${letters}{2,3}|${letters}{3}=|${letters}{2}==)?$`,\n      'u',\n    );\n  }\n\n  return pattern(struct, re);\n};\n"],"names":["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/{bytes.js → esm/bytes.js}

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