@metamask/utils 8.4.0 → 8.5.0

package/dist/number.cjs

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexToBigInt = exports.hexToNumber = exports.bigIntToHex = exports.numberToHex = void 0;
+const assert_1 = require("./assert.cjs");
+const hex_1 = require("./hex.cjs");
+/**
+ * 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.
+ */
+const numberToHex = (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 `bigIntToHex` instead.');
+    return (0, hex_1.add0x)(value.toString(16));
+};
+exports.numberToHex = numberToHex;
+/**
+ * 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.
+ */
+const bigIntToHex = (value) => {
+    (0, assert_1.assert)(typeof value === 'bigint', 'Value must be a bigint.');
+    (0, assert_1.assert)(value >= 0, 'Value must be a non-negative bigint.');
+    return (0, hex_1.add0x)(value.toString(16));
+};
+exports.bigIntToHex = bigIntToHex;
+/**
+ * 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.
+ */
+const hexToNumber = (value) => {
+    (0, hex_1.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_1.assert)(Number.isSafeInteger(numberValue), 'Value is not a safe integer. Use `hexToBigInt` instead.');
+    return numberValue;
+};
+exports.hexToNumber = hexToNumber;
+/**
+ * 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.
+ */
+const hexToBigInt = (value) => {
+    (0, hex_1.assertIsHexString)(value);
+    // The `BigInt` constructor requires the "0x"-prefix to parse a hex string.
+    return BigInt((0, hex_1.add0x)(value));
+};
+exports.hexToBigInt = hexToBigInt;
+//# sourceMappingURL=number.cjs.map

package/dist/number.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.cjs","sourceRoot":"","sources":["../src/number.ts"],"names":[],"mappings":";;;AAAA,yCAAkC;AAClC,mCAAiD;AAEjD;;;;;;;;;;;;;;;;GAgBG;AACI,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE;IACnD,IAAA,eAAM,EAAC,OAAO,KAAK,KAAK,QAAQ,EAAE,yBAAyB,CAAC,CAAC;IAC7D,IAAA,eAAM,EAAC,KAAK,IAAI,CAAC,EAAE,sCAAsC,CAAC,CAAC;IAC3D,IAAA,eAAM,EACJ,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,EAC3B,yDAAyD,CAC1D,CAAC;IAEF,OAAO,IAAA,WAAK,EAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;AACnC,CAAC,CAAC;AATW,QAAA,WAAW,eAStB;AAEF;;;;;;;;;;;;;;;GAeG;AACI,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE;IACnD,IAAA,eAAM,EAAC,OAAO,KAAK,KAAK,QAAQ,EAAE,yBAAyB,CAAC,CAAC;IAC7D,IAAA,eAAM,EAAC,KAAK,IAAI,CAAC,EAAE,sCAAsC,CAAC,CAAC;IAE3D,OAAO,IAAA,WAAK,EAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;AACnC,CAAC,CAAC;AALW,QAAA,WAAW,eAKtB;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACI,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE;IACnD,IAAA,uBAAiB,EAAC,KAAK,CAAC,CAAC;IAEzB,2EAA2E;IAC3E,kEAAkE;IAClE,MAAM,WAAW,GAAG,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAExC,IAAA,eAAM,EACJ,MAAM,CAAC,aAAa,CAAC,WAAW,CAAC,EACjC,yDAAyD,CAC1D,CAAC;IAEF,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAbW,QAAA,WAAW,eAatB;AAEF;;;;;;;;;;;;;;;GAeG;AACI,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE;IACnD,IAAA,uBAAiB,EAAC,KAAK,CAAC,CAAC;IAEzB,2EAA2E;IAC3E,OAAO,MAAM,CAAC,IAAA,WAAK,EAAC,KAAK,CAAC,CAAC,CAAC;AAC9B,CAAC,CAAC;AALW,QAAA,WAAW,eAKtB","sourcesContent":["import { assert } from './assert';\nimport { add0x, assertIsHexString } from './hex';\n\n/**\n * Convert a number to a hexadecimal string. This verifies that the number is a\n * non-negative safe integer.\n *\n * To convert a `bigint` to a hexadecimal string instead, use\n * {@link bigIntToHex}.\n *\n * @example\n * ```typescript\n * numberToHex(0); // '0x0'\n * numberToHex(1); // '0x1'\n * numberToHex(16); // '0x10'\n * ```\n * @param value - The number to convert to a hexadecimal string.\n * @returns The hexadecimal string, with the \"0x\"-prefix.\n * @throws If the number is not a non-negative safe integer.\n */\nexport const numberToHex = (value: number): string => {\n  assert(typeof value === 'number', 'Value must be a number.');\n  assert(value >= 0, 'Value must be a non-negative number.');\n  assert(\n    Number.isSafeInteger(value),\n    'Value is not a safe integer. Use `bigIntToHex` instead.',\n  );\n\n  return add0x(value.toString(16));\n};\n\n/**\n * Convert a `bigint` to a hexadecimal string. This verifies that the `bigint`\n * is a non-negative integer.\n *\n * To convert a number to a hexadecimal string instead, use {@link numberToHex}.\n *\n * @example\n * ```typescript\n * bigIntToHex(0n); // '0x0'\n * bigIntToHex(1n); // '0x1'\n * bigIntToHex(16n); // '0x10'\n * ```\n * @param value - The `bigint` to convert to a hexadecimal string.\n * @returns The hexadecimal string, with the \"0x\"-prefix.\n * @throws If the `bigint` is not a non-negative integer.\n */\nexport const bigIntToHex = (value: bigint): string => {\n  assert(typeof value === 'bigint', 'Value must be a bigint.');\n  assert(value >= 0, 'Value must be a non-negative bigint.');\n\n  return add0x(value.toString(16));\n};\n\n/**\n * Convert a hexadecimal string to a number. This verifies that the string is a\n * valid hex string, and that the resulting number is a safe integer. Both\n * \"0x\"-prefixed and unprefixed strings are supported.\n *\n * To convert a hexadecimal string to a `bigint` instead, use\n * {@link hexToBigInt}.\n *\n * @example\n * ```typescript\n * hexToNumber('0x0'); // 0\n * hexToNumber('0x1'); // 1\n * hexToNumber('0x10'); // 16\n * ```\n * @param value - The hexadecimal string to convert to a number.\n * @returns The number.\n * @throws If the value is not a valid hexadecimal string, or if the resulting\n * number is not a safe integer.\n */\nexport const hexToNumber = (value: string): number => {\n  assertIsHexString(value);\n\n  // `parseInt` accepts values without the \"0x\"-prefix, whereas `Number` does\n  // not. Using this is slightly faster than `Number(add0x(value))`.\n  const numberValue = parseInt(value, 16);\n\n  assert(\n    Number.isSafeInteger(numberValue),\n    'Value is not a safe integer. Use `hexToBigInt` instead.',\n  );\n\n  return numberValue;\n};\n\n/**\n * Convert a hexadecimal string to a `bigint`. This verifies that the string is\n * a valid hex string. Both \"0x\"-prefixed and unprefixed strings are supported.\n *\n * To convert a hexadecimal string to a number instead, use {@link hexToNumber}.\n *\n * @example\n * ```typescript\n * hexToBigInt('0x0'); // 0n\n * hexToBigInt('0x1'); // 1n\n * hexToBigInt('0x10'); // 16n\n * ```\n * @param value - The hexadecimal string to convert to a `bigint`.\n * @returns The `bigint`.\n * @throws If the value is not a valid hexadecimal string.\n */\nexport const hexToBigInt = (value: string): bigint => {\n  assertIsHexString(value);\n\n  // The `BigInt` constructor requires the \"0x\"-prefix to parse a hex string.\n  return BigInt(add0x(value));\n};\n"]}

package/dist/{types/number.d.ts → number.d.cts}

@@ -70,4 +70,4 @@ export declare const hexToNumber: (value: string) => number;
  * @throws If the value is not a valid hexadecimal string.
  */
 export declare const hexToBigInt: (value: string) => bigint;
-//# sourceMappingURL=number.d.ts.map
+//# sourceMappingURL=number.d.cts.map

package/dist/number.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.cts","sourceRoot":"","sources":["../src/number.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,MAS3C,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,MAK3C,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.d.mts

@@ -0,0 +1,73 @@
+/**
+ * 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) => string;
+/**
+ * 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) => string;
+/**
+ * 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.mts.map

package/dist/number.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.mts","sourceRoot":"","sources":["../src/number.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,MAS3C,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,MAK3C,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.mjs

@@ -1,18 +1,95 @@
-import {
-  bigIntToHex,
-  hexToBigInt,
-  hexToNumber,
-  numberToHex
-} from "./chunk-S3UHBN2Z.mjs";
-import "./chunk-VA2DRBDE.mjs";
-import "./chunk-74DGVJVE.mjs";
-import "./chunk-XYGUOY6N.mjs";
-import "./chunk-H4YFDLB7.mjs";
-import "./chunk-X66SUIEF.mjs";
-export {
-  bigIntToHex,
-  hexToBigInt,
-  hexToNumber,
-  numberToHex
+import { assert } from "./assert.mjs";
+import { add0x, assertIsHexString } from "./hex.mjs";
+/**
+ * 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.mjs.map

package/dist/number.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"number.mjs","sourceRoot":"","sources":["../src/number.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,qBAAiB;AAClC,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,kBAAc;AAEjD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE;IACnD,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,EAAU,EAAE;IACnD,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';\nimport { add0x, assertIsHexString } from './hex';\n\n/**\n * Convert a number to a hexadecimal string. This verifies that the number is a\n * non-negative safe integer.\n *\n * To convert a `bigint` to a hexadecimal string instead, use\n * {@link bigIntToHex}.\n *\n * @example\n * ```typescript\n * numberToHex(0); // '0x0'\n * numberToHex(1); // '0x1'\n * numberToHex(16); // '0x10'\n * ```\n * @param value - The number to convert to a hexadecimal string.\n * @returns The hexadecimal string, with the \"0x\"-prefix.\n * @throws If the number is not a non-negative safe integer.\n */\nexport const numberToHex = (value: number): string => {\n  assert(typeof value === 'number', 'Value must be a number.');\n  assert(value >= 0, 'Value must be a non-negative number.');\n  assert(\n    Number.isSafeInteger(value),\n    'Value is not a safe integer. Use `bigIntToHex` instead.',\n  );\n\n  return add0x(value.toString(16));\n};\n\n/**\n * Convert a `bigint` to a hexadecimal string. This verifies that the `bigint`\n * is a non-negative integer.\n *\n * To convert a number to a hexadecimal string instead, use {@link numberToHex}.\n *\n * @example\n * ```typescript\n * bigIntToHex(0n); // '0x0'\n * bigIntToHex(1n); // '0x1'\n * bigIntToHex(16n); // '0x10'\n * ```\n * @param value - The `bigint` to convert to a hexadecimal string.\n * @returns The hexadecimal string, with the \"0x\"-prefix.\n * @throws If the `bigint` is not a non-negative integer.\n */\nexport const bigIntToHex = (value: bigint): string => {\n  assert(typeof value === 'bigint', 'Value must be a bigint.');\n  assert(value >= 0, 'Value must be a non-negative bigint.');\n\n  return add0x(value.toString(16));\n};\n\n/**\n * Convert a hexadecimal string to a number. This verifies that the string is a\n * valid hex string, and that the resulting number is a safe integer. Both\n * \"0x\"-prefixed and unprefixed strings are supported.\n *\n * To convert a hexadecimal string to a `bigint` instead, use\n * {@link hexToBigInt}.\n *\n * @example\n * ```typescript\n * hexToNumber('0x0'); // 0\n * hexToNumber('0x1'); // 1\n * hexToNumber('0x10'); // 16\n * ```\n * @param value - The hexadecimal string to convert to a number.\n * @returns The number.\n * @throws If the value is not a valid hexadecimal string, or if the resulting\n * number is not a safe integer.\n */\nexport const hexToNumber = (value: string): number => {\n  assertIsHexString(value);\n\n  // `parseInt` accepts values without the \"0x\"-prefix, whereas `Number` does\n  // not. Using this is slightly faster than `Number(add0x(value))`.\n  const numberValue = parseInt(value, 16);\n\n  assert(\n    Number.isSafeInteger(numberValue),\n    'Value is not a safe integer. Use `hexToBigInt` instead.',\n  );\n\n  return numberValue;\n};\n\n/**\n * Convert a hexadecimal string to a `bigint`. This verifies that the string is\n * a valid hex string. Both \"0x\"-prefixed and unprefixed strings are supported.\n *\n * To convert a hexadecimal string to a number instead, use {@link hexToNumber}.\n *\n * @example\n * ```typescript\n * hexToBigInt('0x0'); // 0n\n * hexToBigInt('0x1'); // 1n\n * hexToBigInt('0x10'); // 16n\n * ```\n * @param value - The hexadecimal string to convert to a `bigint`.\n * @returns The `bigint`.\n * @throws If the value is not a valid hexadecimal string.\n */\nexport const hexToBigInt = (value: string): bigint => {\n  assertIsHexString(value);\n\n  // The `BigInt` constructor requires the \"0x\"-prefix to parse a hex string.\n  return BigInt(add0x(value));\n};\n"]}

package/dist/opaque.cjs

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=opaque.cjs.map

package/dist/opaque.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"opaque.cjs","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/opaque.d.cts

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

package/dist/opaque.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opaque.d.cts","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.d.mts

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

package/dist/opaque.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opaque.d.mts","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.mjs

@@ -1,2 +1,2 @@
-import "./chunk-AY6FDCBT.mjs";
+export {};
 //# sourceMappingURL=opaque.mjs.map

package/dist/opaque.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"opaque.mjs","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.cjs

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeferredPromise = void 0;
+/**
+ * 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.
+ */
+function createDeferredPromise({ suppressUnhandledRejection = false, } = {}) {
+    let resolve;
+    let reject;
+    const promise = new Promise((innerResolve, innerReject) => {
+        resolve = innerResolve;
+        reject = innerReject;
+    });
+    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 };
+}
+exports.createDeferredPromise = createDeferredPromise;
+//# sourceMappingURL=promise.cjs.map

package/dist/promise.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.cjs","sourceRoot":"","sources":["../src/promise.ts"],"names":[],"mappings":";;;AAsBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,qBAAqB,CAAgB,EACnD,0BAA0B,GAAG,KAAK,MAGhC,EAAE;IACJ,IAAI,OAA2C,CAAC;IAChD,IAAI,MAAyC,CAAC;IAC9C,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;IAEF,IAAI,0BAA0B,EAAE;QAC9B,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE;YACvB,uEAAuE;QACzE,CAAC,CAAC,CAAC;KACJ;IAED,2EAA2E;IAC3E,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;AACtC,CAAC;AAzBD,sDAyBC","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  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\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/{types/promise.d.ts → promise.d.cts}

@@ -5,7 +5,7 @@
  * the Promise construction.
  * @template Result - The result type of the Promise.
  */
-export declare type DeferredPromise<Result = void> = {
+export type DeferredPromise<Result = void> = {
     /**
      * The Promise that has been deferred.
      */
@@ -42,4 +42,4 @@ export declare type DeferredPromise<Result = void> = {
 export declare function createDeferredPromise<Result = void>({ suppressUnhandledRejection, }?: {
     suppressUnhandledRejection?: boolean;
 }): DeferredPromise<Result>;
-//# sourceMappingURL=promise.d.ts.map
+//# sourceMappingURL=promise.d.cts.map

package/dist/promise.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.d.cts","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,CAqB/B"}

package/dist/promise.d.mts

@@ -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.mts.map

package/dist/promise.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.d.mts","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,CAqB/B"}

package/dist/promise.mjs

@@ -1,8 +1,36 @@
-import {
-  createDeferredPromise
-} from "./chunk-W5XI7ERF.mjs";
-import "./chunk-X66SUIEF.mjs";
-export {
-  createDeferredPromise
-};
+/**
+ * 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;
+    const promise = new Promise((innerResolve, innerReject) => {
+        resolve = innerResolve;
+        reject = innerReject;
+    });
+    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.mjs.map

package/dist/promise.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"promise.mjs","sourceRoot":"","sources":["../src/promise.ts"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,qBAAqB,CAAgB,EACnD,0BAA0B,GAAG,KAAK,MAGhC,EAAE;IACJ,IAAI,OAA2C,CAAC;IAChD,IAAI,MAAyC,CAAC;IAC9C,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;IAEF,IAAI,0BAA0B,EAAE;QAC9B,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE;YACvB,uEAAuE;QACzE,CAAC,CAAC,CAAC;KACJ;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  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\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/time.cjs

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeSince = exports.inMilliseconds = exports.Duration = void 0;
+/**
+ * Common duration constants, in milliseconds.
+ */
+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 = exports.Duration || (exports.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.
+ */
+function inMilliseconds(count, duration) {
+    assertIsNonNegativeInteger(count, 'count');
+    return count * duration;
+}
+exports.inMilliseconds = inMilliseconds;
+/**
+ * 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.
+ */
+function timeSince(timestamp) {
+    assertIsNonNegativeInteger(timestamp, 'timestamp');
+    return Date.now() - timestamp;
+}
+exports.timeSince = timeSince;
+//# sourceMappingURL=time.cjs.map

package/dist/time.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.cjs","sourceRoot":"","sources":["../src/time.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,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,GAAR,gBAAQ,KAAR,gBAAQ,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;QACjC,MAAM,IAAI,KAAK,CACb,IAAI,IAAI,gDAAgD,MAAM,IAAI,CACnE,CAAC;KACH;AACH,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,SAAgB,cAAc,CAAC,KAAa,EAAE,QAAkB;IAC9D,0BAA0B,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC3C,OAAO,KAAK,GAAG,QAAQ,CAAC;AAC1B,CAAC;AAHD,wCAGC;AAED;;;;;GAKG;AACH,SAAgB,SAAS,CAAC,SAAiB;IACzC,0BAA0B,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;IACnD,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;AAChC,CAAC;AAHD,8BAGC","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"]}

package/dist/{types/time.d.ts → time.d.cts}

@@ -46,4 +46,4 @@ export declare function inMilliseconds(count: number, duration: Duration): numbe
  * @returns The number of milliseconds elapsed since the specified timestamp.
  */
 export declare function timeSince(timestamp: number): number;
-//# sourceMappingURL=time.d.ts.map
+//# sourceMappingURL=time.d.cts.map

package/dist/time.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.cts","sourceRoot":"","sources":["../src/time.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,QAAQ;IAClB;;OAEG;IACH,WAAW,IAAI;IAEf;;OAEG;IACH,MAAM,OAAO;IAEb;;OAEG;IACH,MAAM,QAAS;IAEf;;OAEG;IACH,IAAI,UAAY;IAEhB;;OAEG;IACH,GAAG,WAAa;IAEhB;;OAEG;IACH,IAAI,YAAc;IAElB;;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"}