@metamask-previews/utils 11.12.1-preview-9962b7e

package/dist/mnemonic.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Transform a typed array containing mnemonic data to the seed phrase.
+ * @param uint8Array - Typed array containing mnemonic data.
+ * @returns The seed phrase.
+ */
+export declare function uint8ArrayToMnemonic(uint8Array: Uint8Array): string;
+/**
+ * Encodes a BIP-39 mnemonic as the indices of words in the English BIP-39 wordlist.
+ *
+ * @param mnemonic - The BIP-39 mnemonic.
+ * @returns The Unicode code points for the seed phrase formed from the words in the wordlist.
+ */
+export declare function convertMnemonicToWordlistIndices(mnemonic: string): Uint8Array;
+//# sourceMappingURL=mnemonic.d.ts.map

package/dist/mnemonic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mnemonic.d.ts","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAYnE;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAG7E"}

package/dist/mnemonic.js

@@ -0,0 +1,25 @@
+import * as englishWordlist from '@metamask/scure-bip39/dist/wordlists/english.js';
+const { wordlist } = englishWordlist;
+/**
+ * Transform a typed array containing mnemonic data to the seed phrase.
+ * @param uint8Array - Typed array containing mnemonic data.
+ * @returns The seed phrase.
+ */
+export function uint8ArrayToMnemonic(uint8Array) {
+    if (uint8Array.length === 0) {
+        throw new Error('The method uint8ArrayToMnemonic expects a non-empty array');
+    }
+    const recoveredIndices = Array.from(new Uint16Array(new Uint8Array(uint8Array).buffer));
+    return recoveredIndices.map((i) => wordlist[i]).join(' ');
+}
+/**
+ * Encodes a BIP-39 mnemonic as the indices of words in the English BIP-39 wordlist.
+ *
+ * @param mnemonic - The BIP-39 mnemonic.
+ * @returns The Unicode code points for the seed phrase formed from the words in the wordlist.
+ */
+export function convertMnemonicToWordlistIndices(mnemonic) {
+    const indices = mnemonic.split(' ').map((word) => wordlist.indexOf(word));
+    return new Uint8Array(new Uint16Array(indices).buffer);
+}
+//# sourceMappingURL=mnemonic.js.map

package/dist/mnemonic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mnemonic.js","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,eAAe,MAAM,iDAAiD,CAAC;AAEnF,MAAM,EAAE,QAAQ,EAAE,GAAG,eAAe,CAAC;AAErC;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,UAAsB;IACzD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CACb,2DAA2D,CAC5D,CAAC;IACJ,CAAC;IAED,MAAM,gBAAgB,GAAG,KAAK,CAAC,IAAI,CACjC,IAAI,WAAW,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CACnD,CAAC;IAEF,OAAO,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gCAAgC,CAAC,QAAgB;IAC/D,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IAC1E,OAAO,IAAI,UAAU,CAAC,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AACzD,CAAC","sourcesContent":["import * as englishWordlist from '@metamask/scure-bip39/dist/wordlists/english.js';\n\nconst { wordlist } = englishWordlist;\n\n/**\n * Transform a typed array containing mnemonic data to the seed phrase.\n * @param uint8Array - Typed array containing mnemonic data.\n * @returns The seed phrase.\n */\nexport function uint8ArrayToMnemonic(uint8Array: Uint8Array): string {\n  if (uint8Array.length === 0) {\n    throw new Error(\n      'The method uint8ArrayToMnemonic expects a non-empty array',\n    );\n  }\n\n  const recoveredIndices = Array.from(\n    new Uint16Array(new Uint8Array(uint8Array).buffer),\n  );\n\n  return recoveredIndices.map((i) => wordlist[i]).join(' ');\n}\n\n/**\n * Encodes a BIP-39 mnemonic as the indices of words in the English BIP-39 wordlist.\n *\n * @param mnemonic - The BIP-39 mnemonic.\n * @returns The Unicode code points for the seed phrase formed from the words in the wordlist.\n */\nexport function convertMnemonicToWordlistIndices(mnemonic: string): Uint8Array {\n  const indices = mnemonic.split(' ').map((word) => wordlist.indexOf(word));\n  return new Uint8Array(new Uint16Array(indices).buffer);\n}\n"]}

package/dist/node.d.ts

@@ -0,0 +1,3 @@
+export * from './index.js';
+export * from './fs.js';
+//# sourceMappingURL=node.d.ts.map

package/dist/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC"}

package/dist/node.js

@@ -0,0 +1,3 @@
+export * from './index.js';
+export * from './fs.js';
+//# sourceMappingURL=node.js.map

package/dist/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC","sourcesContent":["export * from './index.js';\nexport * from './fs.js';\n"]}

package/dist/number.d.ts

@@ -0,0 +1,74 @@
+import type { Hex } from './hex.js';
+/**
+ * Convert a number to a hexadecimal string. This verifies that the number is a
+ * non-negative safe integer.
+ *
+ * To convert a `bigint` to a hexadecimal string instead, use
+ * {@link bigIntToHex}.
+ *
+ * @example
+ * ```typescript
+ * numberToHex(0); // '0x0'
+ * numberToHex(1); // '0x1'
+ * numberToHex(16); // '0x10'
+ * ```
+ * @param value - The number to convert to a hexadecimal string.
+ * @returns The hexadecimal string, with the "0x"-prefix.
+ * @throws If the number is not a non-negative safe integer.
+ */
+export declare const numberToHex: (value: number) => Hex;
+/**
+ * Convert a `bigint` to a hexadecimal string. This verifies that the `bigint`
+ * is a non-negative integer.
+ *
+ * To convert a number to a hexadecimal string instead, use {@link numberToHex}.
+ *
+ * @example
+ * ```typescript
+ * bigIntToHex(0n); // '0x0'
+ * bigIntToHex(1n); // '0x1'
+ * bigIntToHex(16n); // '0x10'
+ * ```
+ * @param value - The `bigint` to convert to a hexadecimal string.
+ * @returns The hexadecimal string, with the "0x"-prefix.
+ * @throws If the `bigint` is not a non-negative integer.
+ */
+export declare const bigIntToHex: (value: bigint) => Hex;
+/**
+ * Convert a hexadecimal string to a number. This verifies that the string is a
+ * valid hex string, and that the resulting number is a safe integer. Both
+ * "0x"-prefixed and unprefixed strings are supported.
+ *
+ * To convert a hexadecimal string to a `bigint` instead, use
+ * {@link hexToBigInt}.
+ *
+ * @example
+ * ```typescript
+ * hexToNumber('0x0'); // 0
+ * hexToNumber('0x1'); // 1
+ * hexToNumber('0x10'); // 16
+ * ```
+ * @param value - The hexadecimal string to convert to a number.
+ * @returns The number.
+ * @throws If the value is not a valid hexadecimal string, or if the resulting
+ * number is not a safe integer.
+ */
+export declare const hexToNumber: (value: string) => number;
+/**
+ * Convert a hexadecimal string to a `bigint`. This verifies that the string is
+ * a valid hex string. Both "0x"-prefixed and unprefixed strings are supported.
+ *
+ * To convert a hexadecimal string to a number instead, use {@link hexToNumber}.
+ *
+ * @example
+ * ```typescript
+ * hexToBigInt('0x0'); // 0n
+ * hexToBigInt('0x1'); // 1n
+ * hexToBigInt('0x10'); // 16n
+ * ```
+ * @param value - The hexadecimal string to convert to a `bigint`.
+ * @returns The `bigint`.
+ * @throws If the value is not a valid hexadecimal string.
+ */
+export declare const hexToBigInt: (value: string) => bigint;
+//# sourceMappingURL=number.d.ts.map

package/dist/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../src/number.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAGpC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,GAS3C,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,GAK3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,MAa3C,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,MAK3C,CAAC"}

package/dist/number.js

@@ -0,0 +1,95 @@
+import { assert } from './assert.js';
+import { add0x, assertIsHexString } from './hex.js';
+/**
+ * Convert a number to a hexadecimal string. This verifies that the number is a
+ * non-negative safe integer.
+ *
+ * To convert a `bigint` to a hexadecimal string instead, use
+ * {@link bigIntToHex}.
+ *
+ * @example
+ * ```typescript
+ * numberToHex(0); // '0x0'
+ * numberToHex(1); // '0x1'
+ * numberToHex(16); // '0x10'
+ * ```
+ * @param value - The number to convert to a hexadecimal string.
+ * @returns The hexadecimal string, with the "0x"-prefix.
+ * @throws If the number is not a non-negative safe integer.
+ */
+export const numberToHex = (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 `bigIntToHex` instead.');
+    return add0x(value.toString(16));
+};
+/**
+ * Convert a `bigint` to a hexadecimal string. This verifies that the `bigint`
+ * is a non-negative integer.
+ *
+ * To convert a number to a hexadecimal string instead, use {@link numberToHex}.
+ *
+ * @example
+ * ```typescript
+ * bigIntToHex(0n); // '0x0'
+ * bigIntToHex(1n); // '0x1'
+ * bigIntToHex(16n); // '0x10'
+ * ```
+ * @param value - The `bigint` to convert to a hexadecimal string.
+ * @returns The hexadecimal string, with the "0x"-prefix.
+ * @throws If the `bigint` is not a non-negative integer.
+ */
+export const bigIntToHex = (value) => {
+    assert(typeof value === 'bigint', 'Value must be a bigint.');
+    assert(value >= 0, 'Value must be a non-negative bigint.');
+    return add0x(value.toString(16));
+};
+/**
+ * Convert a hexadecimal string to a number. This verifies that the string is a
+ * valid hex string, and that the resulting number is a safe integer. Both
+ * "0x"-prefixed and unprefixed strings are supported.
+ *
+ * To convert a hexadecimal string to a `bigint` instead, use
+ * {@link hexToBigInt}.
+ *
+ * @example
+ * ```typescript
+ * hexToNumber('0x0'); // 0
+ * hexToNumber('0x1'); // 1
+ * hexToNumber('0x10'); // 16
+ * ```
+ * @param value - The hexadecimal string to convert to a number.
+ * @returns The number.
+ * @throws If the value is not a valid hexadecimal string, or if the resulting
+ * number is not a safe integer.
+ */
+export const hexToNumber = (value) => {
+    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);
+    assert(Number.isSafeInteger(numberValue), 'Value is not a safe integer. Use `hexToBigInt` instead.');
+    return numberValue;
+};
+/**
+ * Convert a hexadecimal string to a `bigint`. This verifies that the string is
+ * a valid hex string. Both "0x"-prefixed and unprefixed strings are supported.
+ *
+ * To convert a hexadecimal string to a number instead, use {@link hexToNumber}.
+ *
+ * @example
+ * ```typescript
+ * hexToBigInt('0x0'); // 0n
+ * hexToBigInt('0x1'); // 1n
+ * hexToBigInt('0x10'); // 16n
+ * ```
+ * @param value - The hexadecimal string to convert to a `bigint`.
+ * @returns The `bigint`.
+ * @throws If the value is not a valid hexadecimal string.
+ */
+export const hexToBigInt = (value) => {
+    assertIsHexString(value);
+    // The `BigInt` constructor requires the "0x"-prefix to parse a hex string.
+    return BigInt(add0x(value));
+};
+//# sourceMappingURL=number.js.map

package/dist/number.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.js","sourceRoot":"","sources":["../src/number.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAa,EAAO,EAAE;IAChD,MAAM,CAAC,OAAO,KAAK,KAAK,QAAQ,EAAE,yBAAyB,CAAC,CAAC;IAC7D,MAAM,CAAC,KAAK,IAAI,CAAC,EAAE,sCAAsC,CAAC,CAAC;IAC3D,MAAM,CACJ,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,EAC3B,yDAAyD,CAC1D,CAAC;IAEF,OAAO,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;AACnC,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAa,EAAO,EAAE;IAChD,MAAM,CAAC,OAAO,KAAK,KAAK,QAAQ,EAAE,yBAAyB,CAAC,CAAC;IAC7D,MAAM,CAAC,KAAK,IAAI,CAAC,EAAE,sCAAsC,CAAC,CAAC;IAE3D,OAAO,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;AACnC,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE;IACnD,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAEzB,2EAA2E;IAC3E,kEAAkE;IAClE,MAAM,WAAW,GAAG,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAExC,MAAM,CACJ,MAAM,CAAC,aAAa,CAAC,WAAW,CAAC,EACjC,yDAAyD,CAC1D,CAAC;IAEF,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE;IACnD,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAEzB,2EAA2E;IAC3E,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;AAC9B,CAAC,CAAC","sourcesContent":["import { assert } from './assert.js';\nimport type { Hex } from './hex.js';\nimport { add0x, assertIsHexString } from './hex.js';\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): Hex => {\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): Hex => {\n  assert(typeof value === 'bigint', 'Value must be a bigint.');\n  assert(value >= 0, 'Value must be a non-negative bigint.');\n\n  return add0x(value.toString(16));\n};\n\n/**\n * Convert a hexadecimal string to a number. This verifies that the string is a\n * valid hex string, and that the resulting number is a safe integer. Both\n * \"0x\"-prefixed and unprefixed strings are supported.\n *\n * To convert a hexadecimal string to a `bigint` instead, use\n * {@link hexToBigInt}.\n *\n * @example\n * ```typescript\n * hexToNumber('0x0'); // 0\n * hexToNumber('0x1'); // 1\n * hexToNumber('0x10'); // 16\n * ```\n * @param value - The hexadecimal string to convert to a number.\n * @returns The number.\n * @throws If the value is not a valid hexadecimal string, or if the resulting\n * number is not a safe integer.\n */\nexport const hexToNumber = (value: string): number => {\n  assertIsHexString(value);\n\n  // `parseInt` accepts values without the \"0x\"-prefix, whereas `Number` does\n  // not. Using this is slightly faster than `Number(add0x(value))`.\n  const numberValue = parseInt(value, 16);\n\n  assert(\n    Number.isSafeInteger(numberValue),\n    'Value is not a safe integer. Use `hexToBigInt` instead.',\n  );\n\n  return numberValue;\n};\n\n/**\n * Convert a hexadecimal string to a `bigint`. This verifies that the string is\n * a valid hex string. Both \"0x\"-prefixed and unprefixed strings are supported.\n *\n * To convert a hexadecimal string to a number instead, use {@link hexToNumber}.\n *\n * @example\n * ```typescript\n * hexToBigInt('0x0'); // 0n\n * hexToBigInt('0x1'); // 1n\n * hexToBigInt('0x10'); // 16n\n * ```\n * @param value - The hexadecimal string to convert to a `bigint`.\n * @returns The `bigint`.\n * @throws If the value is not a valid hexadecimal string.\n */\nexport const hexToBigInt = (value: string): bigint => {\n  assertIsHexString(value);\n\n  // The `BigInt` constructor requires the \"0x\"-prefix to parse a hex string.\n  return BigInt(add0x(value));\n};\n"]}

package/dist/opaque.d.ts

@@ -0,0 +1,6 @@
+declare const brand: unique symbol;
+export type Opaque<Base, Brand extends symbol> = Base & {
+    [brand]: Brand;
+};
+export {};
+//# sourceMappingURL=opaque.d.ts.map

package/dist/opaque.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opaque.d.ts","sourceRoot":"","sources":["../src/opaque.ts"],"names":[],"mappings":"AAEA,OAAO,CAAC,MAAM,KAAK,EAAE,OAAO,MAAM,CAAC;AACnC,MAAM,MAAM,MAAM,CAAC,IAAI,EAAE,KAAK,SAAS,MAAM,IAAI,IAAI,GAAG;IAAE,CAAC,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC"}

package/dist/opaque.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=opaque.js.map

package/dist/opaque.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opaque.js","sourceRoot":"","sources":["../src/opaque.ts"],"names":[],"mappings":"","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"]}

package/dist/promise.d.ts

@@ -0,0 +1,45 @@
+/**
+ * A deferred Promise.
+ *
+ * A deferred Promise is one that can be resolved or rejected independently of
+ * the Promise construction.
+ * @template Result - The result type of the Promise.
+ */
+export type DeferredPromise<Result = void> = {
+    /**
+     * The Promise that has been deferred.
+     */
+    promise: Promise<Result>;
+    /**
+     * A function that resolves the Promise.
+     */
+    resolve: (result: Result) => void;
+    /**
+     * A function that rejects the Promise.
+     */
+    reject: (error: unknown) => void;
+};
+/**
+ * Create a defered Promise.
+ *
+ * If the Promise is rejected prior to a handler being added, this can result in an
+ * `UnhandledPromiseRejection` error. Optionally this can be suppressed with the
+ * `suppressUnhandledRejection` flag, as it's common to belatedly handle deferred Promises, or to
+ * ignore them if they're no longer relevant (e.g. related to a cancelled request).
+ *
+ * However, be very careful that you have handled the Promise if you do this. Suppressing these
+ * errors is dangerous, they exist for good reason. An unhandled rejection can hide errors, making
+ * debugging extremely difficult. They should only be suppressed if you're confident that the
+ * Promise is always handled correctly, in both the success and failure cases.
+ *
+ * @param args - The arguments.
+ * @param args.suppressUnhandledRejection - This option adds an empty error handler
+ * to the Promise to suppress the UnhandledPromiseRejection error. This can be
+ * useful if the deferred Promise is sometimes intentionally not used.
+ * @returns A deferred Promise.
+ * @template Result - The result type of the Promise.
+ */
+export declare function createDeferredPromise<Result = void>({ suppressUnhandledRejection, }?: {
+    suppressUnhandledRejection?: boolean;
+}): DeferredPromise<Result>;
+//# sourceMappingURL=promise.d.ts.map

package/dist/promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.d.ts","sourceRoot":"","sources":["../src/promise.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,CAAC,MAAM,GAAG,IAAI,IAAI;IAC3C;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACzB;;OAEG;IACH,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC;;OAEG;IACH,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAClC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,GAAG,IAAI,EAAE,EACnD,0BAAkC,GACnC,GAAE;IACD,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACjC,GAAG,eAAe,CAAC,MAAM,CAAC,CAyB/B"}

package/dist/promise.js

@@ -0,0 +1,40 @@
+/**
+ * Create a defered Promise.
+ *
+ * If the Promise is rejected prior to a handler being added, this can result in an
+ * `UnhandledPromiseRejection` error. Optionally this can be suppressed with the
+ * `suppressUnhandledRejection` flag, as it's common to belatedly handle deferred Promises, or to
+ * ignore them if they're no longer relevant (e.g. related to a cancelled request).
+ *
+ * However, be very careful that you have handled the Promise if you do this. Suppressing these
+ * errors is dangerous, they exist for good reason. An unhandled rejection can hide errors, making
+ * debugging extremely difficult. They should only be suppressed if you're confident that the
+ * Promise is always handled correctly, in both the success and failure cases.
+ *
+ * @param args - The arguments.
+ * @param args.suppressUnhandledRejection - This option adds an empty error handler
+ * to the Promise to suppress the UnhandledPromiseRejection error. This can be
+ * useful if the deferred Promise is sometimes intentionally not used.
+ * @returns A deferred Promise.
+ * @template Result - The result type of the Promise.
+ */
+export function createDeferredPromise({ suppressUnhandledRejection = false, } = {}) {
+    let resolve;
+    let reject;
+    /* eslint-disable promise/param-names -- Deliberately not named
+       'resolve'/'reject' so they do not shadow the outer bindings assigned
+       just below. */
+    const promise = new Promise((innerResolve, innerReject) => {
+        resolve = innerResolve;
+        reject = innerReject;
+    });
+    /* eslint-enable promise/param-names */
+    if (suppressUnhandledRejection) {
+        promise.catch((_error) => {
+            // This handler is used to suppress the UnhandledPromiseRejection error
+        });
+    }
+    // @ts-expect-error We know that these are assigned, but TypeScript doesn't
+    return { promise, resolve, reject };
+}
+//# sourceMappingURL=promise.js.map

package/dist/promise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.js","sourceRoot":"","sources":["../src/promise.ts"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,qBAAqB,CAAgB,EACnD,0BAA0B,GAAG,KAAK,GACnC,GAEG,EAAE;IACJ,IAAI,OAA2C,CAAC;IAChD,IAAI,MAAyC,CAAC;IAC9C;;qBAEiB;IACjB,MAAM,OAAO,GAAG,IAAI,OAAO,CACzB,CACE,YAAgD,EAChD,WAA8C,EAC9C,EAAE;QACF,OAAO,GAAG,YAAY,CAAC;QACvB,MAAM,GAAG,WAAW,CAAC;IACvB,CAAC,CACF,CAAC;IACF,uCAAuC;IAEvC,IAAI,0BAA0B,EAAE,CAAC;QAC/B,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE;YACvB,uEAAuE;QACzE,CAAC,CAAC,CAAC;IACL,CAAC;IAED,2EAA2E;IAC3E,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;AACtC,CAAC","sourcesContent":["/**\n * A deferred Promise.\n *\n * A deferred Promise is one that can be resolved or rejected independently of\n * the Promise construction.\n * @template Result - The result type of the Promise.\n */\nexport type DeferredPromise<Result = void> = {\n  /**\n   * The Promise that has been deferred.\n   */\n  promise: Promise<Result>;\n  /**\n   * A function that resolves the Promise.\n   */\n  resolve: (result: Result) => void;\n  /**\n   * A function that rejects the Promise.\n   */\n  reject: (error: unknown) => void;\n};\n\n/**\n * Create a defered Promise.\n *\n * If the Promise is rejected prior to a handler being added, this can result in an\n * `UnhandledPromiseRejection` error. Optionally this can be suppressed with the\n * `suppressUnhandledRejection` flag, as it's common to belatedly handle deferred Promises, or to\n * ignore them if they're no longer relevant (e.g. related to a cancelled request).\n *\n * However, be very careful that you have handled the Promise if you do this. Suppressing these\n * errors is dangerous, they exist for good reason. An unhandled rejection can hide errors, making\n * debugging extremely difficult. They should only be suppressed if you're confident that the\n * Promise is always handled correctly, in both the success and failure cases.\n *\n * @param args - The arguments.\n * @param args.suppressUnhandledRejection - This option adds an empty error handler\n * to the Promise to suppress the UnhandledPromiseRejection error. This can be\n * useful if the deferred Promise is sometimes intentionally not used.\n * @returns A deferred Promise.\n * @template Result - The result type of the Promise.\n */\nexport function createDeferredPromise<Result = void>({\n  suppressUnhandledRejection = false,\n}: {\n  suppressUnhandledRejection?: boolean;\n} = {}): DeferredPromise<Result> {\n  let resolve: DeferredPromise<Result>['resolve'];\n  let reject: DeferredPromise<Result>['reject'];\n  /* eslint-disable promise/param-names -- Deliberately not named\n     'resolve'/'reject' so they do not shadow the outer bindings assigned\n     just below. */\n  const promise = new Promise<Result>(\n    (\n      innerResolve: DeferredPromise<Result>['resolve'],\n      innerReject: DeferredPromise<Result>['reject'],\n    ) => {\n      resolve = innerResolve;\n      reject = innerReject;\n    },\n  );\n  /* eslint-enable promise/param-names */\n\n  if (suppressUnhandledRejection) {\n    promise.catch((_error) => {\n      // This handler is used to suppress the UnhandledPromiseRejection error\n    });\n  }\n\n  // @ts-expect-error We know that these are assigned, but TypeScript doesn't\n  return { promise, resolve, reject };\n}\n"]}

package/dist/superstruct.d.ts

@@ -0,0 +1,20 @@
+import type { Struct } from '@metamask/superstruct';
+/**
+ * Defines a new string-struct matching a regular expression.
+ *
+ * @example
+ * const EthAddressStruct = definePattern('EthAddress', /^0x[0-9a-f]{40}$/iu);
+ * type EthAddress = Infer<typeof EthAddressStruct>; // string
+ *
+ * const CaipChainIdStruct = defineTypedPattern<`${string}:${string}`>(
+ *   'CaipChainId',
+ *   /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}$/u;
+ * );
+ * type CaipChainId = Infer<typeof CaipChainIdStruct>; // `${string}:${string}`
+ * @param name - Type name.
+ * @param pattern - Regular expression to match.
+ * @template Pattern - The pattern type, defaults to `string`.
+ * @returns A new string-struct that matches the given pattern.
+ */
+export declare function definePattern<Pattern extends string = string>(name: string, pattern: RegExp): Struct<Pattern, null>;
+//# sourceMappingURL=superstruct.d.ts.map

package/dist/superstruct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"superstruct.d.ts","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EAC3D,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAIvB"}

package/dist/superstruct.js

@@ -0,0 +1,24 @@
+import { define } from '@metamask/superstruct';
+/**
+ * Defines a new string-struct matching a regular expression.
+ *
+ * @example
+ * const EthAddressStruct = definePattern('EthAddress', /^0x[0-9a-f]{40}$/iu);
+ * type EthAddress = Infer<typeof EthAddressStruct>; // string
+ *
+ * const CaipChainIdStruct = defineTypedPattern<`${string}:${string}`>(
+ *   'CaipChainId',
+ *   /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}$/u;
+ * );
+ * type CaipChainId = Infer<typeof CaipChainIdStruct>; // `${string}:${string}`
+ * @param name - Type name.
+ * @param pattern - Regular expression to match.
+ * @template Pattern - The pattern type, defaults to `string`.
+ * @returns A new string-struct that matches the given pattern.
+ */
+export function definePattern(name, pattern) {
+    return define(name, (value) => {
+        return typeof value === 'string' && pattern.test(value);
+    });
+}
+//# sourceMappingURL=superstruct.js.map

package/dist/superstruct.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"superstruct.js","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE/C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,aAAa,CAC3B,IAAY,EACZ,OAAe;IAEf,OAAO,MAAM,CAAU,IAAI,EAAE,CAAC,KAAc,EAAoB,EAAE;QAChE,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1D,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { Struct } from '@metamask/superstruct';\nimport { define } from '@metamask/superstruct';\n\n/**\n * Defines a new string-struct matching a regular expression.\n *\n * @example\n * const EthAddressStruct = definePattern('EthAddress', /^0x[0-9a-f]{40}$/iu);\n * type EthAddress = Infer<typeof EthAddressStruct>; // string\n *\n * const CaipChainIdStruct = defineTypedPattern<`${string}:${string}`>(\n *   'CaipChainId',\n *   /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}$/u;\n * );\n * type CaipChainId = Infer<typeof CaipChainIdStruct>; // `${string}:${string}`\n * @param name - Type name.\n * @param pattern - Regular expression to match.\n * @template Pattern - The pattern type, defaults to `string`.\n * @returns A new string-struct that matches the given pattern.\n */\nexport function definePattern<Pattern extends string = string>(\n  name: string,\n  pattern: RegExp,\n): Struct<Pattern, null> {\n  return define<Pattern>(name, (value: unknown): boolean | string => {\n    return typeof value === 'string' && pattern.test(value);\n  });\n}\n"]}

package/dist/time.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Common duration constants, in milliseconds.
+ */
+export declare enum Duration {
+    /**
+     * A millisecond.
+     */
+    Millisecond = 1,
+    /**
+     * A second, in milliseconds.
+     */
+    Second = 1000,// Millisecond * 1000
+    /**
+     * A minute, in milliseconds.
+     */
+    Minute = 60000,// Second * 60
+    /**
+     * An hour, in milliseconds.
+     */
+    Hour = 3600000,// Minute * 60
+    /**
+     * A day, in milliseconds.
+     */
+    Day = 86400000,// Hour * 24
+    /**
+     * A week, in milliseconds.
+     */
+    Week = 604800000,// Day * 7
+    /**
+     * A year, in milliseconds.
+     */
+    Year = 31536000000
+}
+/**
+ * Calculates the millisecond value of the specified number of units of time.
+ *
+ * @param count - The number of units of time.
+ * @param duration - The unit of time to count.
+ * @returns The count multiplied by the specified duration.
+ */
+export declare function inMilliseconds(count: number, duration: Duration): number;
+/**
+ * Gets the milliseconds since a particular Unix epoch timestamp.
+ *
+ * @param timestamp - A Unix millisecond timestamp.
+ * @returns The number of milliseconds elapsed since the specified timestamp.
+ */
+export declare function timeSince(timestamp: number): number;
+//# sourceMappingURL=time.d.ts.map

package/dist/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../src/time.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,QAAQ;IAClB;;OAEG;IACH,WAAW,IAAI;IAEf;;OAEG;IACH,MAAM,OAAO,CAAE,qBAAqB;IAEpC;;OAEG;IACH,MAAM,QAAS,CAAE,cAAc;IAE/B;;OAEG;IACH,IAAI,UAAY,CAAE,cAAc;IAEhC;;OAEG;IACH,GAAG,WAAa,CAAE,YAAY;IAE9B;;OAEG;IACH,IAAI,YAAc,CAAE,UAAU;IAE9B;;OAEG;IACH,IAAI,cAAiB;CACtB;AAaD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAGxE;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAGnD"}

package/dist/time.js

@@ -0,0 +1,62 @@
+/**
+ * Common duration constants, in milliseconds.
+ */
+export var Duration;
+(function (Duration) {
+    /**
+     * A millisecond.
+     */
+    Duration[Duration["Millisecond"] = 1] = "Millisecond";
+    /**
+     * A second, in milliseconds.
+     */
+    Duration[Duration["Second"] = 1000] = "Second";
+    /**
+     * A minute, in milliseconds.
+     */
+    Duration[Duration["Minute"] = 60000] = "Minute";
+    /**
+     * An hour, in milliseconds.
+     */
+    Duration[Duration["Hour"] = 3600000] = "Hour";
+    /**
+     * A day, in milliseconds.
+     */
+    Duration[Duration["Day"] = 86400000] = "Day";
+    /**
+     * A week, in milliseconds.
+     */
+    Duration[Duration["Week"] = 604800000] = "Week";
+    /**
+     * A year, in milliseconds.
+     */
+    Duration[Duration["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}".`);
+    }
+};
+/**
+ * Calculates the millisecond value of the specified number of units of time.
+ *
+ * @param count - The number of units of time.
+ * @param duration - The unit of time to count.
+ * @returns The count multiplied by the specified duration.
+ */
+export function inMilliseconds(count, duration) {
+    assertIsNonNegativeInteger(count, 'count');
+    return count * duration;
+}
+/**
+ * Gets the milliseconds since a particular Unix epoch timestamp.
+ *
+ * @param timestamp - A Unix millisecond timestamp.
+ * @returns The number of milliseconds elapsed since the specified timestamp.
+ */
+export function timeSince(timestamp) {
+    assertIsNonNegativeInteger(timestamp, 'timestamp');
+    return Date.now() - timestamp;
+}
+//# sourceMappingURL=time.js.map

package/dist/time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.js","sourceRoot":"","sources":["../src/time.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAN,IAAY,QAmCX;AAnCD,WAAY,QAAQ;IAClB;;OAEG;IACH,qDAAe,CAAA;IAEf;;OAEG;IACH,8CAAa,CAAA;IAEb;;OAEG;IACH,+CAAe,CAAA;IAEf;;OAEG;IACH,6CAAgB,CAAA;IAEhB;;OAEG;IACH,4CAAgB,CAAA;IAEhB;;OAEG;IACH,+CAAkB,CAAA;IAElB;;OAEG;IACH,iDAAqB,CAAA;AACvB,CAAC,EAnCW,QAAQ,KAAR,QAAQ,QAmCnB;AAED,MAAM,oBAAoB,GAAG,CAAC,MAAc,EAAE,EAAE,CAC9C,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC,CAAC;AAE1C,MAAM,0BAA0B,GAAG,CAAC,MAAc,EAAE,IAAY,EAAE,EAAE;IAClE,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CACb,IAAI,IAAI,gDAAgD,MAAM,IAAI,CACnE,CAAC;IACJ,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,KAAa,EAAE,QAAkB;IAC9D,0BAA0B,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC3C,OAAO,KAAK,GAAG,QAAQ,CAAC;AAC1B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,SAAiB;IACzC,0BAA0B,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;IACnD,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;AAChC,CAAC","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"]}