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

package/dist/transaction-types.d.ts

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

package/dist/transaction-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-types.d.ts","sourceRoot":"","sources":["../src/transaction-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAEpC,MAAM,MAAM,WAAW,GACnB,iBAAiB,GACjB,kBAAkB,GAClB,kBAAkB,CAAC;AAEvB,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,SAAS,CAAC;AAExD,MAAM,MAAM,SAAS,GAAG;IACtB;;;OAGG;IACH,CAAC,EAAE,KAAK,CAAC;IAET;;;;OAIG;IACH,CAAC,EAAE,KAAK,CAAC;IAET;;;OAGG;IACH,OAAO,EAAE,KAAK,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;;OAGG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,GAAG,GAAG,UAAU,CAAC;IAEvB;;;;OAIG;IACH,EAAE,EAAE,GAAG,GAAG,UAAU,CAAC;IAErB;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,QAAQ,EAAE,KAAK,CAAC;IAEhB;;OAEG;IACH,IAAI,CAAC,EAAE,KAAK,CAAC;CACd,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG;IAC/C;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,eAAe,GAAG;IAChD;;OAEG;IACH,QAAQ,EAAE,KAAK,GAAG,IAAI,CAAC;CACxB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,gBAAgB,GAAG;IAClD;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC;IAER;;OAEG;IACH,OAAO,EAAE,KAAK,CAAC;IAEf;;OAEG;IACH,UAAU,EACN;QAAE,OAAO,EAAE,GAAG,CAAC;QAAC,WAAW,EAAE,GAAG,EAAE,CAAA;KAAE,EAAE,GACtC;QAAE,OAAO,EAAE,UAAU,CAAC;QAAC,WAAW,EAAE,UAAU,EAAE,CAAA;KAAE,EAAE,CAAC;CAC1D,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,gBAAgB,GAAG;IAClD;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC;IAER;;OAEG;IACH,oBAAoB,EAAE,KAAK,CAAC;IAE5B;;OAEG;IACH,YAAY,EAAE,KAAK,CAAC;CACrB,CAAC"}

package/dist/transaction-types.js

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

package/dist/transaction-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-types.js","sourceRoot":"","sources":["../src/transaction-types.ts"],"names":[],"mappings":"","sourcesContent":["import type { Bytes } from './bytes.js';\nimport type { Hex } from './hex.js';\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/unitsConversion.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Converts a string, number, or bigint to a bigint.
+ *
+ * @param arg - The value to convert to bigint.
+ * @returns The bigint representation of the input.
+ * @throws Error if the input type cannot be converted to bigint.
+ */
+export declare function numericToBigInt(arg: string | number | bigint): bigint;
+export declare const unitMap: {
+    readonly noether: '0';
+    readonly wei: '1';
+    readonly kwei: '1000';
+    readonly Kwei: '1000';
+    readonly babbage: '1000';
+    readonly femtoether: '1000';
+    readonly mwei: '1000000';
+    readonly Mwei: '1000000';
+    readonly lovelace: '1000000';
+    readonly picoether: '1000000';
+    readonly gwei: '1000000000';
+    readonly Gwei: '1000000000';
+    readonly shannon: '1000000000';
+    readonly nanoether: '1000000000';
+    readonly nano: '1000000000';
+    readonly szabo: '1000000000000';
+    readonly microether: '1000000000000';
+    readonly micro: '1000000000000';
+    readonly finney: '1000000000000000';
+    readonly milliether: '1000000000000000';
+    readonly milli: '1000000000000000';
+    readonly ether: '1000000000000000000';
+    readonly kether: '1000000000000000000000';
+    readonly grand: '1000000000000000000000';
+    readonly mether: '1000000000000000000000000';
+    readonly gether: '1000000000000000000000000000';
+    readonly tether: '1000000000000000000000000000000';
+};
+type EthereumUnit = keyof typeof unitMap;
+/**
+ * Returns value of unit in Wei.
+ *
+ * @param unitInput - The unit to convert to, default ether.
+ * @returns Value of the unit (in Wei).
+ * @throws Error if the unit is not correct.
+ */
+export declare function getValueOfUnit(unitInput?: EthereumUnit): bigint;
+/**
+ * Converts a number to a string.
+ *
+ * @param arg - The number to convert to a string.
+ * @returns The string representation of the number.
+ * @throws Error if the number is invalid.
+ */
+export declare function numberToString(arg: string | number | bigint): string;
+/**
+ * Converts a number from Wei to a string.
+ *
+ * @param weiInput - The number to convert from Wei.
+ * @param unit - The unit to convert to, default ether.
+ * @param optionsInput - The options to use for the conversion.
+ * @param optionsInput.pad - Whether to pad the fractional part with zeros.
+ * @param optionsInput.commify - Whether to add commas to separate thousands.
+ * @returns The string representation of the number.
+ * @throws Error if the number is invalid.
+ */
+export declare function fromWei(weiInput: string | number | bigint, unit: EthereumUnit, optionsInput?: {
+    pad?: boolean;
+    commify?: boolean;
+}): string;
+/**
+ * Converts a number to Wei.
+ *
+ * @param etherInput - The number to convert to Wei.
+ * @param unit - The unit to convert to, default ether.
+ * @returns The number in Wei.
+ * @throws Error if the number is invalid.
+ */
+export declare function toWei(etherInput: string | number | bigint, unit: EthereumUnit): bigint;
+export {};
+//# sourceMappingURL=unitsConversion.d.ts.map

package/dist/unitsConversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unitsConversion.d.ts","sourceRoot":"","sources":["../src/unitsConversion.ts"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAYrE;AAGD,eAAO,MAAM,OAAO;aAClB,OAAO,EAAE,GAAG;aACZ,GAAG,EAAE,GAAG;aACR,IAAI,EAAE,MAAM;aACZ,IAAI,EAAE,MAAM;aACZ,OAAO,EAAE,MAAM;aACf,UAAU,EAAE,MAAM;aAClB,IAAI,EAAE,SAAS;aACf,IAAI,EAAE,SAAS;aACf,QAAQ,EAAE,SAAS;aACnB,SAAS,EAAE,SAAS;aACpB,IAAI,EAAE,YAAY;aAClB,IAAI,EAAE,YAAY;aAClB,OAAO,EAAE,YAAY;aACrB,SAAS,EAAE,YAAY;aACvB,IAAI,EAAE,YAAY;aAClB,KAAK,EAAE,eAAe;aACtB,UAAU,EAAE,eAAe;aAC3B,KAAK,EAAE,eAAe;aACtB,MAAM,EAAE,kBAAkB;aAC1B,UAAU,EAAE,kBAAkB;aAC9B,KAAK,EAAE,kBAAkB;aACzB,KAAK,EAAE,qBAAqB;aAC5B,MAAM,EAAE,wBAAwB;aAChC,KAAK,EAAE,wBAAwB;aAC/B,MAAM,EAAE,2BAA2B;aACnC,MAAM,EAAE,8BAA8B;aACtC,MAAM,EAAE,iCAAiC;CACjC,CAAC;AAeX,KAAK,YAAY,GAAG,MAAM,OAAO,OAAO,CAAC;AAEzC;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,SAAS,GAAE,YAAsB,GAAG,MAAM,CAexE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,UAoB3D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CACrB,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAClC,IAAI,EAAE,YAAY,EAClB,YAAY,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,UAmDpD;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,CACnB,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EACpC,IAAI,EAAE,YAAY,GACjB,MAAM,CA8ER"}

package/dist/unitsConversion.js

@@ -0,0 +1,209 @@
+/* eslint-disable operator-assignment */
+/*
+Primary Attribution
+Richard Moore <ricmoo@me.com>
+https://github.com/ethers-io
+
+Note, Richard is a god of ether gods. Follow and respect him, and use Ethers.io!
+*/
+const zero = BigInt(0);
+const negative1 = BigInt(-1);
+/**
+ * Converts a string, number, or bigint to a bigint.
+ *
+ * @param arg - The value to convert to bigint.
+ * @returns The bigint representation of the input.
+ * @throws Error if the input type cannot be converted to bigint.
+ */
+export function numericToBigInt(arg) {
+    if (typeof arg === 'string') {
+        return BigInt(arg);
+    }
+    if (typeof arg === 'number') {
+        return BigInt(arg);
+    }
+    if (typeof arg === 'bigint') {
+        return arg;
+    }
+    throw new Error(`Cannot convert ${typeof arg} to BigInt`);
+}
+// complete ethereum unit map
+export const unitMap = {
+    noether: '0',
+    wei: '1',
+    kwei: '1000',
+    Kwei: '1000',
+    babbage: '1000',
+    femtoether: '1000',
+    mwei: '1000000',
+    Mwei: '1000000',
+    lovelace: '1000000',
+    picoether: '1000000',
+    gwei: '1000000000',
+    Gwei: '1000000000',
+    shannon: '1000000000',
+    nanoether: '1000000000',
+    nano: '1000000000',
+    szabo: '1000000000000',
+    microether: '1000000000000',
+    micro: '1000000000000',
+    finney: '1000000000000000',
+    milliether: '1000000000000000',
+    milli: '1000000000000000',
+    ether: '1000000000000000000',
+    kether: '1000000000000000000000',
+    grand: '1000000000000000000000',
+    mether: '1000000000000000000000000',
+    gether: '1000000000000000000000000000',
+    tether: '1000000000000000000000000000000',
+};
+// Pre-computed unit values as BigInt for performance
+const unitMapBigInt = Object.fromEntries(Object.entries(unitMap).map(([key, value]) => [key, BigInt(value)]));
+const unitLengths = Object.fromEntries(Object.entries(unitMap).map(([key, value]) => [key, value.length - 1 || 1]));
+const NUMBER_REGEX = /^-?[0-9.]+$/u;
+const FRACTION_REGEX = /^([0-9]*[1-9]|0)(0*)/u;
+const COMMIFY_REGEX = /\B(?=(\d{3})+(?!\d))/gu;
+/**
+ * Returns value of unit in Wei.
+ *
+ * @param unitInput - The unit to convert to, default ether.
+ * @returns Value of the unit (in Wei).
+ * @throws Error if the unit is not correct.
+ */
+export function getValueOfUnit(unitInput = 'ether') {
+    const unit = unitInput.toLowerCase();
+    const unitValue = unitMapBigInt[unit];
+    if (unitValue === undefined) {
+        throw new Error(`The unit provided ${unitInput} doesn't exist, please use the one of the following units ${JSON.stringify(unitMap, null, 2)}`);
+    }
+    return unitValue;
+}
+/**
+ * Converts a number to a string.
+ *
+ * @param arg - The number to convert to a string.
+ * @returns The string representation of the number.
+ * @throws Error if the number is invalid.
+ */
+export function numberToString(arg) {
+    if (typeof arg === 'string') {
+        if (!NUMBER_REGEX.test(arg)) {
+            throw new Error(`while converting number to string, invalid number value '${arg}', should be a number matching (^-?[0-9.]+).`);
+        }
+        return arg;
+    }
+    if (typeof arg === 'number') {
+        return String(arg);
+    }
+    if (typeof arg === 'bigint') {
+        return arg.toString();
+    }
+    throw new Error(`while converting number to string, invalid number value '${String(arg)}' type ${typeof arg}.`);
+}
+/**
+ * Converts a number from Wei to a string.
+ *
+ * @param weiInput - The number to convert from Wei.
+ * @param unit - The unit to convert to, default ether.
+ * @param optionsInput - The options to use for the conversion.
+ * @param optionsInput.pad - Whether to pad the fractional part with zeros.
+ * @param optionsInput.commify - Whether to add commas to separate thousands.
+ * @returns The string representation of the number.
+ * @throws Error if the number is invalid.
+ */
+export function fromWei(weiInput, unit, optionsInput) {
+    let wei = numericToBigInt(weiInput);
+    const negative = wei < zero;
+    const unitLower = unit.toLowerCase();
+    const base = unitMapBigInt[unitLower];
+    const baseLength = unitLengths[unitLower];
+    const options = optionsInput ?? {};
+    if (base === undefined) {
+        throw new Error(`The unit provided ${unit} doesn't exist, please use the one of the following units ${JSON.stringify(unitMap, null, 2)}`);
+    }
+    // Handle special case of noether (base = 0)
+    if (base === zero) {
+        return negative ? '-0' : '0';
+    }
+    if (negative) {
+        wei = wei * negative1;
+    }
+    let fraction = (wei % base).toString();
+    fraction = fraction.padStart(baseLength, '0');
+    if (!options.pad) {
+        const fractionMatch = fraction.match(FRACTION_REGEX);
+        // istanbul ignore next: defensive fallback that's never reachable but necessary to satisfy TS
+        fraction = fractionMatch?.[1] ?? '0';
+    }
+    let whole = (wei / base).toString();
+    if (options.commify) {
+        whole = whole.replace(COMMIFY_REGEX, ',');
+    }
+    let value = `${whole}${fraction === '0' ? '' : `.${fraction}`}`;
+    if (negative) {
+        value = `-${value}`;
+    }
+    return value;
+}
+/**
+ * Converts a number to Wei.
+ *
+ * @param etherInput - The number to convert to Wei.
+ * @param unit - The unit to convert to, default ether.
+ * @returns The number in Wei.
+ * @throws Error if the number is invalid.
+ */
+export function toWei(etherInput, unit) {
+    const unitLower = unit.toLowerCase();
+    const base = unitMapBigInt[unitLower];
+    const baseLength = unitLengths[unitLower];
+    if (base === undefined) {
+        throw new Error(`The unit provided ${unit} doesn't exist, please use the one of the following units ${JSON.stringify(unitMap, null, 2)}`);
+    }
+    // Handle special case of noether (base = 0)
+    if (base === zero) {
+        return zero;
+    }
+    // Fast path for bigint inputs when unit is wei (no conversion needed)
+    if (typeof etherInput === 'bigint' && unitLower === 'wei') {
+        return etherInput;
+    }
+    // Fast path for bigint inputs with whole units (no fractional part)
+    if (typeof etherInput === 'bigint') {
+        return etherInput * base;
+    }
+    let ether = numberToString(etherInput);
+    // Is it negative?
+    const negative = ether.startsWith('-');
+    if (negative) {
+        ether = ether.substring(1);
+    }
+    if (ether === '.') {
+        throw new Error(`While converting number ${etherInput} to wei, invalid value`);
+    }
+    // Split it into a whole and fractional part
+    const comps = ether.split('.');
+    if (comps.length > 2) {
+        throw new Error(`While converting number ${etherInput} to wei,  too many decimal points`);
+    }
+    let whole = comps[0];
+    let fraction = comps[1];
+    if (!whole) {
+        whole = '0';
+    }
+    if (!fraction) {
+        fraction = '0';
+    }
+    if (fraction.length > baseLength) {
+        throw new Error(`While converting number ${etherInput} to wei, too many decimal places`);
+    }
+    fraction = fraction.padEnd(baseLength, '0');
+    const wholeBigInt = BigInt(whole);
+    const fractionBigInt = BigInt(fraction);
+    let wei = wholeBigInt * base + fractionBigInt;
+    if (negative) {
+        wei = wei * negative1;
+    }
+    return wei;
+}
+//# sourceMappingURL=unitsConversion.js.map

package/dist/unitsConversion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unitsConversion.js","sourceRoot":"","sources":["../src/unitsConversion.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable operator-assignment */\n/*\nPrimary Attribution\nRichard Moore <ricmoo@me.com>\nhttps://github.com/ethers-io\n\nNote, Richard is a god of ether gods. Follow and respect him, and use Ethers.io!\n*/\n\nconst zero = BigInt(0);\nconst negative1 = BigInt(-1);\n\n/**\n * Converts a string, number, or bigint to a bigint.\n *\n * @param arg - The value to convert to bigint.\n * @returns The bigint representation of the input.\n * @throws Error if the input type cannot be converted to bigint.\n */\nexport function numericToBigInt(arg: string | number | bigint): bigint {\n  if (typeof arg === 'string') {\n    return BigInt(arg);\n  }\n  if (typeof arg === 'number') {\n    return BigInt(arg);\n  }\n  if (typeof arg === 'bigint') {\n    return arg;\n  }\n\n  throw new Error(`Cannot convert ${typeof arg} to BigInt`);\n}\n\n// complete ethereum unit map\nexport const unitMap = {\n  noether: '0',\n  wei: '1',\n  kwei: '1000',\n  Kwei: '1000',\n  babbage: '1000',\n  femtoether: '1000',\n  mwei: '1000000',\n  Mwei: '1000000',\n  lovelace: '1000000',\n  picoether: '1000000',\n  gwei: '1000000000',\n  Gwei: '1000000000',\n  shannon: '1000000000',\n  nanoether: '1000000000',\n  nano: '1000000000',\n  szabo: '1000000000000',\n  microether: '1000000000000',\n  micro: '1000000000000',\n  finney: '1000000000000000',\n  milliether: '1000000000000000',\n  milli: '1000000000000000',\n  ether: '1000000000000000000',\n  kether: '1000000000000000000000',\n  grand: '1000000000000000000000',\n  mether: '1000000000000000000000000',\n  gether: '1000000000000000000000000000',\n  tether: '1000000000000000000000000000000',\n} as const;\n\n// Pre-computed unit values as BigInt for performance\nconst unitMapBigInt = Object.fromEntries(\n  Object.entries(unitMap).map(([key, value]) => [key, BigInt(value)]),\n) as Record<EthereumUnit, bigint>;\n\nconst unitLengths = Object.fromEntries(\n  Object.entries(unitMap).map(([key, value]) => [key, value.length - 1 || 1]),\n) as Record<EthereumUnit, number>;\n\nconst NUMBER_REGEX = /^-?[0-9.]+$/u;\nconst FRACTION_REGEX = /^([0-9]*[1-9]|0)(0*)/u;\nconst COMMIFY_REGEX = /\\B(?=(\\d{3})+(?!\\d))/gu;\n\ntype EthereumUnit = keyof typeof unitMap;\n\n/**\n * Returns value of unit in Wei.\n *\n * @param unitInput - The unit to convert to, default ether.\n * @returns Value of the unit (in Wei).\n * @throws Error if the unit is not correct.\n */\nexport function getValueOfUnit(unitInput: EthereumUnit = 'ether'): bigint {\n  const unit = unitInput.toLowerCase() as EthereumUnit;\n  const unitValue = unitMapBigInt[unit];\n\n  if (unitValue === undefined) {\n    throw new Error(\n      `The unit provided ${unitInput} doesn't exist, please use the one of the following units ${JSON.stringify(\n        unitMap,\n        null,\n        2,\n      )}`,\n    );\n  }\n\n  return unitValue;\n}\n\n/**\n * Converts a number to a string.\n *\n * @param arg - The number to convert to a string.\n * @returns The string representation of the number.\n * @throws Error if the number is invalid.\n */\nexport function numberToString(arg: string | number | bigint) {\n  if (typeof arg === 'string') {\n    if (!NUMBER_REGEX.test(arg)) {\n      throw new Error(\n        `while converting number to string, invalid number value '${arg}', should be a number matching (^-?[0-9.]+).`,\n      );\n    }\n    return arg;\n  }\n  if (typeof arg === 'number') {\n    return String(arg);\n  }\n  if (typeof arg === 'bigint') {\n    return arg.toString();\n  }\n  throw new Error(\n    `while converting number to string, invalid number value '${String(\n      arg,\n    )}' type ${typeof arg}.`,\n  );\n}\n\n/**\n * Converts a number from Wei to a string.\n *\n * @param weiInput - The number to convert from Wei.\n * @param unit - The unit to convert to, default ether.\n * @param optionsInput - The options to use for the conversion.\n * @param optionsInput.pad - Whether to pad the fractional part with zeros.\n * @param optionsInput.commify - Whether to add commas to separate thousands.\n * @returns The string representation of the number.\n * @throws Error if the number is invalid.\n */\nexport function fromWei(\n  weiInput: string | number | bigint,\n  unit: EthereumUnit,\n  optionsInput?: { pad?: boolean; commify?: boolean },\n) {\n  let wei = numericToBigInt(weiInput);\n  const negative = wei < zero;\n  const unitLower = unit.toLowerCase() as EthereumUnit;\n  const base = unitMapBigInt[unitLower];\n  const baseLength = unitLengths[unitLower];\n  const options = optionsInput ?? {};\n\n  if (base === undefined) {\n    throw new Error(\n      `The unit provided ${unit} doesn't exist, please use the one of the following units ${JSON.stringify(\n        unitMap,\n        null,\n        2,\n      )}`,\n    );\n  }\n\n  // Handle special case of noether (base = 0)\n  if (base === zero) {\n    return negative ? '-0' : '0';\n  }\n\n  if (negative) {\n    wei = wei * negative1;\n  }\n\n  let fraction = (wei % base).toString();\n\n  fraction = fraction.padStart(baseLength, '0');\n\n  if (!options.pad) {\n    const fractionMatch = fraction.match(FRACTION_REGEX);\n    // istanbul ignore next: defensive fallback that's never reachable but necessary to satisfy TS\n    fraction = fractionMatch?.[1] ?? '0';\n  }\n\n  let whole = (wei / base).toString();\n\n  if (options.commify) {\n    whole = whole.replace(COMMIFY_REGEX, ',');\n  }\n\n  let value = `${whole}${fraction === '0' ? '' : `.${fraction}`}`;\n\n  if (negative) {\n    value = `-${value}`;\n  }\n\n  return value;\n}\n\n/**\n * Converts a number to Wei.\n *\n * @param etherInput - The number to convert to Wei.\n * @param unit - The unit to convert to, default ether.\n * @returns The number in Wei.\n * @throws Error if the number is invalid.\n */\nexport function toWei(\n  etherInput: string | number | bigint,\n  unit: EthereumUnit,\n): bigint {\n  const unitLower = unit.toLowerCase() as EthereumUnit;\n  const base = unitMapBigInt[unitLower];\n  const baseLength = unitLengths[unitLower];\n\n  if (base === undefined) {\n    throw new Error(\n      `The unit provided ${unit} doesn't exist, please use the one of the following units ${JSON.stringify(\n        unitMap,\n        null,\n        2,\n      )}`,\n    );\n  }\n\n  // Handle special case of noether (base = 0)\n  if (base === zero) {\n    return zero;\n  }\n\n  // Fast path for bigint inputs when unit is wei (no conversion needed)\n  if (typeof etherInput === 'bigint' && unitLower === 'wei') {\n    return etherInput;\n  }\n\n  // Fast path for bigint inputs with whole units (no fractional part)\n  if (typeof etherInput === 'bigint') {\n    return etherInput * base;\n  }\n\n  let ether = numberToString(etherInput);\n\n  // Is it negative?\n  const negative = ether.startsWith('-');\n  if (negative) {\n    ether = ether.substring(1);\n  }\n\n  if (ether === '.') {\n    throw new Error(\n      `While converting number ${etherInput} to wei, invalid value`,\n    );\n  }\n\n  // Split it into a whole and fractional part\n  const comps = ether.split('.');\n  if (comps.length > 2) {\n    throw new Error(\n      `While converting number ${etherInput} to wei,  too many decimal points`,\n    );\n  }\n\n  let whole = comps[0];\n  let fraction = comps[1];\n\n  if (!whole) {\n    whole = '0';\n  }\n  if (!fraction) {\n    fraction = '0';\n  }\n  if (fraction.length > baseLength) {\n    throw new Error(\n      `While converting number ${etherInput} to wei, too many decimal places`,\n    );\n  }\n\n  fraction = fraction.padEnd(baseLength, '0');\n\n  const wholeBigInt = BigInt(whole);\n  const fractionBigInt = BigInt(fraction);\n  let wei = wholeBigInt * base + fractionBigInt;\n\n  if (negative) {\n    wei = wei * negative1;\n  }\n\n  return wei;\n}\n"]}

package/dist/versions.d.ts

@@ -0,0 +1,101 @@
+import type { Struct } from '@metamask/superstruct';
+import type { Opaque } from './opaque.js';
+/**
+ * {@link https://codemix.com/opaque-types-in-javascript/ Opaque} type for SemVer ranges.
+ *
+ * @example Use {@link assertIsSemVerRange} and {@link isValidSemVerRange} to cast to proper type.
+ * ```typescript
+ * const unsafeRange: string = dataFromUser();
+ * assertIsSemVerRange(unsafeRange);
+ * unsafeRange
+ * // ^? SemVerRange
+ * ```
+ * @example If you know what you're doing and want to side-step type safety, casting from a string works correctly.
+ * ```typescript
+ * const unsafeRange: string = dataFromUser();
+ * unsafeRange as SemVerRange;
+ * // ^? SemVerRange
+ * ```
+ * @see {@link assertIsSemVerRange}
+ * @see {@link isValidSemVerRange}
+ */
+export type SemVerRange = Opaque<string, typeof semVerRange>;
+declare const semVerRange: unique symbol;
+/**
+ * {@link https://codemix.com/opaque-types-in-javascript/ Opaque} type for singular SemVer version.
+ *
+ * @example Use {@link assertIsSemVerVersion} and {@link isValidSemVerVersion} to cast to proper type.
+ * ```typescript
+ * const unsafeVersion: string = dataFromUser();
+ * assertIsSemVerVersion(unsafeRange);
+ * unsafeVersion
+ * // ^? SemVerVersion
+ * ```
+ * @example If you know what you're doing and want to side-step type safety, casting from a string works correctly.
+ * ```typescript
+ * const unsafeVersion: string = dataFromUser();
+ * unsafeRange as SemVerVersion;
+ * // ^? SemVerVersion
+ * ```
+ * @see {@link assertIsSemVerVersion}
+ * @see {@link isValidSemVerVersion}
+ */
+export type SemVerVersion = Opaque<string, typeof semVerVersion>;
+declare const semVerVersion: unique symbol;
+/**
+ * A struct for validating a version string.
+ */
+export declare const VersionStruct: Struct<SemVerVersion, null>;
+export declare const VersionRangeStruct: Struct<SemVerRange, null>;
+/**
+ * Checks whether a SemVer version is valid.
+ *
+ * @param version - A potential version.
+ * @returns `true` if the version is valid, and `false` otherwise.
+ */
+export declare function isValidSemVerVersion(version: unknown): version is SemVerVersion;
+/**
+ * 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.
+ */
+export declare function isValidSemVerRange(versionRange: unknown): versionRange is SemVerRange;
+/**
+ * Asserts that a value is a valid concrete SemVer version.
+ *
+ * @param version - A potential SemVer concrete version.
+ */
+export declare function assertIsSemVerVersion(version: unknown): asserts version is SemVerVersion;
+/**
+ * Asserts that a value is a valid SemVer range.
+ *
+ * @param range - A potential SemVer range.
+ */
+export declare function assertIsSemVerRange(range: unknown): asserts range is SemVerRange;
+/**
+ * Checks whether a SemVer version is greater than another.
+ *
+ * @param version1 - The left-hand version.
+ * @param version2 - The right-hand version.
+ * @returns `version1 > version2`.
+ */
+export declare function gtVersion(version1: SemVerVersion, version2: SemVerVersion): boolean;
+/**
+ * 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`.
+ */
+export declare function gtRange(version: SemVerVersion, range: SemVerRange): boolean;
+/**
+ * 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.
+ */
+export declare function satisfiesVersionRange(version: SemVerVersion, versionRange: SemVerRange): boolean;
+export {};
+//# sourceMappingURL=versions.d.ts.map

package/dist/versions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versions.d.ts","sourceRoot":"","sources":["../src/versions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAWpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,WAAW,CAAC,CAAC;AAE7D,OAAO,CAAC,MAAM,WAAW,EAAE,OAAO,MAAM,CAAC;AAEzC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,aAAa,CAAC,CAAC;AAEjE,OAAO,CAAC,MAAM,aAAa,EAAE,OAAO,MAAM,CAAC;AAE3C;;GAEG;AACH,eAAO,MAAM,aAAa,6BASzB,CAAC;AAEF,eAAO,MAAM,kBAAkB,2BAS9B,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,GACf,OAAO,IAAI,aAAa,CAE1B;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,OAAO,GACpB,YAAY,IAAI,WAAW,CAE7B;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,OAAO,IAAI,aAAa,CAElC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,KAAK,IAAI,WAAW,CAE9B;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,aAAa,EACvB,QAAQ,EAAE,aAAa,GACtB,OAAO,CAET;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAE3E;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,aAAa,EACtB,YAAY,EAAE,WAAW,GACxB,OAAO,CAIT"}

package/dist/versions.js

@@ -0,0 +1,85 @@
+import { is, refine, string } from '@metamask/superstruct';
+import { gt as gtSemver, gtr as gtrSemver, satisfies as satisfiesSemver, valid as validSemVerVersion, validRange as validSemVerRange, } from 'semver';
+import { assertStruct } from './assert.js';
+/**
+ * A struct for validating a version string.
+ */
+export const VersionStruct = refine(string(), 'Version', (value) => {
+    if (validSemVerVersion(value) === null) {
+        return `Expected SemVer version, got "${value}"`;
+    }
+    return true;
+});
+export const VersionRangeStruct = refine(string(), 'Version range', (value) => {
+    if (validSemVerRange(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.
+ */
+export function isValidSemVerVersion(version) {
+    return is(version, VersionStruct);
+}
+/**
+ * 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.
+ */
+export function isValidSemVerRange(versionRange) {
+    return is(versionRange, VersionRangeStruct);
+}
+/**
+ * Asserts that a value is a valid concrete SemVer version.
+ *
+ * @param version - A potential SemVer concrete version.
+ */
+export function assertIsSemVerVersion(version) {
+    assertStruct(version, VersionStruct);
+}
+/**
+ * Asserts that a value is a valid SemVer range.
+ *
+ * @param range - A potential SemVer range.
+ */
+export function assertIsSemVerRange(range) {
+    assertStruct(range, VersionRangeStruct);
+}
+/**
+ * Checks whether a SemVer version is greater than another.
+ *
+ * @param version1 - The left-hand version.
+ * @param version2 - The right-hand version.
+ * @returns `version1 > version2`.
+ */
+export function gtVersion(version1, version2) {
+    return gtSemver(version1, version2);
+}
+/**
+ * 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`.
+ */
+export function gtRange(version, range) {
+    return gtrSemver(version, range);
+}
+/**
+ * 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.
+ */
+export function satisfiesVersionRange(version, versionRange) {
+    return satisfiesSemver(version, versionRange, {
+        includePrerelease: true,
+    });
+}
+//# sourceMappingURL=versions.js.map

package/dist/versions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"versions.js","sourceRoot":"","sources":["../src/versions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EACL,EAAE,IAAI,QAAQ,EACd,GAAG,IAAI,SAAS,EAChB,SAAS,IAAI,eAAe,EAC5B,KAAK,IAAI,kBAAkB,EAC3B,UAAU,IAAI,gBAAgB,GAC/B,MAAM,QAAQ,CAAC;AAEhB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAiD3C;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CACjC,MAAM,EAA4C,EAClD,SAAS,EACT,CAAC,KAAK,EAAE,EAAE;IACR,IAAI,kBAAkB,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,CAAC;QACvC,OAAO,iCAAiC,KAAK,GAAG,CAAC;IACnD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC,CACF,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CACtC,MAAM,EAA0C,EAChD,eAAe,EACf,CAAC,KAAK,EAAE,EAAE;IACR,IAAI,gBAAgB,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,CAAC;QACrC,OAAO,+BAA+B,KAAK,GAAG,CAAC;IACjD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC,CACF,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAClC,OAAgB;IAEhB,OAAO,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;AACpC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAChC,YAAqB;IAErB,OAAO,EAAE,CAAC,YAAY,EAAE,kBAAkB,CAAC,CAAC;AAC9C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CACnC,OAAgB;IAEhB,YAAY,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;AACvC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAc;IAEd,YAAY,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CACvB,QAAuB,EACvB,QAAuB;IAEvB,OAAO,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,OAAO,CAAC,OAAsB,EAAE,KAAkB;IAChE,OAAO,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CACnC,OAAsB,EACtB,YAAyB;IAEzB,OAAO,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE;QAC5C,iBAAiB,EAAE,IAAI;KACxB,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { Struct } from '@metamask/superstruct';\nimport { is, refine, string } from '@metamask/superstruct';\nimport {\n  gt as gtSemver,\n  gtr as gtrSemver,\n  satisfies as satisfiesSemver,\n  valid as validSemVerVersion,\n  validRange as validSemVerRange,\n} from 'semver';\n\nimport { assertStruct } from './assert.js';\nimport type { Opaque } from './opaque.js';\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>;\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- Branding symbol for the opaque type; used only via `typeof`.\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>;\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- Branding symbol for the opaque type; used only via `typeof`.\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"]}