@metamask/utils 6.2.0 → 7.0.0

package/dist/cjs/keyring.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/keyring.ts"],"names":[],"mappings":""}

package/dist/cjs/logging.js

@@ -0,0 +1,33 @@
+"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, {
+    createProjectLogger: function() {
+        return createProjectLogger;
+    },
+    createModuleLogger: function() {
+        return createModuleLogger;
+    }
+});
+const _debug = /*#__PURE__*/ _interop_require_default(require("debug"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const globalLogger = (0, _debug.default)('metamask');
+function createProjectLogger(projectName) {
+    return globalLogger.extend(projectName);
+}
+function createModuleLogger(projectLogger, moduleName) {
+    return projectLogger.extend(moduleName);
+}
+
+//# sourceMappingURL=logging.js.map

package/dist/cjs/logging.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/logging.ts"],"sourcesContent":["import type { Debugger } from 'debug';\nimport debug from 'debug';\n\nconst globalLogger = debug('metamask');\n\n/**\n * Creates a logger via the `debug` library whose log messages will be tagged\n * using the name of your project. By default, such messages will be\n * suppressed, but you can reveal them by setting the `DEBUG` environment\n * variable to `metamask:<projectName>`. You can also set this variable to\n * `metamask:*` if you want to see log messages from all MetaMask projects that\n * are also using this function to create their loggers.\n *\n * @param projectName - The name of your project. This should be the name of\n * your NPM package if you're developing one.\n * @returns An instance of `debug`.\n */\nexport function createProjectLogger(projectName: string): Debugger {\n  return globalLogger.extend(projectName);\n}\n\n/**\n * Creates a logger via the `debug` library which is derived from the logger for\n * the whole project whose log messages will be tagged using the name of your\n * module. By default, such messages will be suppressed, but you can reveal them\n * by setting the `DEBUG` environment variable to\n * `metamask:<projectName>:<moduleName>`. You can also set this variable to\n * `metamask:<projectName>:*` if you want to see log messages from the project,\n * or `metamask:*` if you want to see log messages from all MetaMask projects.\n *\n * @param projectLogger - The logger created via {@link createProjectLogger}.\n * @param moduleName - The name of your module. You could use the name of the\n * file where you're using this logger or some other name.\n * @returns An instance of `debug`.\n */\nexport function createModuleLogger(\n  projectLogger: Debugger,\n  moduleName: string,\n): Debugger {\n  return projectLogger.extend(moduleName);\n}\n"],"names":["createProjectLogger","createModuleLogger","globalLogger","debug","projectName","extend","projectLogger","moduleName"],"mappings":";;;;;;;;;;;IAiBgBA,mBAAmB;eAAnBA;;IAkBAC,kBAAkB;eAAlBA;;;8DAlCE;;;;;;AAElB,MAAMC,eAAeC,IAAAA,cAAK,EAAC;AAcpB,SAASH,oBAAoBI,WAAmB;IACrD,OAAOF,aAAaG,MAAM,CAACD;AAC7B;AAgBO,SAASH,mBACdK,aAAuB,EACvBC,UAAkB;IAElB,OAAOD,cAAcD,MAAM,CAACE;AAC9B"}

package/dist/cjs/misc.js

@@ -0,0 +1,111 @@
+//
+// Types
+//
+/**
+ * Makes every specified property of the specified object type mutable.
+ *
+ * @template ObjectValue - The object whose readonly properties to make mutable.
+ * @template TargetKey - The property key(s) to make mutable.
+ */ "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, {
+    JsonSize: function() {
+        return JsonSize;
+    },
+    isNonEmptyArray: function() {
+        return isNonEmptyArray;
+    },
+    isNullOrUndefined: function() {
+        return isNullOrUndefined;
+    },
+    isObject: function() {
+        return isObject;
+    },
+    hasProperty: function() {
+        return hasProperty;
+    },
+    getKnownPropertyNames: function() {
+        return getKnownPropertyNames;
+    },
+    ESCAPE_CHARACTERS_REGEXP: function() {
+        return ESCAPE_CHARACTERS_REGEXP;
+    },
+    isPlainObject: function() {
+        return isPlainObject;
+    },
+    isASCII: function() {
+        return isASCII;
+    },
+    calculateStringSize: function() {
+        return calculateStringSize;
+    },
+    calculateNumberSize: function() {
+        return calculateNumberSize;
+    }
+});
+function isNonEmptyArray(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+function isNullOrUndefined(value) {
+    return value === null || value === undefined;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+const hasProperty = (objectToCheck, name)=>Object.hasOwnProperty.call(objectToCheck, name);
+function getKnownPropertyNames(object) {
+    return Object.getOwnPropertyNames(object);
+}
+var JsonSize;
+(function(JsonSize) {
+    JsonSize[JsonSize["Null"] = 4] = "Null";
+    JsonSize[JsonSize["Comma"] = 1] = "Comma";
+    JsonSize[JsonSize["Wrapper"] = 1] = "Wrapper";
+    JsonSize[JsonSize["True"] = 4] = "True";
+    JsonSize[JsonSize["False"] = 5] = "False";
+    JsonSize[JsonSize["Quote"] = 1] = "Quote";
+    JsonSize[JsonSize["Colon"] = 1] = "Colon";
+    JsonSize[JsonSize[// eslint-disable-next-line @typescript-eslint/no-shadow
+    "Date"] = 24] = "Date";
+})(JsonSize || (JsonSize = {}));
+const ESCAPE_CHARACTERS_REGEXP = /"|\\|\n|\r|\t/gu;
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    try {
+        let proto = value;
+        while(Object.getPrototypeOf(proto) !== null){
+            proto = Object.getPrototypeOf(proto);
+        }
+        return Object.getPrototypeOf(value) === proto;
+    } catch (_) {
+        return false;
+    }
+}
+function isASCII(character) {
+    return character.charCodeAt(0) <= 127;
+}
+function calculateStringSize(value) {
+    const size = value.split('').reduce((total, character)=>{
+        if (isASCII(character)) {
+            return total + 1;
+        }
+        return total + 2;
+    }, 0);
+    // Also detect characters that need backslash escape
+    return size + (value.match(ESCAPE_CHARACTERS_REGEXP) ?? []).length;
+}
+function calculateNumberSize(value) {
+    return value.toString().length;
+}
+
+//# sourceMappingURL=misc.js.map

package/dist/cjs/misc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/misc.ts"],"sourcesContent":["//\n// Types\n//\n\n/**\n * Makes every specified property of the specified object type mutable.\n *\n * @template ObjectValue - The object whose readonly properties to make mutable.\n * @template TargetKey - The property key(s) to make mutable.\n */\nexport type Mutable<\n  ObjectValue extends Record<string, unknown>,\n  TargetKey extends keyof ObjectValue,\n> = {\n  -readonly [Key in keyof Pick<ObjectValue, TargetKey>]: ObjectValue[Key];\n} & {\n  [Key in keyof Omit<ObjectValue, TargetKey>]: ObjectValue[Key];\n};\n\n/**\n * Useful for representing some value that _might_ be present and / or complete.\n *\n * @template Value - The value that might be present or complete.\n */\nexport type PartialOrAbsent<Value> = Partial<Value> | null | undefined;\n\n/**\n * Like {@link Array}, but always non-empty.\n *\n * @template Element - The non-empty array member type.\n */\nexport type NonEmptyArray<Element> = [Element, ...Element[]];\n\n/**\n * A JavaScript object that is not `null`, a function, or an array.\n */\nexport type RuntimeObject = Record<PropertyKey, unknown>;\n\n//\n// Type Guards\n//\n\n/**\n * A {@link NonEmptyArray} type guard.\n *\n * @template Element - The non-empty array member type.\n * @param value - The value to check.\n * @returns Whether the value is a non-empty array.\n */\nexport function isNonEmptyArray<Element>(\n  value: Element[],\n): value is NonEmptyArray<Element> {\n  return Array.isArray(value) && value.length > 0;\n}\n\n/**\n * Type guard for \"nullishness\".\n *\n * @param value - Any value.\n * @returns `true` if the value is null or undefined, `false` otherwise.\n */\nexport function isNullOrUndefined(value: unknown): value is null | undefined {\n  return value === null || value === undefined;\n}\n\n/**\n * A type guard for {@link RuntimeObject}.\n *\n * @param value - The value to check.\n * @returns Whether the specified value has a runtime type of `object` and is\n * neither `null` nor an `Array`.\n */\nexport function isObject(value: unknown): value is RuntimeObject {\n  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);\n}\n\n//\n// Other utility functions\n//\n\n/**\n * A type guard for ensuring an object has a property.\n *\n * @param objectToCheck - The object to check.\n * @param name - The property name to check for.\n * @returns Whether the specified object has an own property with the specified\n * name, regardless of whether it is enumerable or not.\n */\nexport const hasProperty = <\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  ObjectToCheck extends Object,\n  Property extends PropertyKey,\n>(\n  objectToCheck: ObjectToCheck,\n  name: Property,\n): objectToCheck is ObjectToCheck &\n  Record<\n    Property,\n    Property extends keyof ObjectToCheck ? ObjectToCheck[Property] : unknown\n  > => Object.hasOwnProperty.call(objectToCheck, name);\n\n/**\n * `Object.getOwnPropertyNames()` is intentionally generic: it returns the\n * immediate property names of an object, but it cannot make guarantees about\n * the contents of that object, so the type of the property names is merely\n * `string[]`. While this is technically accurate, it is also unnecessary if we\n * have an object with a type that we own (such as an enum).\n *\n * @param object - The plain object.\n * @returns The own property names of the object which are assigned a type\n * derived from the object itself.\n */\nexport function getKnownPropertyNames<Key extends PropertyKey>(\n  object: Partial<Record<Key, any>>,\n): Key[] {\n  return Object.getOwnPropertyNames(object) as Key[];\n}\n\nexport type PlainObject = Record<number | string | symbol, unknown>;\n\n/**\n * Predefined sizes (in Bytes) of specific parts of JSON structure.\n */\nexport enum JsonSize {\n  Null = 4,\n  Comma = 1,\n  Wrapper = 1,\n  True = 4,\n  False = 5,\n  Quote = 1,\n  Colon = 1,\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  Date = 24,\n}\n\n/**\n * Regular expression with pattern matching for (special) escaped characters.\n */\nexport const ESCAPE_CHARACTERS_REGEXP = /\"|\\\\|\\n|\\r|\\t/gu;\n\n/**\n * Check if the value is plain object.\n *\n * @param value - Value to be checked.\n * @returns True if an object is the plain JavaScript object,\n * false if the object is not plain (e.g. function).\n */\nexport function isPlainObject(value: unknown): value is PlainObject {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n\n  try {\n    let proto = value;\n    while (Object.getPrototypeOf(proto) !== null) {\n      proto = Object.getPrototypeOf(proto);\n    }\n\n    return Object.getPrototypeOf(value) === proto;\n  } catch (_) {\n    return false;\n  }\n}\n\n/**\n * Check if character is ASCII.\n *\n * @param character - Character.\n * @returns True if a character code is ASCII, false if not.\n */\nexport function isASCII(character: string) {\n  return character.charCodeAt(0) <= 127;\n}\n\n/**\n * Calculate string size.\n *\n * @param value - String value to calculate size.\n * @returns Number of bytes used to store whole string value.\n */\nexport function calculateStringSize(value: string): number {\n  const size = value.split('').reduce((total, character) => {\n    if (isASCII(character)) {\n      return total + 1;\n    }\n    return total + 2;\n  }, 0);\n\n  // Also detect characters that need backslash escape\n  return size + (value.match(ESCAPE_CHARACTERS_REGEXP) ?? []).length;\n}\n\n/**\n * Calculate size of a number ofter JSON serialization.\n *\n * @param value - Number value to calculate size.\n * @returns Number of bytes used to store whole number in JSON.\n */\nexport function calculateNumberSize(value: number): number {\n  return value.toString().length;\n}\n"],"names":["isNonEmptyArray","isNullOrUndefined","isObject","hasProperty","getKnownPropertyNames","ESCAPE_CHARACTERS_REGEXP","isPlainObject","isASCII","calculateStringSize","calculateNumberSize","value","Array","isArray","length","undefined","Boolean","objectToCheck","name","Object","hasOwnProperty","call","object","getOwnPropertyNames","JsonSize","Null","Comma","Wrapper","True","False","Quote","Colon","Date","proto","getPrototypeOf","_","character","charCodeAt","size","split","reduce","total","match","toString"],"mappings":"AAAA,EAAE;AACF,QAAQ;AACR,EAAE;AAEF;;;;;CAKC;;;;;;;;;;;;;;IAwCeA,eAAe;eAAfA;;IAYAC,iBAAiB;eAAjBA;;IAWAC,QAAQ;eAARA;;IAgBHC,WAAW;eAAXA;;IAwBGC,qBAAqB;eAArBA;;IA0BHC,wBAAwB;eAAxBA;;IASGC,aAAa;eAAbA;;IAuBAC,OAAO;eAAPA;;IAUAC,mBAAmB;eAAnBA;;IAkBAC,mBAAmB;eAAnBA;;;AArJT,SAAST,gBACdU,KAAgB;IAEhB,OAAOC,MAAMC,OAAO,CAACF,UAAUA,MAAMG,MAAM,GAAG;AAChD;AAQO,SAASZ,kBAAkBS,KAAc;IAC9C,OAAOA,UAAU,QAAQA,UAAUI;AACrC;AASO,SAASZ,SAASQ,KAAc;IACrC,OAAOK,QAAQL,UAAU,OAAOA,UAAU,YAAY,CAACC,MAAMC,OAAO,CAACF;AACvE;AAcO,MAAMP,cAAc,CAKzBa,eACAC,OAKKC,OAAOC,cAAc,CAACC,IAAI,CAACJ,eAAeC;AAa1C,SAASb,sBACdiB,MAAiC;IAEjC,OAAOH,OAAOI,mBAAmB,CAACD;AACpC;IAOO;UAAKE,QAAQ;IAARA,SAAAA,SACVC,UAAO,KAAPA;IADUD,SAAAA,SAEVE,WAAQ,KAARA;IAFUF,SAAAA,SAGVG,aAAU,KAAVA;IAHUH,SAAAA,SAIVI,UAAO,KAAPA;IAJUJ,SAAAA,SAKVK,WAAQ,KAARA;IALUL,SAAAA,SAMVM,WAAQ,KAARA;IANUN,SAAAA,SAOVO,WAAQ,KAARA;IAPUP,SAAAA,SAQV,wDAAwD;IACxDQ,UAAO,MAAPA;GATUR,aAAAA;AAeL,MAAMlB,2BAA2B;AASjC,SAASC,cAAcI,KAAc;IAC1C,IAAI,OAAOA,UAAU,YAAYA,UAAU,MAAM;QAC/C,OAAO;IACT;IAEA,IAAI;QACF,IAAIsB,QAAQtB;QACZ,MAAOQ,OAAOe,cAAc,CAACD,WAAW,KAAM;YAC5CA,QAAQd,OAAOe,cAAc,CAACD;QAChC;QAEA,OAAOd,OAAOe,cAAc,CAACvB,WAAWsB;IAC1C,EAAE,OAAOE,GAAG;QACV,OAAO;IACT;AACF;AAQO,SAAS3B,QAAQ4B,SAAiB;IACvC,OAAOA,UAAUC,UAAU,CAAC,MAAM;AACpC;AAQO,SAAS5B,oBAAoBE,KAAa;IAC/C,MAAM2B,OAAO3B,MAAM4B,KAAK,CAAC,IAAIC,MAAM,CAAC,CAACC,OAAOL;QAC1C,IAAI5B,QAAQ4B,YAAY;YACtB,OAAOK,QAAQ;QACjB;QACA,OAAOA,QAAQ;IACjB,GAAG;IAEH,oDAAoD;IACpD,OAAOH,OAAO,AAAC3B,CAAAA,MAAM+B,KAAK,CAACpC,6BAA6B,EAAE,AAAD,EAAGQ,MAAM;AACpE;AAQO,SAASJ,oBAAoBC,KAAa;IAC/C,OAAOA,MAAMgC,QAAQ,GAAG7B,MAAM;AAChC"}

package/dist/cjs/number.js

@@ -0,0 +1,52 @@
+"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, {
+    numberToHex: function() {
+        return numberToHex;
+    },
+    bigIntToHex: function() {
+        return bigIntToHex;
+    },
+    hexToNumber: function() {
+        return hexToNumber;
+    },
+    hexToBigInt: function() {
+        return hexToBigInt;
+    }
+});
+const _assert = require("./assert");
+const _hex = require("./hex");
+const numberToHex = (value)=>{
+    (0, _assert.assert)(typeof value === 'number', 'Value must be a number.');
+    (0, _assert.assert)(value >= 0, 'Value must be a non-negative number.');
+    (0, _assert.assert)(Number.isSafeInteger(value), 'Value is not a safe integer. Use `bigIntToHex` instead.');
+    return (0, _hex.add0x)(value.toString(16));
+};
+const bigIntToHex = (value)=>{
+    (0, _assert.assert)(typeof value === 'bigint', 'Value must be a bigint.');
+    (0, _assert.assert)(value >= 0, 'Value must be a non-negative bigint.');
+    return (0, _hex.add0x)(value.toString(16));
+};
+const hexToNumber = (value)=>{
+    (0, _hex.assertIsHexString)(value);
+    // `parseInt` accepts values without the "0x"-prefix, whereas `Number` does
+    // not. Using this is slightly faster than `Number(add0x(value))`.
+    const numberValue = parseInt(value, 16);
+    (0, _assert.assert)(Number.isSafeInteger(numberValue), 'Value is not a safe integer. Use `hexToBigInt` instead.');
+    return numberValue;
+};
+const hexToBigInt = (value)=>{
+    (0, _hex.assertIsHexString)(value);
+    // The `BigInt` constructor requires the "0x"-prefix to parse a hex string.
+    return BigInt((0, _hex.add0x)(value));
+};
+
+//# sourceMappingURL=number.js.map

package/dist/cjs/number.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/number.ts"],"sourcesContent":["import { assert } from './assert';\nimport { add0x, assertIsHexString } from './hex';\n\n/**\n * Convert a number to a hexadecimal string. This verifies that the number is a\n * non-negative safe integer.\n *\n * To convert a `bigint` to a hexadecimal string instead, use\n * {@link bigIntToHex}.\n *\n * @example\n * ```typescript\n * numberToHex(0); // '0x0'\n * numberToHex(1); // '0x1'\n * numberToHex(16); // '0x10'\n * ```\n * @param value - The number to convert to a hexadecimal string.\n * @returns The hexadecimal string, with the \"0x\"-prefix.\n * @throws If the number is not a non-negative safe integer.\n */\nexport const numberToHex = (value: number): string => {\n  assert(typeof value === 'number', 'Value must be a number.');\n  assert(value >= 0, 'Value must be a non-negative number.');\n  assert(\n    Number.isSafeInteger(value),\n    'Value is not a safe integer. Use `bigIntToHex` instead.',\n  );\n\n  return add0x(value.toString(16));\n};\n\n/**\n * Convert a `bigint` to a hexadecimal string. This verifies that the `bigint`\n * is a non-negative integer.\n *\n * To convert a number to a hexadecimal string instead, use {@link numberToHex}.\n *\n * @example\n * ```typescript\n * bigIntToHex(0n); // '0x0'\n * bigIntToHex(1n); // '0x1'\n * bigIntToHex(16n); // '0x10'\n * ```\n * @param value - The `bigint` to convert to a hexadecimal string.\n * @returns The hexadecimal string, with the \"0x\"-prefix.\n * @throws If the `bigint` is not a non-negative integer.\n */\nexport const bigIntToHex = (value: bigint): string => {\n  assert(typeof value === 'bigint', 'Value must be a bigint.');\n  assert(value >= 0, 'Value must be a non-negative bigint.');\n\n  return add0x(value.toString(16));\n};\n\n/**\n * Convert a hexadecimal string to a number. This verifies that the string is a\n * valid hex string, and that the resulting number is a safe integer. Both\n * \"0x\"-prefixed and unprefixed strings are supported.\n *\n * To convert a hexadecimal string to a `bigint` instead, use\n * {@link hexToBigInt}.\n *\n * @example\n * ```typescript\n * hexToNumber('0x0'); // 0\n * hexToNumber('0x1'); // 1\n * hexToNumber('0x10'); // 16\n * ```\n * @param value - The hexadecimal string to convert to a number.\n * @returns The number.\n * @throws If the value is not a valid hexadecimal string, or if the resulting\n * number is not a safe integer.\n */\nexport const hexToNumber = (value: string): number => {\n  assertIsHexString(value);\n\n  // `parseInt` accepts values without the \"0x\"-prefix, whereas `Number` does\n  // not. Using this is slightly faster than `Number(add0x(value))`.\n  const numberValue = parseInt(value, 16);\n\n  assert(\n    Number.isSafeInteger(numberValue),\n    'Value is not a safe integer. Use `hexToBigInt` instead.',\n  );\n\n  return numberValue;\n};\n\n/**\n * Convert a hexadecimal string to a `bigint`. This verifies that the string is\n * a valid hex string. Both \"0x\"-prefixed and unprefixed strings are supported.\n *\n * To convert a hexadecimal string to a number instead, use {@link hexToNumber}.\n *\n * @example\n * ```typescript\n * hexToBigInt('0x0'); // 0n\n * hexToBigInt('0x1'); // 1n\n * hexToBigInt('0x10'); // 16n\n * ```\n * @param value - The hexadecimal string to convert to a `bigint`.\n * @returns The `bigint`.\n * @throws If the value is not a valid hexadecimal string.\n */\nexport const hexToBigInt = (value: string): bigint => {\n  assertIsHexString(value);\n\n  // The `BigInt` constructor requires the \"0x\"-prefix to parse a hex string.\n  return BigInt(add0x(value));\n};\n"],"names":["numberToHex","bigIntToHex","hexToNumber","hexToBigInt","value","assert","Number","isSafeInteger","add0x","toString","assertIsHexString","numberValue","parseInt","BigInt"],"mappings":";;;;;;;;;;;IAoBaA,WAAW;eAAXA;;IA2BAC,WAAW;eAAXA;;IA0BAC,WAAW;eAAXA;;IA+BAC,WAAW;eAAXA;;;wBAxGU;qBACkB;AAmBlC,MAAMH,cAAc,CAACI;IAC1BC,IAAAA,cAAM,EAAC,OAAOD,UAAU,UAAU;IAClCC,IAAAA,cAAM,EAACD,SAAS,GAAG;IACnBC,IAAAA,cAAM,EACJC,OAAOC,aAAa,CAACH,QACrB;IAGF,OAAOI,IAAAA,UAAK,EAACJ,MAAMK,QAAQ,CAAC;AAC9B;AAkBO,MAAMR,cAAc,CAACG;IAC1BC,IAAAA,cAAM,EAAC,OAAOD,UAAU,UAAU;IAClCC,IAAAA,cAAM,EAACD,SAAS,GAAG;IAEnB,OAAOI,IAAAA,UAAK,EAACJ,MAAMK,QAAQ,CAAC;AAC9B;AAqBO,MAAMP,cAAc,CAACE;IAC1BM,IAAAA,sBAAiB,EAACN;IAElB,2EAA2E;IAC3E,kEAAkE;IAClE,MAAMO,cAAcC,SAASR,OAAO;IAEpCC,IAAAA,cAAM,EACJC,OAAOC,aAAa,CAACI,cACrB;IAGF,OAAOA;AACT;AAkBO,MAAMR,cAAc,CAACC;IAC1BM,IAAAA,sBAAiB,EAACN;IAElB,2EAA2E;IAC3E,OAAOS,OAAOL,IAAAA,UAAK,EAACJ;AACtB"}

package/dist/cjs/opaque.js

@@ -0,0 +1,8 @@
+// We use a symbol property name instead of { _type: Brand }, because that would show up in IDE suggestions,
+// while internal symbols do not.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=opaque.js.map

package/dist/cjs/opaque.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/opaque.ts"],"sourcesContent":["// We use a symbol property name instead of { _type: Brand }, because that would show up in IDE suggestions,\n// while internal symbols do not.\ndeclare const brand: unique symbol;\nexport type Opaque<Base, Brand extends symbol> = Base & { [brand]: Brand };\n"],"names":[],"mappings":"AAAA,4GAA4G;AAC5G,iCAAiC"}

package/dist/cjs/time.js

@@ -0,0 +1,63 @@
+/**
+ * Common duration constants, in milliseconds.
+ */ "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, {
+    Duration: function() {
+        return Duration;
+    },
+    inMilliseconds: function() {
+        return inMilliseconds;
+    },
+    timeSince: function() {
+        return timeSince;
+    }
+});
+var Duration;
+(function(Duration) {
+    Duration[Duration[/**
+   * A millisecond.
+   */ "Millisecond"] = 1] = "Millisecond";
+    Duration[Duration[/**
+   * A second, in milliseconds.
+   */ "Second"] = 1000] = "Second";
+    Duration[Duration[/**
+   * A minute, in milliseconds.
+   */ "Minute"] = 60000] = "Minute";
+    Duration[Duration[/**
+   * An hour, in milliseconds.
+   */ "Hour"] = 3600000] = "Hour";
+    Duration[Duration[/**
+   * A day, in milliseconds.
+   */ "Day"] = 86400000] = "Day";
+    Duration[Duration[/**
+   * A week, in milliseconds.
+   */ "Week"] = 604800000] = "Week";
+    Duration[Duration[/**
+   * A year, in milliseconds.
+   */ "Year"] = 31536000000] = "Year";
+})(Duration || (Duration = {}));
+const isNonNegativeInteger = (number)=>Number.isInteger(number) && number >= 0;
+const assertIsNonNegativeInteger = (number, name)=>{
+    if (!isNonNegativeInteger(number)) {
+        throw new Error(`"${name}" must be a non-negative integer. Received: "${number}".`);
+    }
+};
+function inMilliseconds(count, duration) {
+    assertIsNonNegativeInteger(count, 'count');
+    return count * duration;
+}
+function timeSince(timestamp) {
+    assertIsNonNegativeInteger(timestamp, 'timestamp');
+    return Date.now() - timestamp;
+}
+
+//# sourceMappingURL=time.js.map

package/dist/cjs/time.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/time.ts"],"sourcesContent":["/**\n * Common duration constants, in milliseconds.\n */\nexport enum Duration {\n  /**\n   * A millisecond.\n   */\n  Millisecond = 1,\n\n  /**\n   * A second, in milliseconds.\n   */\n  Second = 1000, // Millisecond * 1000\n\n  /**\n   * A minute, in milliseconds.\n   */\n  Minute = 60_000, // Second * 60\n\n  /**\n   * An hour, in milliseconds.\n   */\n  Hour = 3_600_000, // Minute * 60\n\n  /**\n   * A day, in milliseconds.\n   */\n  Day = 86_400_000, // Hour * 24\n\n  /**\n   * A week, in milliseconds.\n   */\n  Week = 604_800_000, // Day * 7\n\n  /**\n   * A year, in milliseconds.\n   */\n  Year = 31_536_000_000, // Day * 365\n}\n\nconst isNonNegativeInteger = (number: number) =>\n  Number.isInteger(number) && number >= 0;\n\nconst assertIsNonNegativeInteger = (number: number, name: string) => {\n  if (!isNonNegativeInteger(number)) {\n    throw new Error(\n      `\"${name}\" must be a non-negative integer. Received: \"${number}\".`,\n    );\n  }\n};\n\n/**\n * Calculates the millisecond value of the specified number of units of time.\n *\n * @param count - The number of units of time.\n * @param duration - The unit of time to count.\n * @returns The count multiplied by the specified duration.\n */\nexport function inMilliseconds(count: number, duration: Duration): number {\n  assertIsNonNegativeInteger(count, 'count');\n  return count * duration;\n}\n\n/**\n * Gets the milliseconds since a particular Unix epoch timestamp.\n *\n * @param timestamp - A Unix millisecond timestamp.\n * @returns The number of milliseconds elapsed since the specified timestamp.\n */\nexport function timeSince(timestamp: number): number {\n  assertIsNonNegativeInteger(timestamp, 'timestamp');\n  return Date.now() - timestamp;\n}\n"],"names":["inMilliseconds","timeSince","Duration","Millisecond","Second","Minute","Hour","Day","Week","Year","isNonNegativeInteger","number","Number","isInteger","assertIsNonNegativeInteger","name","Error","count","duration","timestamp","Date","now"],"mappings":"AAAA;;CAEC;;;;;;;;;;;;;;IAwDeA,cAAc;eAAdA;;IAWAC,SAAS;eAATA;;;IAlET;UAAKC,QAAQ;IAARA,SAAAA,SACV;;GAEC,GACDC,iBAAc,KAAdA;IAJUD,SAAAA,SAMV;;GAEC,GACDE,YAAS,QAATA;IATUF,SAAAA,SAWV;;GAEC,GACDG,YAAS,SAATA;IAdUH,SAAAA,SAgBV;;GAEC,GACDI,UAAO,WAAPA;IAnBUJ,SAAAA,SAqBV;;GAEC,GACDK,SAAM,YAANA;IAxBUL,SAAAA,SA0BV;;GAEC,GACDM,UAAO,aAAPA;IA7BUN,SAAAA,SA+BV;;GAEC,GACDO,UAAO,eAAPA;GAlCUP,aAAAA;AAqCZ,MAAMQ,uBAAuB,CAACC,SAC5BC,OAAOC,SAAS,CAACF,WAAWA,UAAU;AAExC,MAAMG,6BAA6B,CAACH,QAAgBI;IAClD,IAAI,CAACL,qBAAqBC,SAAS;QACjC,MAAM,IAAIK,MACR,CAAC,CAAC,EAAED,KAAK,6CAA6C,EAAEJ,OAAO,EAAE,CAAC;IAEtE;AACF;AASO,SAASX,eAAeiB,KAAa,EAAEC,QAAkB;IAC9DJ,2BAA2BG,OAAO;IAClC,OAAOA,QAAQC;AACjB;AAQO,SAASjB,UAAUkB,SAAiB;IACzCL,2BAA2BK,WAAW;IACtC,OAAOC,KAAKC,GAAG,KAAKF;AACtB"}

package/dist/cjs/transaction-types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=transaction-types.js.map

package/dist/cjs/transaction-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transaction-types.ts"],"names":[],"mappings":""}

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"}