@metamask/utils 6.2.0 → 7.0.0

package/dist/misc.test-d.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tsd_1 = require("tsd");
-const misc_1 = require("./misc");
-//=============================================================================
-// isObject
-//=============================================================================
-// eslint-disable-next-line @typescript-eslint/ban-types
-const unknownValue = {};
-(0, tsd_1.expectNotAssignable)(unknownValue);
-if ((0, misc_1.isObject)(unknownValue)) {
-    (0, tsd_1.expectAssignable)(unknownValue);
-}
-// Does not interfere with satisfaction of static type
-const constObjectType = { foo: 'foo' };
-if ((0, misc_1.hasProperty)(constObjectType, 'foo')) {
-    (0, tsd_1.expectAssignable)(constObjectType);
-}
-//=============================================================================
-// hasProperty
-//=============================================================================
-// eslint-disable-next-line @typescript-eslint/ban-types
-const unknownObject = {};
-// Establish that `Object` is not accepted when a specific property is needed.
-(0, tsd_1.expectNotAssignable)(unknownObject);
-// Establish that `RuntimeObject` is not accepted when a specific property is needed.
-if ((0, misc_1.isObject)(unknownObject)) {
-    (0, tsd_1.expectNotAssignable)(unknownObject);
-}
-// An object is accepted after `hasProperty` is used to prove that it has the required property.
-if ((0, misc_1.isObject)(unknownObject) && (0, misc_1.hasProperty)(unknownObject, 'foo')) {
-    (0, tsd_1.expectAssignable)(unknownObject);
-}
-// An object is accepted after `hasProperty` is used to prove that it has all required properties.
-if ((0, misc_1.isObject)(unknownObject) &&
-    (0, misc_1.hasProperty)(unknownObject, 'foo') &&
-    (0, misc_1.hasProperty)(unknownObject, 'bar')) {
-    (0, tsd_1.expectAssignable)(unknownObject);
-}
-// An object is not accepted after `hasProperty` has only been used to establish that some required properties exist.
-if ((0, misc_1.isObject)(unknownObject) && (0, misc_1.hasProperty)(unknownObject, 'foo')) {
-    (0, tsd_1.expectNotAssignable)(unknownObject);
-}
-// Does not interfere with satisfaction of non-overlapping types
-const overlappingTypesExample = { foo: 'foo', baz: 'baz' };
-if ((0, misc_1.hasProperty)(overlappingTypesExample, 'foo')) {
-    (0, tsd_1.expectAssignable)(overlappingTypesExample);
-}
-const exampleErrorWithCode = new Error('test');
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-exampleErrorWithCode.code = 999;
-// Establish that trying to check for a custom property on an error results in failure
-(0, tsd_1.expectNotAssignable)(exampleErrorWithCode);
-// Using custom Error property is allowed after checking with `hasProperty`
-if ((0, misc_1.hasProperty)(exampleErrorWithCode, 'code')) {
-    (0, tsd_1.expectType)(exampleErrorWithCode.code);
-}
-const hasPropertyInterfaceExample = { a: 0 };
-(0, misc_1.hasProperty)(hasPropertyInterfaceExample, 'a');
-// `hasProperty` is compatible with classes
-class HasPropertyClassExample {
-}
-const hasPropertyClassExample = new HasPropertyClassExample();
-(0, misc_1.hasProperty)(hasPropertyClassExample, 'a');
-// It keeps the original type when defined.
-const hasPropertyTypeExample = {};
-if ((0, misc_1.hasProperty)(hasPropertyTypeExample, 'a')) {
-    (0, tsd_1.expectType)(hasPropertyTypeExample.a);
-}
-//=============================================================================
-// RuntimeObject
-//=============================================================================
-// Valid runtime objects:
-(0, tsd_1.expectAssignable)({});
-(0, tsd_1.expectAssignable)({ foo: 'foo' });
-// eslint-disable-next-line @typescript-eslint/naming-convention
-(0, tsd_1.expectAssignable)({ 0: 'foo' });
-(0, tsd_1.expectAssignable)({ [Symbol('foo')]: 'foo' });
-// Invalid runtime objects:
-(0, tsd_1.expectNotAssignable)(null);
-(0, tsd_1.expectNotAssignable)(undefined);
-(0, tsd_1.expectNotAssignable)('foo');
-(0, tsd_1.expectNotAssignable)(0);
-(0, tsd_1.expectNotAssignable)([]);
-(0, tsd_1.expectNotAssignable)(new Date());
-(0, tsd_1.expectNotAssignable)(() => 0);
-(0, tsd_1.expectNotAssignable)(new Set());
-(0, tsd_1.expectNotAssignable)(new Map());
-(0, tsd_1.expectNotAssignable)(Symbol('test'));
-const runtimeObjectInterfaceExample = { a: 0 };
-(0, tsd_1.expectNotAssignable)(runtimeObjectInterfaceExample);
-class RuntimeObjectClassExample {
-}
-const runtimeObjectClassExample = new RuntimeObjectClassExample();
-(0, tsd_1.expectNotAssignable)(runtimeObjectClassExample);
-//# sourceMappingURL=misc.test-d.js.map

package/dist/misc.test-d.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"misc.test-d.js","sourceRoot":"","sources":["../src/misc.test-d.ts"],"names":[],"mappings":"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","sourcesContent":["import { expectAssignable, expectNotAssignable, expectType } from 'tsd';\n\nimport { isObject, hasProperty, RuntimeObject } from './misc';\n\n//=============================================================================\n// isObject\n//=============================================================================\n\n// eslint-disable-next-line @typescript-eslint/ban-types\nconst unknownValue = {} as unknown;\n\nexpectNotAssignable<RuntimeObject>(unknownValue);\n\nif (isObject(unknownValue)) {\n  expectAssignable<RuntimeObject>(unknownValue);\n}\n\n// Does not interfere with satisfaction of static type\nconst constObjectType = { foo: 'foo' } as const;\nif (hasProperty(constObjectType, 'foo')) {\n  expectAssignable<{ foo: 'foo' }>(constObjectType);\n}\n\n//=============================================================================\n// hasProperty\n//=============================================================================\n\n// eslint-disable-next-line @typescript-eslint/ban-types\nconst unknownObject = {} as Object;\n\n// Establish that `Object` is not accepted when a specific property is needed.\nexpectNotAssignable<Record<'foo', unknown>>(unknownObject);\n\n// Establish that `RuntimeObject` is not accepted when a specific property is needed.\nif (isObject(unknownObject)) {\n  expectNotAssignable<Record<'foo', unknown>>(unknownObject);\n}\n\n// An object is accepted after `hasProperty` is used to prove that it has the required property.\nif (isObject(unknownObject) && hasProperty(unknownObject, 'foo')) {\n  expectAssignable<Record<'foo', unknown>>(unknownObject);\n}\n\n// An object is accepted after `hasProperty` is used to prove that it has all required properties.\nif (\n  isObject(unknownObject) &&\n  hasProperty(unknownObject, 'foo') &&\n  hasProperty(unknownObject, 'bar')\n) {\n  expectAssignable<Record<'foo' | 'bar', unknown>>(unknownObject);\n}\n\n// An object is not accepted after `hasProperty` has only been used to establish that some required properties exist.\nif (isObject(unknownObject) && hasProperty(unknownObject, 'foo')) {\n  expectNotAssignable<Record<'foo' | 'bar', unknown>>(unknownObject);\n}\n\n// Does not interfere with satisfaction of non-overlapping types\nconst overlappingTypesExample = { foo: 'foo', baz: 'baz' };\nif (hasProperty(overlappingTypesExample, 'foo')) {\n  expectAssignable<Record<'baz', unknown>>(overlappingTypesExample);\n}\n\nconst exampleErrorWithCode = new Error('test');\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nexampleErrorWithCode.code = 999;\n\n// Establish that trying to check for a custom property on an error results in failure\nexpectNotAssignable<{ code: any }>(exampleErrorWithCode);\n\n// Using custom Error property is allowed after checking with `hasProperty`\nif (hasProperty(exampleErrorWithCode, 'code')) {\n  expectType<unknown>(exampleErrorWithCode.code);\n}\n\n// `hasProperty` is compatible with interfaces\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\ninterface HasPropertyInterfaceExample {\n  a: number;\n}\nconst hasPropertyInterfaceExample: HasPropertyInterfaceExample = { a: 0 };\nhasProperty(hasPropertyInterfaceExample, 'a');\n\n// `hasProperty` is compatible with classes\nclass HasPropertyClassExample {\n  a!: number;\n}\nconst hasPropertyClassExample = new HasPropertyClassExample();\nhasProperty(hasPropertyClassExample, 'a');\n\ntype HasPropertyTypeExample = {\n  a?: number;\n};\n\n// It keeps the original type when defined.\nconst hasPropertyTypeExample: HasPropertyTypeExample = {};\nif (hasProperty(hasPropertyTypeExample, 'a')) {\n  expectType<number | undefined>(hasPropertyTypeExample.a);\n}\n\n//=============================================================================\n// RuntimeObject\n//=============================================================================\n\n// Valid runtime objects:\n\nexpectAssignable<RuntimeObject>({});\n\nexpectAssignable<RuntimeObject>({ foo: 'foo' });\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexpectAssignable<RuntimeObject>({ 0: 'foo' });\n\nexpectAssignable<RuntimeObject>({ [Symbol('foo')]: 'foo' });\n\n// Invalid runtime objects:\n\nexpectNotAssignable<RuntimeObject>(null);\n\nexpectNotAssignable<RuntimeObject>(undefined);\n\nexpectNotAssignable<RuntimeObject>('foo');\n\nexpectNotAssignable<RuntimeObject>(0);\n\nexpectNotAssignable<RuntimeObject>([]);\n\nexpectNotAssignable<RuntimeObject>(new Date());\n\nexpectNotAssignable<RuntimeObject>(() => 0);\n\nexpectNotAssignable<RuntimeObject>(new Set());\n\nexpectNotAssignable<RuntimeObject>(new Map());\n\nexpectNotAssignable<RuntimeObject>(Symbol('test'));\n\n// The RuntimeObject type gets confused by interfaces. This interface is a valid object,\n// but it's incompatible with the RuntimeObject type.\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\ninterface RuntimeObjectInterfaceExample {\n  a: number;\n}\nconst runtimeObjectInterfaceExample: RuntimeObjectInterfaceExample = { a: 0 };\nexpectNotAssignable<RuntimeObject>(runtimeObjectInterfaceExample);\n\nclass RuntimeObjectClassExample {\n  a!: number;\n}\nconst runtimeObjectClassExample = new RuntimeObjectClassExample();\nexpectNotAssignable<RuntimeObject>(runtimeObjectClassExample);\n"]}

package/dist/number.js.map

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

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

package/dist/opaque.js.map

@@ -1 +0,0 @@
-{"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/time.js

@@ -1,67 +0,0 @@
-"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.js.map

package/dist/time.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"time.js","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/transaction-types.js

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

package/dist/transaction-types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transaction-types.js","sourceRoot":"","sources":["../src/transaction-types.ts"],"names":[],"mappings":"","sourcesContent":["import { Bytes } from './bytes';\nimport { Hex } from './hex';\n\nexport type Transaction =\n  | LegacyTransaction\n  | EIP2930Transaction\n  | EIP1559Transaction;\n\nexport type SignedTransaction = Transaction & Signature;\n\nexport type Signature = {\n  /**\n   * EC signature parameter\n   * 32 bytes long sequence.\n   */\n  r: Bytes;\n\n  /**\n   * EC signature parameter\n   * Signature proof.\n   * 32 bytes long sequence\n   */\n  s: Bytes;\n\n  /**\n   * Recovery identifier. It can be either 0x1b or 0x1c\n   * 1 byte long sequence\n   */\n  yParity: Bytes;\n};\n\n/**\n * Base Ethereum Transaction\n */\nexport type BaseTransaction = {\n  /**\n   * Sequentially incrementing counter which indicates the transaction\n   * number from the account\n   */\n  nonce: Bytes;\n\n  /**\n   * The address of the sender, that will be signing the transaction\n   */\n  from: Hex | Uint8Array;\n\n  /**\n   * The receiving address.\n   * If an externally-owned account, the transaction will transfer value.\n   * If a contract account, the transaction will execute the contract code.\n   */\n  to: Hex | Uint8Array;\n\n  /**\n   * The amount of Ether sent.\n   */\n  value: Bytes;\n\n  /**\n   * Maximum amount of gas units that this transaction can consume.\n   */\n  gasLimit: Bytes;\n\n  /**\n   * Arbitrary data.\n   */\n  data?: Bytes;\n};\n\n/**\n * Typed Ethereum Transaction\n */\nexport type TypedTransaction = BaseTransaction & {\n  /**\n   * Transaction type.\n   */\n  type: number;\n};\n\n/**\n * Ethereum Legacy Transaction\n * Reference: https://ethereum.org/en/developers/docs/transactions/\n */\nexport type LegacyTransaction = BaseTransaction & {\n  /**\n   * Transaction's gas price.\n   */\n  gasPrice: Bytes | null;\n};\n\n/**\n * EIP-2930 Transaction: Optional Access Lists\n * Reference: https://eips.ethereum.org/EIPS/eip-2930\n */\nexport type EIP2930Transaction = TypedTransaction & {\n  /**\n   * Transaction type.\n   */\n  type: 1;\n\n  /**\n   * Transaction chain ID\n   */\n  chainId: Bytes;\n\n  /**\n   * List of addresses and storage keys that the transaction plans to access\n   */\n  accessList:\n    | { address: Hex; storageKeys: Hex[] }[]\n    | { address: Uint8Array; storageKeys: Uint8Array[] }[];\n};\n\n/**\n * EIP-1559 Transaction: Fee market change for ETH 1.0 chain (Type-2)\n *\n * Reference: https://eips.ethereum.org/EIPS/eip-1559\n */\nexport type EIP1559Transaction = TypedTransaction & {\n  /**\n   * Transaction type.\n   */\n  type: 2;\n\n  /**\n   * Maximum fee to give to the miner\n   */\n  maxPriorityFeePerGas: Bytes;\n\n  /**\n   * Maximum total fee\n   */\n  maxFeePerGas: Bytes;\n};\n"]}

package/dist/versions.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.satisfiesVersionRange = exports.gtRange = exports.gtVersion = exports.assertIsSemVerRange = exports.assertIsSemVerVersion = exports.isValidSemVerRange = exports.isValidSemVerVersion = exports.VersionRangeStruct = exports.VersionStruct = void 0;
-const semver_1 = require("semver");
-const superstruct_1 = require("superstruct");
-const assert_1 = require("./assert");
-/**
- * A struct for validating a version string.
- */
-exports.VersionStruct = (0, superstruct_1.refine)((0, superstruct_1.string)(), 'Version', (value) => {
-    if ((0, semver_1.valid)(value) === null) {
-        return `Expected SemVer version, got "${value}"`;
-    }
-    return true;
-});
-exports.VersionRangeStruct = (0, superstruct_1.refine)((0, superstruct_1.string)(), 'Version range', (value) => {
-    if ((0, semver_1.validRange)(value) === null) {
-        return `Expected SemVer range, got "${value}"`;
-    }
-    return true;
-});
-/**
- * Checks whether a SemVer version is valid.
- *
- * @param version - A potential version.
- * @returns `true` if the version is valid, and `false` otherwise.
- */
-function isValidSemVerVersion(version) {
-    return (0, superstruct_1.is)(version, exports.VersionStruct);
-}
-exports.isValidSemVerVersion = isValidSemVerVersion;
-/**
- * Checks whether a SemVer version range is valid.
- *
- * @param versionRange - A potential version range.
- * @returns `true` if the version range is valid, and `false` otherwise.
- */
-function isValidSemVerRange(versionRange) {
-    return (0, superstruct_1.is)(versionRange, exports.VersionRangeStruct);
-}
-exports.isValidSemVerRange = isValidSemVerRange;
-/**
- * Asserts that a value is a valid concrete SemVer version.
- *
- * @param version - A potential SemVer concrete version.
- */
-function assertIsSemVerVersion(version) {
-    (0, assert_1.assertStruct)(version, exports.VersionStruct);
-}
-exports.assertIsSemVerVersion = assertIsSemVerVersion;
-/**
- * Asserts that a value is a valid SemVer range.
- *
- * @param range - A potential SemVer range.
- */
-function assertIsSemVerRange(range) {
-    (0, assert_1.assertStruct)(range, exports.VersionRangeStruct);
-}
-exports.assertIsSemVerRange = assertIsSemVerRange;
-/**
- * Checks whether a SemVer version is greater than another.
- *
- * @param version1 - The left-hand version.
- * @param version2 - The right-hand version.
- * @returns `version1 > version2`.
- */
-function gtVersion(version1, version2) {
-    return (0, semver_1.gt)(version1, version2);
-}
-exports.gtVersion = gtVersion;
-/**
- * Checks whether a SemVer version is greater than all possibilities in a range.
- *
- * @param version - A SemvVer version.
- * @param range - The range to check against.
- * @returns `version > range`.
- */
-function gtRange(version, range) {
-    return (0, semver_1.gtr)(version, range);
-}
-exports.gtRange = gtRange;
-/**
- * Returns whether a SemVer version satisfies a SemVer range.
- *
- * @param version - The SemVer version to check.
- * @param versionRange - The SemVer version range to check against.
- * @returns Whether the version satisfied the version range.
- */
-function satisfiesVersionRange(version, versionRange) {
-    return (0, semver_1.satisfies)(version, versionRange, {
-        includePrerelease: true,
-    });
-}
-exports.satisfiesVersionRange = satisfiesVersionRange;
-//# sourceMappingURL=versions.js.map

package/dist/versions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"versions.js","sourceRoot":"","sources":["../src/versions.ts"],"names":[],"mappings":";;;AAAA,mCAMgB;AAChB,6CAAyD;AAEzD,qCAAwC;AA+CxC;;GAEG;AACU,QAAA,aAAa,GAAG,IAAA,oBAAM,EACjC,IAAA,oBAAM,GAA4C,EAClD,SAAS,EACT,CAAC,KAAK,EAAE,EAAE;IACR,IAAI,IAAA,cAAkB,EAAC,KAAK,CAAC,KAAK,IAAI,EAAE;QACtC,OAAO,iCAAiC,KAAK,GAAG,CAAC;KAClD;IACD,OAAO,IAAI,CAAC;AACd,CAAC,CACF,CAAC;AAEW,QAAA,kBAAkB,GAAG,IAAA,oBAAM,EACtC,IAAA,oBAAM,GAA0C,EAChD,eAAe,EACf,CAAC,KAAK,EAAE,EAAE;IACR,IAAI,IAAA,mBAAgB,EAAC,KAAK,CAAC,KAAK,IAAI,EAAE;QACpC,OAAO,+BAA+B,KAAK,GAAG,CAAC;KAChD;IACD,OAAO,IAAI,CAAC;AACd,CAAC,CACF,CAAC;AAEF;;;;;GAKG;AACH,SAAgB,oBAAoB,CAClC,OAAgB;IAEhB,OAAO,IAAA,gBAAE,EAAC,OAAO,EAAE,qBAAa,CAAC,CAAC;AACpC,CAAC;AAJD,oDAIC;AAED;;;;;GAKG;AACH,SAAgB,kBAAkB,CAChC,YAAqB;IAErB,OAAO,IAAA,gBAAE,EAAC,YAAY,EAAE,0BAAkB,CAAC,CAAC;AAC9C,CAAC;AAJD,gDAIC;AAED;;;;GAIG;AACH,SAAgB,qBAAqB,CACnC,OAAgB;IAEhB,IAAA,qBAAY,EAAC,OAAO,EAAE,qBAAa,CAAC,CAAC;AACvC,CAAC;AAJD,sDAIC;AAED;;;;GAIG;AACH,SAAgB,mBAAmB,CACjC,KAAc;IAEd,IAAA,qBAAY,EAAC,KAAK,EAAE,0BAAkB,CAAC,CAAC;AAC1C,CAAC;AAJD,kDAIC;AAED;;;;;;GAMG;AACH,SAAgB,SAAS,CACvB,QAAuB,EACvB,QAAuB;IAEvB,OAAO,IAAA,WAAQ,EAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;AACtC,CAAC;AALD,8BAKC;AAED;;;;;;GAMG;AACH,SAAgB,OAAO,CAAC,OAAsB,EAAE,KAAkB;IAChE,OAAO,IAAA,YAAS,EAAC,OAAO,EAAE,KAAK,CAAC,CAAC;AACnC,CAAC;AAFD,0BAEC;AAED;;;;;;GAMG;AACH,SAAgB,qBAAqB,CACnC,OAAsB,EACtB,YAAyB;IAEzB,OAAO,IAAA,kBAAe,EAAC,OAAO,EAAE,YAAY,EAAE;QAC5C,iBAAiB,EAAE,IAAI;KACxB,CAAC,CAAC;AACL,CAAC;AAPD,sDAOC","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 { is, refine, string, Struct } from 'superstruct';\n\nimport { assertStruct } from './assert';\nimport { 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"]}