@metamask/keyring-utils - npm Package Compare versions

Comparing version 3.2.0 to 3.3.0

LICENSE

+MIT License
+
+Copyright (c) 2026 MetaMask
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

CHANGELOG.md

@@ -10,2 +10,13 @@ # Changelog
 
+## [3.3.0]
+
+### Added
+
+- Add `BaseKeyring` type ([#543](https://github.com/MetaMask/accounts/pull/543))
+  - This is the minimum interface that is used by the `KeyringController` to handle keyrings lifecycle.
+
+### Changed
+
+- Bump `@metamask/utils` from `^11.1.0` to `^11.11.0` ([#489](https://github.com/MetaMask/accounts/pull/489)), ([#483](https://github.com/MetaMask/accounts/pull/483))
+
 ## [3.2.0]
@@ -119,3 +130,4 @@
 
-[Unreleased]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-utils@3.2.0...HEAD
+[Unreleased]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-utils@3.3.0...HEAD
+[3.3.0]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-utils@3.2.0...@metamask/keyring-utils@3.3.0
 [3.2.0]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-utils@3.1.0...@metamask/keyring-utils@3.2.0
@@ -122,0 +134,0 @@ [3.1.0]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-utils@3.0.0...@metamask/keyring-utils@3.1.0

dist/btc/address.cjs

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBtcMainnetAddress = isBtcMainnetAddress;
-exports.isBtcTestnetAddress = isBtcTestnetAddress;
+exports.isBtcTestnetAddress = exports.isBtcMainnetAddress = void 0;
 const bitcoin_address_validation_1 = require("bitcoin-address-validation");
@@ -15,2 +14,3 @@ /**
 }
+exports.isBtcMainnetAddress = isBtcMainnetAddress;
 /**
@@ -25,2 +25,3 @@ * Returns whether an address is on the Bitcoin testnet.
 }
+exports.isBtcTestnetAddress = isBtcTestnetAddress;
 //# sourceMappingURL=address.cjs.map

dist/btc/address.cjs.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"address.cjs","sourceRoot":"","sources":["../../src/btc/address.ts"],"names":[],"mappings":";;AAQA,kDAEC;AAQD,kDAEC;AApBD,2EAA+D;AAE/D;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,OAAe;IACjD,OAAO,IAAA,qCAAQ,EAAC,OAAO,EAAE,oCAAO,CAAC,OAAO,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,OAAe;IACjD,OAAO,IAAA,qCAAQ,EAAC,OAAO,EAAE,oCAAO,CAAC,OAAO,CAAC,CAAC;AAC5C,CAAC","sourcesContent":["import { validate, Network } from 'bitcoin-address-validation';\n\n/**\n * Returns whether an address is on the Bitcoin mainnet.\n *\n * @param address - The address to check.\n * @returns `true` if the address is on the Bitcoin mainnet, `false` otherwise.\n */\nexport function isBtcMainnetAddress(address: string): boolean {\n  return validate(address, Network.mainnet);\n}\n\n/**\n * Returns whether an address is on the Bitcoin testnet.\n *\n * @param address - The address to check.\n * @returns `true` if the address is on the Bitcoin testnet, `false` otherwise.\n */\nexport function isBtcTestnetAddress(address: string): boolean {\n  return validate(address, Network.testnet);\n}\n"]}
+{"version":3,"file":"address.cjs","sourceRoot":"","sources":["../../src/btc/address.ts"],"names":[],"mappings":";;;AAAA,2EAA+D;AAE/D;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,OAAe;IACjD,OAAO,IAAA,qCAAQ,EAAC,OAAO,EAAE,oCAAO,CAAC,OAAO,CAAC,CAAC;AAC5C,CAAC;AAFD,kDAEC;AAED;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,OAAe;IACjD,OAAO,IAAA,qCAAQ,EAAC,OAAO,EAAE,oCAAO,CAAC,OAAO,CAAC,CAAC;AAC5C,CAAC;AAFD,kDAEC","sourcesContent":["import { validate, Network } from 'bitcoin-address-validation';\n\n/**\n * Returns whether an address is on the Bitcoin mainnet.\n *\n * @param address - The address to check.\n * @returns `true` if the address is on the Bitcoin mainnet, `false` otherwise.\n */\nexport function isBtcMainnetAddress(address: string): boolean {\n  return validate(address, Network.mainnet);\n}\n\n/**\n * Returns whether an address is on the Bitcoin testnet.\n *\n * @param address - The address to check.\n * @returns `true` if the address is on the Bitcoin testnet, `false` otherwise.\n */\nexport function isBtcTestnetAddress(address: string): boolean {\n  return validate(address, Network.testnet);\n}\n"]}

dist/keyring.cjs.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"keyring.cjs","sourceRoot":"","sources":["../src/keyring.ts"],"names":[],"mappings":"","sourcesContent":["import type { TypedTransaction, TypedTxData } from '@ethereumjs/tx';\nimport type { Eip1024EncryptedData, Hex, Json } from '@metamask/utils';\n\n/**\n * A Keyring class.\n *\n * This type is used to validate the constructor signature and the `type`\n * static property on Keyring classes. See the {@link Keyring} type for more\n * information.\n */\nexport type KeyringClass = {\n  /**\n   * The Keyring constructor. Takes a single parameter, an \"options\" object.\n   * See the documentation for the specific keyring for more information about\n   * what these options are.\n   *\n   * @param options - The constructor options. Differs between keyring\n   * implementations.\n   */\n  new (options?: Record<string, unknown>): Keyring;\n\n  /**\n   * The name of this type of keyring. This must uniquely identify the\n   * keyring type.\n   */\n  type: string;\n};\n\n/**\n * A keyring is something that can sign messages. Keyrings are used to add new\n * signing strategies; each strategy is a new keyring.\n *\n * Each keyring manages a collection of key pairs, which we call \"accounts\".\n * Each account is referred to by its \"address\", which is a unique identifier\n * derived from the public key. The address is always a \"0x\"-prefixed\n * hexidecimal string.\n *\n * The keyring might store the private key for each account as well, but it's\n * not guaranteed. Some keyrings delegate signing, so they don't need the\n * private key directly. The keyring (and in particular the keyring state)\n * should be treated with care though, just in case it does contain sensitive\n * material such as a private key.\n */\nexport type Keyring = {\n  /**\n   * The name of this type of keyring. This must match the `type` property of\n   * the keyring class.\n   */\n  type: string;\n\n  /**\n   * Get the addresses for all accounts in this keyring.\n   *\n   * @returns A list of the account addresses for this keyring\n   */\n  getAccounts(): Promise<Hex[]>;\n\n  /**\n   * Add an account to the keyring.\n   *\n   * @param number - The number of accounts to add. Usually defaults to 1.\n   * @returns A list of the newly added account addresses.\n   */\n  addAccounts(number: number): Promise<Hex[]>;\n\n  /**\n   * Serialize the keyring state as a JSON-serializable object.\n   *\n   * @returns A JSON-serializable representation of the keyring state.\n   */\n  serialize(): Promise<Json>;\n\n  /**\n   * Deserialize the given keyring state, overwriting any existing state with\n   * the serialized state provided.\n   *\n   * @param state - A JSON-serializable representation of the keyring state.\n   */\n  deserialize(state: Json): Promise<void>;\n\n  /**\n   * Method to include asynchronous configuration.\n   */\n  init?(): Promise<void>;\n\n  /**\n   * Remove an account from the keyring.\n   *\n   * @param address - The address of the account to remove.\n   */\n  removeAccount?(address: Hex): void;\n\n  /**\n   * Export the private key for one of the keyring accounts.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter is used to allow exporting a\n   * private key that is derived from the given account, rather than exporting\n   * that account's private key directly.\n   *\n   * @param address - The address of the account to export.\n   * @param options - Export options; differs between keyrings.\n   * @returns The non-prefixed, hex-encoded private key that was requested.\n   */\n  exportAccount?(\n    address: Hex,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Get the \"app key\" address for the given account and origin. An app key is\n   * an application-specific key pair. See {@link https://eips.ethereum.org/EIPS/eip-1775|EIP-1775}\n   * for more information. The {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Origin|origin}\n   * is used as the unique identifier for the application, and it's used as\n   * part of the key derivation process.\n   *\n   * @param address - The address of the account the app key is derived from.\n   * @param origin - The origin of the application.\n   * @returns The address of the app key for the given account and origin.\n   */\n  getAppKeyAddress?(address: Hex, origin: string): Promise<Hex>;\n\n  /**\n   * Sign a transaction. This is equivalent to the `eth_signTransaction`\n   * Ethereum JSON-RPC method. See the Ethereum JSON-RPC API documentation for\n   * more details.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param transaction - The transaction to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed transaction.\n   */\n  signTransaction?(\n    address: Hex,\n    transaction: TypedTransaction,\n    options?: Record<string, unknown>,\n  ): Promise<TypedTxData>;\n\n  /**\n   * Sign a message. This is equivalent to an older version of the the\n   * `eth_sign` Ethereum JSON-RPC method. The message is signed using ECDSA,\n   * using the curve secp256k1 the Keccak-256 hash function.\n   *\n   * For more information about this method and why we still support it, see\n   * the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param message - The message to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signMessage?(\n    address: Hex,\n    message: string,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign an EIP-7702 authorization. This is a signing method for authorizing a\n   * specific contract on a specific chain.\n   *\n   * @param address - The address of the account to use for signing.\n   * @param authorization - An array containing the chain ID, contract address,\n   * and nonce.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed authorization as a hex string.\n   */\n  signEip7702Authorization?(\n    address: Hex,\n    authorization: [chainId: number, contractAddress: Hex, nonce: number],\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign a message. This is equivalent to the `eth_sign` Ethereum JSON-RPC\n   * method, which is exposed by MetaMask as the method `personal_sign`. See\n   * the Ethereum JSON-RPC API documentation for more details.\n   *\n   * For more information about this method and why we call it `personal_sign`,\n   * see the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param message - The message to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signPersonalMessage?(\n    address: Hex,\n    message: Hex,\n    options?: { version?: string } & Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign a message. This is equivalent to the `eth_signTypedData` Ethereum\n   * JSON-RPC method. See {@link https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md|EIP-712}\n   * for more details.\n   *\n   * The \"version\" option dictates which version of `eth_signTypedData` is\n   * used. The latest version reflects the specification most closely, whereas\n   * earlier versions reflect earlier drafts of the specification that are\n   * still supported for backwards-compatibility reasons. For more information\n   * about why we support multiple versions, see the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept additional options as well. See the documentation for\n   * the specific keyring for more information about what these options are.\n   * For some keyrings, the options parameter can even change which key is used\n   * for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param typedData - The data to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signTypedData?(\n    address: Hex,\n    typedData: unknown[] | Record<string, unknown>,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Get a public key to use for encryption. This is equivalent to the\n   * ` eth_getEncryptionPublicKey` JSON-RPC method. See the {@link https://docs.metamask.io/guide/rpc-api.html#eth-getencryptionpublickey|MetaMask Docs}\n   * for more information.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used (e.g. encrypting with app keys).\n   *\n   * @param account - The address of the account you want the encryption key for.\n   * @param options - Options; differs between keyrings.\n   */\n  getEncryptionPublicKey?(\n    account: Hex,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Decrypt an encrypted message. This is equivalent to the `  eth_decrypt`\n   * JSON-RPC method. See the {@link https://docs.metamask.io/guide/rpc-api.html#eth-decrypt|MetaMask Docs}\n   * for more information.\n   *\n   * @param account - The address of the account you want to use to decrypt\n   * the message.\n   * @param encryptedData - The encrypted data that you want to decrypt.\n   * @returns The decrypted data.\n   */\n  decryptMessage?(\n    account: Hex,\n    encryptedData: Eip1024EncryptedData,\n  ): Promise<string>;\n\n  /**\n   * Generates the properties for the keyring based on the given\n   * BIP39-compliant mnemonic.\n   *\n   * @returns A promise resolving when the keyring has generated the properties.\n   */\n  generateRandomMnemonic?(): Promise<void>;\n\n  /**\n   * Destroy the keyring.\n   */\n  destroy?(): Promise<void>;\n};\n\n/**\n * The legacy `Keyring` is Ethereum only, so we can alias it here for better\n * clarity.\n */\nexport type EthKeyring = Keyring;\n"]}
+{"version":3,"file":"keyring.cjs","sourceRoot":"","sources":["../src/keyring.ts"],"names":[],"mappings":"","sourcesContent":["import type { TypedTransaction, TypedTxData } from '@ethereumjs/tx';\nimport type { Eip1024EncryptedData, Hex, Json } from '@metamask/utils';\n\n/**\n * A Keyring class.\n *\n * This type is used to validate the constructor signature and the `type`\n * static property on Keyring classes. See the {@link Keyring} type for more\n * information.\n */\nexport type KeyringClass = {\n  /**\n   * The Keyring constructor. Takes a single parameter, an \"options\" object.\n   * See the documentation for the specific keyring for more information about\n   * what these options are.\n   *\n   * @param options - The constructor options. Differs between keyring\n   * implementations.\n   */\n  new (options?: Record<string, unknown>): Keyring;\n\n  /**\n   * The name of this type of keyring. This must uniquely identify the\n   * keyring type.\n   */\n  type: string;\n};\n\n/**\n * Base keyring interface. See the {@link Keyring} type for more information.\n */\nexport type BaseKeyring = {\n  /**\n   * The name of this type of keyring. This must match the `type` property of\n   * the keyring class.\n   */\n  type: string;\n\n  /**\n   * Method to include asynchronous configuration.\n   */\n  init?(): Promise<void>;\n\n  /**\n   * Destroy the keyring.\n   */\n  destroy?(): Promise<void>;\n\n  /**\n   * Serialize the keyring state as a JSON-serializable object.\n   *\n   * @returns A JSON-serializable representation of the keyring state.\n   */\n  serialize(): Promise<Json>;\n\n  /**\n   * Deserialize the given keyring state, overwriting any existing state with\n   * the serialized state provided.\n   *\n   * @param state - A JSON-serializable representation of the keyring state.\n   */\n  deserialize(state: Json): Promise<void>;\n\n  /**\n   * Get the addresses for all accounts in this keyring.\n   *\n   * @returns A list of the account addresses for this keyring\n   */\n  getAccounts(): Promise<string[]>;\n\n  /**\n   * Remove an account from the keyring.\n   *\n   * @param address - The address of the account to remove.\n   */\n  removeAccount?(address: string): void;\n\n  /**\n   * Export the private key for one of the keyring accounts.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter is used to allow exporting a\n   * private key that is derived from the given account, rather than exporting\n   * that account's private key directly.\n   *\n   * @param address - The address of the account to export.\n   * @param options - Export options; differs between keyrings.\n   * @returns The non-prefixed, hex-encoded private key that was requested.\n   */\n  exportAccount?(\n    address: string,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n};\n\n/**\n * A keyring is something that can sign messages. Keyrings are used to add new\n * signing strategies; each strategy is a new keyring.\n *\n * Each keyring manages a collection of key pairs, which we call \"accounts\".\n * Each account is referred to by its \"address\", which is a unique identifier\n * derived from the public key. The address is always a \"0x\"-prefixed\n * hexidecimal string.\n *\n * The keyring might store the private key for each account as well, but it's\n * not guaranteed. Some keyrings delegate signing, so they don't need the\n * private key directly. The keyring (and in particular the keyring state)\n * should be treated with care though, just in case it does contain sensitive\n * material such as a private key.\n */\nexport type Keyring = BaseKeyring & {\n  /**\n   * Get the addresses for all accounts in this keyring.\n   *\n   * @returns A list of the account addresses for this keyring\n   */\n  getAccounts(): Promise<Hex[]>;\n\n  /**\n   * Add an account to the keyring.\n   *\n   * @param number - The number of accounts to add. Usually defaults to 1.\n   * @returns A list of the newly added account addresses.\n   */\n  addAccounts(number: number): Promise<Hex[]>;\n\n  /**\n   * Remove an account from the keyring.\n   *\n   * @param address - The address of the account to remove.\n   */\n  removeAccount?(address: Hex): void;\n\n  /**\n   * Export the private key for one of the keyring accounts.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter is used to allow exporting a\n   * private key that is derived from the given account, rather than exporting\n   * that account's private key directly.\n   *\n   * @param address - The address of the account to export.\n   * @param options - Export options; differs between keyrings.\n   * @returns The non-prefixed, hex-encoded private key that was requested.\n   */\n  exportAccount?(\n    address: Hex,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Get the \"app key\" address for the given account and origin. An app key is\n   * an application-specific key pair. See {@link https://eips.ethereum.org/EIPS/eip-1775|EIP-1775}\n   * for more information. The {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Origin|origin}\n   * is used as the unique identifier for the application, and it's used as\n   * part of the key derivation process.\n   *\n   * @param address - The address of the account the app key is derived from.\n   * @param origin - The origin of the application.\n   * @returns The address of the app key for the given account and origin.\n   */\n  getAppKeyAddress?(address: Hex, origin: string): Promise<Hex>;\n\n  /**\n   * Sign a transaction. This is equivalent to the `eth_signTransaction`\n   * Ethereum JSON-RPC method. See the Ethereum JSON-RPC API documentation for\n   * more details.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param transaction - The transaction to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed transaction.\n   */\n  signTransaction?(\n    address: Hex,\n    transaction: TypedTransaction,\n    options?: Record<string, unknown>,\n  ): Promise<TypedTxData>;\n\n  /**\n   * Sign a message. This is equivalent to an older version of the the\n   * `eth_sign` Ethereum JSON-RPC method. The message is signed using ECDSA,\n   * using the curve secp256k1 the Keccak-256 hash function.\n   *\n   * For more information about this method and why we still support it, see\n   * the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param message - The message to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signMessage?(\n    address: Hex,\n    message: string,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign an EIP-7702 authorization. This is a signing method for authorizing a\n   * specific contract on a specific chain.\n   *\n   * @param address - The address of the account to use for signing.\n   * @param authorization - An array containing the chain ID, contract address,\n   * and nonce.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed authorization as a hex string.\n   */\n  signEip7702Authorization?(\n    address: Hex,\n    authorization: [chainId: number, contractAddress: Hex, nonce: number],\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign a message. This is equivalent to the `eth_sign` Ethereum JSON-RPC\n   * method, which is exposed by MetaMask as the method `personal_sign`. See\n   * the Ethereum JSON-RPC API documentation for more details.\n   *\n   * For more information about this method and why we call it `personal_sign`,\n   * see the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param message - The message to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signPersonalMessage?(\n    address: Hex,\n    message: Hex,\n    options?: { version?: string } & Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign a message. This is equivalent to the `eth_signTypedData` Ethereum\n   * JSON-RPC method. See {@link https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md|EIP-712}\n   * for more details.\n   *\n   * The \"version\" option dictates which version of `eth_signTypedData` is\n   * used. The latest version reflects the specification most closely, whereas\n   * earlier versions reflect earlier drafts of the specification that are\n   * still supported for backwards-compatibility reasons. For more information\n   * about why we support multiple versions, see the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept additional options as well. See the documentation for\n   * the specific keyring for more information about what these options are.\n   * For some keyrings, the options parameter can even change which key is used\n   * for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param typedData - The data to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signTypedData?(\n    address: Hex,\n    typedData: unknown[] | Record<string, unknown>,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Get a public key to use for encryption. This is equivalent to the\n   * ` eth_getEncryptionPublicKey` JSON-RPC method. See the {@link https://docs.metamask.io/guide/rpc-api.html#eth-getencryptionpublickey|MetaMask Docs}\n   * for more information.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used (e.g. encrypting with app keys).\n   *\n   * @param account - The address of the account you want the encryption key for.\n   * @param options - Options; differs between keyrings.\n   */\n  getEncryptionPublicKey?(\n    account: Hex,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Decrypt an encrypted message. This is equivalent to the `  eth_decrypt`\n   * JSON-RPC method. See the {@link https://docs.metamask.io/guide/rpc-api.html#eth-decrypt|MetaMask Docs}\n   * for more information.\n   *\n   * @param account - The address of the account you want to use to decrypt\n   * the message.\n   * @param encryptedData - The encrypted data that you want to decrypt.\n   * @returns The decrypted data.\n   */\n  decryptMessage?(\n    account: Hex,\n    encryptedData: Eip1024EncryptedData,\n  ): Promise<string>;\n\n  /**\n   * Generates the properties for the keyring based on the given\n   * BIP39-compliant mnemonic.\n   *\n   * @returns A promise resolving when the keyring has generated the properties.\n   */\n  generateRandomMnemonic?(): Promise<void>;\n};\n\n/**\n * The legacy `Keyring` is Ethereum only, so we can alias it here for better\n * clarity.\n */\nexport type EthKeyring = Keyring;\n"]}

dist/keyring.d.cts

@@ -27,2 +27,59 @@ import type { TypedTransaction, TypedTxData } from "@ethereumjs/tx";
 /**
+ * Base keyring interface. See the {@link Keyring} type for more information.
+ */
+export type BaseKeyring = {
+    /**
+     * The name of this type of keyring. This must match the `type` property of
+     * the keyring class.
+     */
+    type: string;
+    /**
+     * Method to include asynchronous configuration.
+     */
+    init?(): Promise<void>;
+    /**
+     * Destroy the keyring.
+     */
+    destroy?(): Promise<void>;
+    /**
+     * Serialize the keyring state as a JSON-serializable object.
+     *
+     * @returns A JSON-serializable representation of the keyring state.
+     */
+    serialize(): Promise<Json>;
+    /**
+     * Deserialize the given keyring state, overwriting any existing state with
+     * the serialized state provided.
+     *
+     * @param state - A JSON-serializable representation of the keyring state.
+     */
+    deserialize(state: Json): Promise<void>;
+    /**
+     * Get the addresses for all accounts in this keyring.
+     *
+     * @returns A list of the account addresses for this keyring
+     */
+    getAccounts(): Promise<string[]>;
+    /**
+     * Remove an account from the keyring.
+     *
+     * @param address - The address of the account to remove.
+     */
+    removeAccount?(address: string): void;
+    /**
+     * Export the private key for one of the keyring accounts.
+     *
+     * Some keyrings accept an "options" parameter as well. See the documentation
+     * for the specific keyring for more information about what these options
+     * are. For some keyrings, the options parameter is used to allow exporting a
+     * private key that is derived from the given account, rather than exporting
+     * that account's private key directly.
+     *
+     * @param address - The address of the account to export.
+     * @param options - Export options; differs between keyrings.
+     * @returns The non-prefixed, hex-encoded private key that was requested.
+     */
+    exportAccount?(address: string, options?: Record<string, unknown>): Promise<string>;
+};
+/**
  * A keyring is something that can sign messages. Keyrings are used to add new
@@ -42,9 +99,4 @@ * signing strategies; each strategy is a new keyring.
  */
-export type Keyring = {
+export type Keyring = BaseKeyring & {
     /**
-     * The name of this type of keyring. This must match the `type` property of
-     * the keyring class.
-     */
-    type: string;
-    /**
      * Get the addresses for all accounts in this keyring.
@@ -63,19 +115,2 @@ *
     /**
-     * Serialize the keyring state as a JSON-serializable object.
-     *
-     * @returns A JSON-serializable representation of the keyring state.
-     */
-    serialize(): Promise<Json>;
-    /**
-     * Deserialize the given keyring state, overwriting any existing state with
-     * the serialized state provided.
-     *
-     * @param state - A JSON-serializable representation of the keyring state.
-     */
-    deserialize(state: Json): Promise<void>;
-    /**
-     * Method to include asynchronous configuration.
-     */
-    init?(): Promise<void>;
-    /**
      * Remove an account from the keyring.
@@ -233,6 +268,2 @@ *
     generateRandomMnemonic?(): Promise<void>;
-    /**
-     * Destroy the keyring.
-     */
-    destroy?(): Promise<void>;
 };
@@ -239,0 +270,0 @@ /**

dist/keyring.d.cts.map

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

dist/keyring.d.mts

@@ -27,2 +27,59 @@ import type { TypedTransaction, TypedTxData } from "@ethereumjs/tx";
 /**
+ * Base keyring interface. See the {@link Keyring} type for more information.
+ */
+export type BaseKeyring = {
+    /**
+     * The name of this type of keyring. This must match the `type` property of
+     * the keyring class.
+     */
+    type: string;
+    /**
+     * Method to include asynchronous configuration.
+     */
+    init?(): Promise<void>;
+    /**
+     * Destroy the keyring.
+     */
+    destroy?(): Promise<void>;
+    /**
+     * Serialize the keyring state as a JSON-serializable object.
+     *
+     * @returns A JSON-serializable representation of the keyring state.
+     */
+    serialize(): Promise<Json>;
+    /**
+     * Deserialize the given keyring state, overwriting any existing state with
+     * the serialized state provided.
+     *
+     * @param state - A JSON-serializable representation of the keyring state.
+     */
+    deserialize(state: Json): Promise<void>;
+    /**
+     * Get the addresses for all accounts in this keyring.
+     *
+     * @returns A list of the account addresses for this keyring
+     */
+    getAccounts(): Promise<string[]>;
+    /**
+     * Remove an account from the keyring.
+     *
+     * @param address - The address of the account to remove.
+     */
+    removeAccount?(address: string): void;
+    /**
+     * Export the private key for one of the keyring accounts.
+     *
+     * Some keyrings accept an "options" parameter as well. See the documentation
+     * for the specific keyring for more information about what these options
+     * are. For some keyrings, the options parameter is used to allow exporting a
+     * private key that is derived from the given account, rather than exporting
+     * that account's private key directly.
+     *
+     * @param address - The address of the account to export.
+     * @param options - Export options; differs between keyrings.
+     * @returns The non-prefixed, hex-encoded private key that was requested.
+     */
+    exportAccount?(address: string, options?: Record<string, unknown>): Promise<string>;
+};
+/**
  * A keyring is something that can sign messages. Keyrings are used to add new
@@ -42,9 +99,4 @@ * signing strategies; each strategy is a new keyring.
  */
-export type Keyring = {
+export type Keyring = BaseKeyring & {
     /**
-     * The name of this type of keyring. This must match the `type` property of
-     * the keyring class.
-     */
-    type: string;
-    /**
      * Get the addresses for all accounts in this keyring.
@@ -63,19 +115,2 @@ *
     /**
-     * Serialize the keyring state as a JSON-serializable object.
-     *
-     * @returns A JSON-serializable representation of the keyring state.
-     */
-    serialize(): Promise<Json>;
-    /**
-     * Deserialize the given keyring state, overwriting any existing state with
-     * the serialized state provided.
-     *
-     * @param state - A JSON-serializable representation of the keyring state.
-     */
-    deserialize(state: Json): Promise<void>;
-    /**
-     * Method to include asynchronous configuration.
-     */
-    init?(): Promise<void>;
-    /**
      * Remove an account from the keyring.
@@ -233,6 +268,2 @@ *
     generateRandomMnemonic?(): Promise<void>;
-    /**
-     * Destroy the keyring.
-     */
-    destroy?(): Promise<void>;
 };
@@ -239,0 +270,0 @@ /**

dist/keyring.d.mts.map

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

dist/keyring.mjs.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"keyring.mjs","sourceRoot":"","sources":["../src/keyring.ts"],"names":[],"mappings":"","sourcesContent":["import type { TypedTransaction, TypedTxData } from '@ethereumjs/tx';\nimport type { Eip1024EncryptedData, Hex, Json } from '@metamask/utils';\n\n/**\n * A Keyring class.\n *\n * This type is used to validate the constructor signature and the `type`\n * static property on Keyring classes. See the {@link Keyring} type for more\n * information.\n */\nexport type KeyringClass = {\n  /**\n   * The Keyring constructor. Takes a single parameter, an \"options\" object.\n   * See the documentation for the specific keyring for more information about\n   * what these options are.\n   *\n   * @param options - The constructor options. Differs between keyring\n   * implementations.\n   */\n  new (options?: Record<string, unknown>): Keyring;\n\n  /**\n   * The name of this type of keyring. This must uniquely identify the\n   * keyring type.\n   */\n  type: string;\n};\n\n/**\n * A keyring is something that can sign messages. Keyrings are used to add new\n * signing strategies; each strategy is a new keyring.\n *\n * Each keyring manages a collection of key pairs, which we call \"accounts\".\n * Each account is referred to by its \"address\", which is a unique identifier\n * derived from the public key. The address is always a \"0x\"-prefixed\n * hexidecimal string.\n *\n * The keyring might store the private key for each account as well, but it's\n * not guaranteed. Some keyrings delegate signing, so they don't need the\n * private key directly. The keyring (and in particular the keyring state)\n * should be treated with care though, just in case it does contain sensitive\n * material such as a private key.\n */\nexport type Keyring = {\n  /**\n   * The name of this type of keyring. This must match the `type` property of\n   * the keyring class.\n   */\n  type: string;\n\n  /**\n   * Get the addresses for all accounts in this keyring.\n   *\n   * @returns A list of the account addresses for this keyring\n   */\n  getAccounts(): Promise<Hex[]>;\n\n  /**\n   * Add an account to the keyring.\n   *\n   * @param number - The number of accounts to add. Usually defaults to 1.\n   * @returns A list of the newly added account addresses.\n   */\n  addAccounts(number: number): Promise<Hex[]>;\n\n  /**\n   * Serialize the keyring state as a JSON-serializable object.\n   *\n   * @returns A JSON-serializable representation of the keyring state.\n   */\n  serialize(): Promise<Json>;\n\n  /**\n   * Deserialize the given keyring state, overwriting any existing state with\n   * the serialized state provided.\n   *\n   * @param state - A JSON-serializable representation of the keyring state.\n   */\n  deserialize(state: Json): Promise<void>;\n\n  /**\n   * Method to include asynchronous configuration.\n   */\n  init?(): Promise<void>;\n\n  /**\n   * Remove an account from the keyring.\n   *\n   * @param address - The address of the account to remove.\n   */\n  removeAccount?(address: Hex): void;\n\n  /**\n   * Export the private key for one of the keyring accounts.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter is used to allow exporting a\n   * private key that is derived from the given account, rather than exporting\n   * that account's private key directly.\n   *\n   * @param address - The address of the account to export.\n   * @param options - Export options; differs between keyrings.\n   * @returns The non-prefixed, hex-encoded private key that was requested.\n   */\n  exportAccount?(\n    address: Hex,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Get the \"app key\" address for the given account and origin. An app key is\n   * an application-specific key pair. See {@link https://eips.ethereum.org/EIPS/eip-1775|EIP-1775}\n   * for more information. The {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Origin|origin}\n   * is used as the unique identifier for the application, and it's used as\n   * part of the key derivation process.\n   *\n   * @param address - The address of the account the app key is derived from.\n   * @param origin - The origin of the application.\n   * @returns The address of the app key for the given account and origin.\n   */\n  getAppKeyAddress?(address: Hex, origin: string): Promise<Hex>;\n\n  /**\n   * Sign a transaction. This is equivalent to the `eth_signTransaction`\n   * Ethereum JSON-RPC method. See the Ethereum JSON-RPC API documentation for\n   * more details.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param transaction - The transaction to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed transaction.\n   */\n  signTransaction?(\n    address: Hex,\n    transaction: TypedTransaction,\n    options?: Record<string, unknown>,\n  ): Promise<TypedTxData>;\n\n  /**\n   * Sign a message. This is equivalent to an older version of the the\n   * `eth_sign` Ethereum JSON-RPC method. The message is signed using ECDSA,\n   * using the curve secp256k1 the Keccak-256 hash function.\n   *\n   * For more information about this method and why we still support it, see\n   * the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param message - The message to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signMessage?(\n    address: Hex,\n    message: string,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign an EIP-7702 authorization. This is a signing method for authorizing a\n   * specific contract on a specific chain.\n   *\n   * @param address - The address of the account to use for signing.\n   * @param authorization - An array containing the chain ID, contract address,\n   * and nonce.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed authorization as a hex string.\n   */\n  signEip7702Authorization?(\n    address: Hex,\n    authorization: [chainId: number, contractAddress: Hex, nonce: number],\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign a message. This is equivalent to the `eth_sign` Ethereum JSON-RPC\n   * method, which is exposed by MetaMask as the method `personal_sign`. See\n   * the Ethereum JSON-RPC API documentation for more details.\n   *\n   * For more information about this method and why we call it `personal_sign`,\n   * see the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param message - The message to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signPersonalMessage?(\n    address: Hex,\n    message: Hex,\n    options?: { version?: string } & Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign a message. This is equivalent to the `eth_signTypedData` Ethereum\n   * JSON-RPC method. See {@link https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md|EIP-712}\n   * for more details.\n   *\n   * The \"version\" option dictates which version of `eth_signTypedData` is\n   * used. The latest version reflects the specification most closely, whereas\n   * earlier versions reflect earlier drafts of the specification that are\n   * still supported for backwards-compatibility reasons. For more information\n   * about why we support multiple versions, see the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept additional options as well. See the documentation for\n   * the specific keyring for more information about what these options are.\n   * For some keyrings, the options parameter can even change which key is used\n   * for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param typedData - The data to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signTypedData?(\n    address: Hex,\n    typedData: unknown[] | Record<string, unknown>,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Get a public key to use for encryption. This is equivalent to the\n   * ` eth_getEncryptionPublicKey` JSON-RPC method. See the {@link https://docs.metamask.io/guide/rpc-api.html#eth-getencryptionpublickey|MetaMask Docs}\n   * for more information.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used (e.g. encrypting with app keys).\n   *\n   * @param account - The address of the account you want the encryption key for.\n   * @param options - Options; differs between keyrings.\n   */\n  getEncryptionPublicKey?(\n    account: Hex,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Decrypt an encrypted message. This is equivalent to the `  eth_decrypt`\n   * JSON-RPC method. See the {@link https://docs.metamask.io/guide/rpc-api.html#eth-decrypt|MetaMask Docs}\n   * for more information.\n   *\n   * @param account - The address of the account you want to use to decrypt\n   * the message.\n   * @param encryptedData - The encrypted data that you want to decrypt.\n   * @returns The decrypted data.\n   */\n  decryptMessage?(\n    account: Hex,\n    encryptedData: Eip1024EncryptedData,\n  ): Promise<string>;\n\n  /**\n   * Generates the properties for the keyring based on the given\n   * BIP39-compliant mnemonic.\n   *\n   * @returns A promise resolving when the keyring has generated the properties.\n   */\n  generateRandomMnemonic?(): Promise<void>;\n\n  /**\n   * Destroy the keyring.\n   */\n  destroy?(): Promise<void>;\n};\n\n/**\n * The legacy `Keyring` is Ethereum only, so we can alias it here for better\n * clarity.\n */\nexport type EthKeyring = Keyring;\n"]}
+{"version":3,"file":"keyring.mjs","sourceRoot":"","sources":["../src/keyring.ts"],"names":[],"mappings":"","sourcesContent":["import type { TypedTransaction, TypedTxData } from '@ethereumjs/tx';\nimport type { Eip1024EncryptedData, Hex, Json } from '@metamask/utils';\n\n/**\n * A Keyring class.\n *\n * This type is used to validate the constructor signature and the `type`\n * static property on Keyring classes. See the {@link Keyring} type for more\n * information.\n */\nexport type KeyringClass = {\n  /**\n   * The Keyring constructor. Takes a single parameter, an \"options\" object.\n   * See the documentation for the specific keyring for more information about\n   * what these options are.\n   *\n   * @param options - The constructor options. Differs between keyring\n   * implementations.\n   */\n  new (options?: Record<string, unknown>): Keyring;\n\n  /**\n   * The name of this type of keyring. This must uniquely identify the\n   * keyring type.\n   */\n  type: string;\n};\n\n/**\n * Base keyring interface. See the {@link Keyring} type for more information.\n */\nexport type BaseKeyring = {\n  /**\n   * The name of this type of keyring. This must match the `type` property of\n   * the keyring class.\n   */\n  type: string;\n\n  /**\n   * Method to include asynchronous configuration.\n   */\n  init?(): Promise<void>;\n\n  /**\n   * Destroy the keyring.\n   */\n  destroy?(): Promise<void>;\n\n  /**\n   * Serialize the keyring state as a JSON-serializable object.\n   *\n   * @returns A JSON-serializable representation of the keyring state.\n   */\n  serialize(): Promise<Json>;\n\n  /**\n   * Deserialize the given keyring state, overwriting any existing state with\n   * the serialized state provided.\n   *\n   * @param state - A JSON-serializable representation of the keyring state.\n   */\n  deserialize(state: Json): Promise<void>;\n\n  /**\n   * Get the addresses for all accounts in this keyring.\n   *\n   * @returns A list of the account addresses for this keyring\n   */\n  getAccounts(): Promise<string[]>;\n\n  /**\n   * Remove an account from the keyring.\n   *\n   * @param address - The address of the account to remove.\n   */\n  removeAccount?(address: string): void;\n\n  /**\n   * Export the private key for one of the keyring accounts.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter is used to allow exporting a\n   * private key that is derived from the given account, rather than exporting\n   * that account's private key directly.\n   *\n   * @param address - The address of the account to export.\n   * @param options - Export options; differs between keyrings.\n   * @returns The non-prefixed, hex-encoded private key that was requested.\n   */\n  exportAccount?(\n    address: string,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n};\n\n/**\n * A keyring is something that can sign messages. Keyrings are used to add new\n * signing strategies; each strategy is a new keyring.\n *\n * Each keyring manages a collection of key pairs, which we call \"accounts\".\n * Each account is referred to by its \"address\", which is a unique identifier\n * derived from the public key. The address is always a \"0x\"-prefixed\n * hexidecimal string.\n *\n * The keyring might store the private key for each account as well, but it's\n * not guaranteed. Some keyrings delegate signing, so they don't need the\n * private key directly. The keyring (and in particular the keyring state)\n * should be treated with care though, just in case it does contain sensitive\n * material such as a private key.\n */\nexport type Keyring = BaseKeyring & {\n  /**\n   * Get the addresses for all accounts in this keyring.\n   *\n   * @returns A list of the account addresses for this keyring\n   */\n  getAccounts(): Promise<Hex[]>;\n\n  /**\n   * Add an account to the keyring.\n   *\n   * @param number - The number of accounts to add. Usually defaults to 1.\n   * @returns A list of the newly added account addresses.\n   */\n  addAccounts(number: number): Promise<Hex[]>;\n\n  /**\n   * Remove an account from the keyring.\n   *\n   * @param address - The address of the account to remove.\n   */\n  removeAccount?(address: Hex): void;\n\n  /**\n   * Export the private key for one of the keyring accounts.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter is used to allow exporting a\n   * private key that is derived from the given account, rather than exporting\n   * that account's private key directly.\n   *\n   * @param address - The address of the account to export.\n   * @param options - Export options; differs between keyrings.\n   * @returns The non-prefixed, hex-encoded private key that was requested.\n   */\n  exportAccount?(\n    address: Hex,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Get the \"app key\" address for the given account and origin. An app key is\n   * an application-specific key pair. See {@link https://eips.ethereum.org/EIPS/eip-1775|EIP-1775}\n   * for more information. The {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Origin|origin}\n   * is used as the unique identifier for the application, and it's used as\n   * part of the key derivation process.\n   *\n   * @param address - The address of the account the app key is derived from.\n   * @param origin - The origin of the application.\n   * @returns The address of the app key for the given account and origin.\n   */\n  getAppKeyAddress?(address: Hex, origin: string): Promise<Hex>;\n\n  /**\n   * Sign a transaction. This is equivalent to the `eth_signTransaction`\n   * Ethereum JSON-RPC method. See the Ethereum JSON-RPC API documentation for\n   * more details.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param transaction - The transaction to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed transaction.\n   */\n  signTransaction?(\n    address: Hex,\n    transaction: TypedTransaction,\n    options?: Record<string, unknown>,\n  ): Promise<TypedTxData>;\n\n  /**\n   * Sign a message. This is equivalent to an older version of the the\n   * `eth_sign` Ethereum JSON-RPC method. The message is signed using ECDSA,\n   * using the curve secp256k1 the Keccak-256 hash function.\n   *\n   * For more information about this method and why we still support it, see\n   * the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param message - The message to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signMessage?(\n    address: Hex,\n    message: string,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign an EIP-7702 authorization. This is a signing method for authorizing a\n   * specific contract on a specific chain.\n   *\n   * @param address - The address of the account to use for signing.\n   * @param authorization - An array containing the chain ID, contract address,\n   * and nonce.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed authorization as a hex string.\n   */\n  signEip7702Authorization?(\n    address: Hex,\n    authorization: [chainId: number, contractAddress: Hex, nonce: number],\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign a message. This is equivalent to the `eth_sign` Ethereum JSON-RPC\n   * method, which is exposed by MetaMask as the method `personal_sign`. See\n   * the Ethereum JSON-RPC API documentation for more details.\n   *\n   * For more information about this method and why we call it `personal_sign`,\n   * see the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param message - The message to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signPersonalMessage?(\n    address: Hex,\n    message: Hex,\n    options?: { version?: string } & Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Sign a message. This is equivalent to the `eth_signTypedData` Ethereum\n   * JSON-RPC method. See {@link https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md|EIP-712}\n   * for more details.\n   *\n   * The \"version\" option dictates which version of `eth_signTypedData` is\n   * used. The latest version reflects the specification most closely, whereas\n   * earlier versions reflect earlier drafts of the specification that are\n   * still supported for backwards-compatibility reasons. For more information\n   * about why we support multiple versions, see the {@link https://docs.metamask.io/guide/signing-data.html|MetaMask Docs}.\n   *\n   * Some keyrings accept additional options as well. See the documentation for\n   * the specific keyring for more information about what these options are.\n   * For some keyrings, the options parameter can even change which key is used\n   * for signing (e.g. signing with app keys).\n   *\n   * @param address - The address of the account to use for signing.\n   * @param typedData - The data to sign.\n   * @param options - Signing options; differs between keyrings.\n   * @returns The signed message.\n   */\n  signTypedData?(\n    address: Hex,\n    typedData: unknown[] | Record<string, unknown>,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Get a public key to use for encryption. This is equivalent to the\n   * ` eth_getEncryptionPublicKey` JSON-RPC method. See the {@link https://docs.metamask.io/guide/rpc-api.html#eth-getencryptionpublickey|MetaMask Docs}\n   * for more information.\n   *\n   * Some keyrings accept an \"options\" parameter as well. See the documentation\n   * for the specific keyring for more information about what these options\n   * are. For some keyrings, the options parameter can even change which key is\n   * used (e.g. encrypting with app keys).\n   *\n   * @param account - The address of the account you want the encryption key for.\n   * @param options - Options; differs between keyrings.\n   */\n  getEncryptionPublicKey?(\n    account: Hex,\n    options?: Record<string, unknown>,\n  ): Promise<string>;\n\n  /**\n   * Decrypt an encrypted message. This is equivalent to the `  eth_decrypt`\n   * JSON-RPC method. See the {@link https://docs.metamask.io/guide/rpc-api.html#eth-decrypt|MetaMask Docs}\n   * for more information.\n   *\n   * @param account - The address of the account you want to use to decrypt\n   * the message.\n   * @param encryptedData - The encrypted data that you want to decrypt.\n   * @returns The decrypted data.\n   */\n  decryptMessage?(\n    account: Hex,\n    encryptedData: Eip1024EncryptedData,\n  ): Promise<string>;\n\n  /**\n   * Generates the properties for the keyring based on the given\n   * BIP39-compliant mnemonic.\n   *\n   * @returns A promise resolving when the keyring has generated the properties.\n   */\n  generateRandomMnemonic?(): Promise<void>;\n};\n\n/**\n * The legacy `Keyring` is Ethereum only, so we can alias it here for better\n * clarity.\n */\nexport type EthKeyring = Keyring;\n"]}

dist/scopes.cjs

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ETH_SCOPE_EOA = void 0;
-exports.isScopeEqual = isScopeEqual;
-exports.isScopeEqualToAny = isScopeEqualToAny;
+exports.isScopeEqualToAny = exports.isScopeEqual = exports.ETH_SCOPE_EOA = void 0;
 const utils_1 = require("@metamask/utils");
@@ -34,2 +32,3 @@ // We do not use the `EthScope` from `@metamask/keyring-api` here to avoid pulling it
 }
+exports.isScopeEqual = isScopeEqual;
 /**
@@ -47,2 +46,3 @@ * Check if `scope` matches any scope from `scopes`. It also supports the special
 }
+exports.isScopeEqualToAny = isScopeEqualToAny;
 //# sourceMappingURL=scopes.cjs.map

dist/scopes.cjs.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"scopes.cjs","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":";;;AAmBA,oCAcC;AAWD,8CAKC;AAhDD,2CAAqD;AAErD,qFAAqF;AACrF,mBAAmB;AACN,QAAA,aAAa,GAAG,GAAG,0BAAkB,CAAC,MAAM,IAAI,CAAC;AAE9D,yEAAyE;AACzE,MAAM,gBAAgB,GAAG,GAAG,0BAAkB,CAAC,MAAM,GAAG,CAAC;AAEzD;;;;;;;;GAQG;AACH,SAAgB,YAAY,CAAC,KAAkB,EAAE,KAAkB;IACjE,MAAM,UAAU,GAAG,KAAK,KAAK,qBAAa,CAAC;IAC3C,MAAM,UAAU,GAAG,KAAK,KAAK,qBAAa,CAAC;IAE3C,wDAAwD;IACxD,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;IAC5C,CAAC;IACD,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;IAC5C,CAAC;IAED,wEAAwE;IACxE,OAAO,KAAK,KAAK,KAAK,CAAC;AACzB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,iBAAiB,CAC/B,KAAkB,EAClB,MAAqB;IAErB,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;AAC5D,CAAC","sourcesContent":["import type { CaipChainId } from '@metamask/utils';\nimport { KnownCaipNamespace } from '@metamask/utils';\n\n// We do not use the `EthScope` from `@metamask/keyring-api` here to avoid pulling it\n// as a dependency.\nexport const ETH_SCOPE_EOA = `${KnownCaipNamespace.Eip155}:0`;\n\n// We use a string prefix when comparing EOAs to avoid unecessary splits.\nconst ETH_SCOPE_PREFIX = `${KnownCaipNamespace.Eip155}:`;\n\n/**\n * Check if scope matches another scope. It also supports the special\n * case of `eip155:0` for EVM EOA chain ID which is compatible with any EVM chain\n * ID (`eip155:*`).\n *\n * @param scope - The scope (CAIP-2 chain ID) to check.\n * @param other - Another scope to compare to.\n * @returns True if both scope are compatible, false otherwise.\n */\nexport function isScopeEqual(scope: CaipChainId, other: CaipChainId): boolean {\n  const isScopeEoa = scope === ETH_SCOPE_EOA;\n  const isOtherEoa = other === ETH_SCOPE_EOA;\n\n  // Special case for EOA scopes (we check on both sides).\n  if (isScopeEoa) {\n    return other.startsWith(ETH_SCOPE_PREFIX);\n  }\n  if (isOtherEoa) {\n    return scope.startsWith(ETH_SCOPE_PREFIX);\n  }\n\n  // Normal case, if both scopes strictly match, then they are compatible.\n  return scope === other;\n}\n\n/**\n * Check if `scope` matches any scope from `scopes`. It also supports the special\n * case of `eip155:0` for EVM EOA chain ID which is compatible with any EVM chain\n * ID (`eip155:*`).\n *\n * @param scope - The scope (CAIP-2 chain ID) to check.\n * @param scopes - The list of scopes to check against.\n * @returns True if `scope` matches any scope from `scopes`, false otherwise.\n */\nexport function isScopeEqualToAny(\n  scope: CaipChainId,\n  scopes: CaipChainId[],\n): boolean {\n  return scopes.some((other) => isScopeEqual(scope, other));\n}\n"]}
+{"version":3,"file":"scopes.cjs","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":";;;AACA,2CAAqD;AAErD,qFAAqF;AACrF,mBAAmB;AACN,QAAA,aAAa,GAAG,GAAG,0BAAkB,CAAC,MAAM,IAAI,CAAC;AAE9D,yEAAyE;AACzE,MAAM,gBAAgB,GAAG,GAAG,0BAAkB,CAAC,MAAM,GAAG,CAAC;AAEzD;;;;;;;;GAQG;AACH,SAAgB,YAAY,CAAC,KAAkB,EAAE,KAAkB;IACjE,MAAM,UAAU,GAAG,KAAK,KAAK,qBAAa,CAAC;IAC3C,MAAM,UAAU,GAAG,KAAK,KAAK,qBAAa,CAAC;IAE3C,wDAAwD;IACxD,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;IAC5C,CAAC;IACD,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;IAC5C,CAAC;IAED,wEAAwE;IACxE,OAAO,KAAK,KAAK,KAAK,CAAC;AACzB,CAAC;AAdD,oCAcC;AAED;;;;;;;;GAQG;AACH,SAAgB,iBAAiB,CAC/B,KAAkB,EAClB,MAAqB;IAErB,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;AAC5D,CAAC;AALD,8CAKC","sourcesContent":["import type { CaipChainId } from '@metamask/utils';\nimport { KnownCaipNamespace } from '@metamask/utils';\n\n// We do not use the `EthScope` from `@metamask/keyring-api` here to avoid pulling it\n// as a dependency.\nexport const ETH_SCOPE_EOA = `${KnownCaipNamespace.Eip155}:0`;\n\n// We use a string prefix when comparing EOAs to avoid unecessary splits.\nconst ETH_SCOPE_PREFIX = `${KnownCaipNamespace.Eip155}:`;\n\n/**\n * Check if scope matches another scope. It also supports the special\n * case of `eip155:0` for EVM EOA chain ID which is compatible with any EVM chain\n * ID (`eip155:*`).\n *\n * @param scope - The scope (CAIP-2 chain ID) to check.\n * @param other - Another scope to compare to.\n * @returns True if both scope are compatible, false otherwise.\n */\nexport function isScopeEqual(scope: CaipChainId, other: CaipChainId): boolean {\n  const isScopeEoa = scope === ETH_SCOPE_EOA;\n  const isOtherEoa = other === ETH_SCOPE_EOA;\n\n  // Special case for EOA scopes (we check on both sides).\n  if (isScopeEoa) {\n    return other.startsWith(ETH_SCOPE_PREFIX);\n  }\n  if (isOtherEoa) {\n    return scope.startsWith(ETH_SCOPE_PREFIX);\n  }\n\n  // Normal case, if both scopes strictly match, then they are compatible.\n  return scope === other;\n}\n\n/**\n * Check if `scope` matches any scope from `scopes`. It also supports the special\n * case of `eip155:0` for EVM EOA chain ID which is compatible with any EVM chain\n * ID (`eip155:*`).\n *\n * @param scope - The scope (CAIP-2 chain ID) to check.\n * @param scopes - The list of scopes to check against.\n * @returns True if `scope` matches any scope from `scopes`, false otherwise.\n */\nexport function isScopeEqualToAny(\n  scope: CaipChainId,\n  scopes: CaipChainId[],\n): boolean {\n  return scopes.some((other) => isScopeEqual(scope, other));\n}\n"]}

dist/superstruct.cjs

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.object = object;
-exports.type = type;
-exports.exactOptional = exactOptional;
-exports.strictMask = strictMask;
-exports.selectiveUnion = selectiveUnion;
+exports.selectiveUnion = exports.strictMask = exports.exactOptional = exports.type = exports.object = void 0;
 const superstruct_1 = require("@metamask/superstruct");
@@ -19,2 +15,3 @@ /**
 }
+exports.object = object;
 /**
@@ -31,2 +28,3 @@ * Change the return type of a superstruct's `type` function to support
 }
+exports.type = type;
 /**
@@ -63,2 +61,3 @@ * Check if the current property is present in its parent object.
 }
+exports.exactOptional = exactOptional;
 /**
@@ -79,2 +78,3 @@ * Assert that a value is valid according to a struct.
 }
+exports.strictMask = strictMask;
 /**
@@ -108,2 +108,3 @@ * Create a custom union struct that uses a `selector` function for choosing
 }
+exports.selectiveUnion = selectiveUnion;
 //# sourceMappingURL=superstruct.cjs.map

dist/superstruct.cjs.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"superstruct.cjs","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":";;AAoEA,wBAIC;AAUD,oBAIC;AA4BD,sCAYC;AAaD,gCAOC;AAwBD,wCAyBC;AAnMD,uDAK+B;AAwD/B;;;;;;GAMG;AACH,SAAgB,MAAM,CACpB,MAAc;IAEd,OAAO,IAAA,oBAAQ,EAAC,MAAM,CAAQ,CAAC;AACjC,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,IAAI,CAClB,MAAc;IAEd,OAAO,IAAA,kBAAM,EAAC,MAAM,CAAQ,CAAC;AAC/B,CAAC;AAED;;;;;GAKG;AACH,SAAS,WAAW,CAAC,GAAY;IAC/B,MAAM,QAAQ,GAAW,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvD,MAAM,MAAM,GAA4B,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAE1E,OAAO,QAAQ,IAAI,MAAM,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,aAAa,CAC3B,MAA4B;IAE5B,OAAO,IAAI,oBAAM,CAAC;QAChB,GAAG,MAAM;QAET,SAAS,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACxB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC;QAEnD,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACtB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAa,EAAE,GAAG,CAAC;KAC1D,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,UAAU,CACxB,KAAc,EACd,MAA4B,EAC5B,OAAgB;IAEhB,IAAA,oBAAM,EAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,KAAK,CAAC;AACf,CAAC;AAgBD;;;;;;;GAOG;AACH,SAAgB,cAAc,CAC5B,QAAkB;IAElB,OAAO,IAAI,oBAAM,CAAC;QAChB,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,IAAI;QAEZ,CAAC,OAAO,CAAC,KAAU,EAAE,OAAY;YAC/B,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO;YACrB,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,OAAO,CAAC,KAAK,EAAE,OAAO;YACpB,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,SAAS,CAAC,KAAK,EAAE,OAAO;YACtB,uEAAuE;YACvE,YAAY;YACZ,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACnD,CAAC;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["import {\n  Struct,\n  assert,\n  object as stObject,\n  type as stType,\n} from '@metamask/superstruct';\nimport type {\n  Infer,\n  Context,\n  ObjectSchema,\n  OmitBy,\n  Optionalize,\n  PickBy,\n  Simplify,\n  AnyStruct,\n} from '@metamask/superstruct';\n\nimport type { Equals } from './types';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ndeclare const ExactOptionalSymbol: unique symbol;\n\nexport type ExactOptionalTag = {\n  type: typeof ExactOptionalSymbol;\n};\n\n/**\n * Exclude type `Type` from the properties of `Obj`.\n *\n * ```ts\n * type Foo = { a: string | null; b: number };\n * type Bar = ExcludeType<Foo, null>;\n * // Bar = { a: string, b: number }\n * ```\n */\nexport type ExcludeType<Obj, Type> = {\n  [K in keyof Obj]: Exclude<Obj[K], Type>;\n};\n\n/**\n * Make optional all properties that have the `ExactOptionalTag` type.\n *\n * ```ts\n * type Foo = { a: string | ExactOptionalTag; b: number};\n * type Bar = ExactOptionalize<Foo>;\n * // Bar = { a?: string; b: number}\n * ```\n */\nexport type ExactOptionalize<Schema extends object> = OmitBy<\n  Schema,\n  ExactOptionalTag\n> &\n  Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;\n\n/**\n * Infer a type from an superstruct object schema.\n */\nexport type ObjectType<Schema extends ObjectSchema> = Simplify<\n  ExactOptionalize<Optionalize<{ [K in keyof Schema]: Infer<Schema[K]> }>>\n>;\n\n/**\n * Change the return type of a superstruct's `object` function to support\n * exact optional properties.\n *\n * @param schema - The object schema.\n * @returns A struct representing an object with a known set of properties.\n */\nexport function object<Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>, Schema> {\n  return stObject(schema) as any;\n}\n\n/**\n * Change the return type of a superstruct's `type` function to support\n * exact optional properties.\n *\n * @param schema - The object schema.\n * @returns A struct representing an object with a known set of properties\n * and ignore unknown properties.\n */\nexport function type<Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>, Schema> {\n  return stType(schema) as any;\n}\n\n/**\n * Check if the current property is present in its parent object.\n *\n * @param ctx - The context to check.\n * @returns `true` if the property is present, `false` otherwise.\n */\nfunction hasOptional(ctx: Context): boolean {\n  const property: string = ctx.path[ctx.path.length - 1];\n  const parent: Record<string, unknown> = ctx.branch[ctx.branch.length - 2];\n\n  return property in parent;\n}\n\n/**\n * Augment a struct to allow exact-optional values. Exact-optional values can\n * be omitted but cannot be `undefined`.\n *\n * ```ts\n * const foo = object({ bar: exactOptional(string()) });\n * type Foo = Infer<typeof foo>;\n * // Foo = { bar?: string }\n * ```\n *\n * @param struct - The struct to augment.\n * @returns The augmented struct.\n */\nexport function exactOptional<Type, Schema>(\n  struct: Struct<Type, Schema>,\n): Struct<Type | ExactOptionalTag, Schema> {\n  return new Struct({\n    ...struct,\n\n    validator: (value, ctx) =>\n      !hasOptional(ctx) || struct.validator(value, ctx),\n\n    refiner: (value, ctx) =>\n      !hasOptional(ctx) || struct.refiner(value as Type, ctx),\n  });\n}\n\n/**\n * Assert that a value is valid according to a struct.\n *\n * It is similar to superstruct's mask function, but it does not ignore extra\n * properties.\n *\n * @param value - Value to check.\n * @param struct - Struct to validate the value against.\n * @param message - Error message to throw if the value is not valid.\n * @returns The value if it is valid.\n */\nexport function strictMask<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  message?: string,\n): Type {\n  assert(value, struct, message);\n  return value;\n}\n\n/**\n * Extracts the type from a struct definition and asserts that it matches the\n * expected type. If the types do not match, the type `never` is returned.\n *\n * @param StructType - The struct type to infer.\n * @param ExpectedType - The expected type.\n */\nexport type InferEquals<\n  StructType extends Struct<any, any>,\n  ExpectedType,\n> = Equals<Infer<StructType>, ExpectedType> extends true\n  ? Infer<StructType>\n  : never;\n\n/**\n * Create a custom union struct that uses a `selector` function for choosing\n * the validation path.\n *\n * @param selector - The selector function choosing the struct to validate with.\n * @returns The `superstruct` struct, which validates that the value satisfies\n * one of the structs.\n */\nexport function selectiveUnion<Selector extends (value: any) => AnyStruct>(\n  selector: Selector,\n): Struct<Infer<ReturnType<Selector>>, null> {\n  return new Struct({\n    type: 'union',\n    schema: null,\n\n    *entries(value: any, context: any): ReturnType<Struct['entries']> {\n      yield* selector(value).entries(value, context);\n    },\n\n    *refiner(value, context): ReturnType<Struct['refiner']> {\n      yield* selector(value).refiner(value, context);\n    },\n\n    coercer(value, context): ReturnType<Struct['coercer']> {\n      return selector(value).coercer(value, context);\n    },\n\n    validator(value, context): ReturnType<Struct['validator']> {\n      // This only validates the root of the struct, entries does the rest of\n      // the work.\n      return selector(value).validator(value, context);\n    },\n  });\n}\n"]}
+{"version":3,"file":"superstruct.cjs","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":";;;AAAA,uDAK+B;AAwD/B;;;;;;GAMG;AACH,SAAgB,MAAM,CACpB,MAAc;IAEd,OAAO,IAAA,oBAAQ,EAAC,MAAM,CAAQ,CAAC;AACjC,CAAC;AAJD,wBAIC;AAED;;;;;;;GAOG;AACH,SAAgB,IAAI,CAClB,MAAc;IAEd,OAAO,IAAA,kBAAM,EAAC,MAAM,CAAQ,CAAC;AAC/B,CAAC;AAJD,oBAIC;AAED;;;;;GAKG;AACH,SAAS,WAAW,CAAC,GAAY;IAC/B,MAAM,QAAQ,GAAW,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvD,MAAM,MAAM,GAA4B,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAE1E,OAAO,QAAQ,IAAI,MAAM,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,aAAa,CAC3B,MAA4B;IAE5B,OAAO,IAAI,oBAAM,CAAC;QAChB,GAAG,MAAM;QAET,SAAS,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACxB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC;QAEnD,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACtB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAa,EAAE,GAAG,CAAC;KAC1D,CAAC,CAAC;AACL,CAAC;AAZD,sCAYC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,UAAU,CACxB,KAAc,EACd,MAA4B,EAC5B,OAAgB;IAEhB,IAAA,oBAAM,EAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,KAAK,CAAC;AACf,CAAC;AAPD,gCAOC;AAcD;;;;;;;GAOG;AACH,SAAgB,cAAc,CAC5B,QAAkB;IAElB,OAAO,IAAI,oBAAM,CAAC;QAChB,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,IAAI;QAEZ,CAAC,OAAO,CAAC,KAAU,EAAE,OAAY;YAC/B,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO;YACrB,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,OAAO,CAAC,KAAK,EAAE,OAAO;YACpB,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,SAAS,CAAC,KAAK,EAAE,OAAO;YACtB,uEAAuE;YACvE,YAAY;YACZ,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACnD,CAAC;KACF,CAAC,CAAC;AACL,CAAC;AAzBD,wCAyBC","sourcesContent":["import {\n  Struct,\n  assert,\n  object as stObject,\n  type as stType,\n} from '@metamask/superstruct';\nimport type {\n  Infer,\n  Context,\n  ObjectSchema,\n  OmitBy,\n  Optionalize,\n  PickBy,\n  Simplify,\n  AnyStruct,\n} from '@metamask/superstruct';\n\nimport type { Equals } from './types';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ndeclare const ExactOptionalSymbol: unique symbol;\n\nexport type ExactOptionalTag = {\n  type: typeof ExactOptionalSymbol;\n};\n\n/**\n * Exclude type `Type` from the properties of `Obj`.\n *\n * ```ts\n * type Foo = { a: string | null; b: number };\n * type Bar = ExcludeType<Foo, null>;\n * // Bar = { a: string, b: number }\n * ```\n */\nexport type ExcludeType<Obj, Type> = {\n  [K in keyof Obj]: Exclude<Obj[K], Type>;\n};\n\n/**\n * Make optional all properties that have the `ExactOptionalTag` type.\n *\n * ```ts\n * type Foo = { a: string | ExactOptionalTag; b: number};\n * type Bar = ExactOptionalize<Foo>;\n * // Bar = { a?: string; b: number}\n * ```\n */\nexport type ExactOptionalize<Schema extends object> = OmitBy<\n  Schema,\n  ExactOptionalTag\n> &\n  Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;\n\n/**\n * Infer a type from an superstruct object schema.\n */\nexport type ObjectType<Schema extends ObjectSchema> = Simplify<\n  ExactOptionalize<Optionalize<{ [K in keyof Schema]: Infer<Schema[K]> }>>\n>;\n\n/**\n * Change the return type of a superstruct's `object` function to support\n * exact optional properties.\n *\n * @param schema - The object schema.\n * @returns A struct representing an object with a known set of properties.\n */\nexport function object<Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>, Schema> {\n  return stObject(schema) as any;\n}\n\n/**\n * Change the return type of a superstruct's `type` function to support\n * exact optional properties.\n *\n * @param schema - The object schema.\n * @returns A struct representing an object with a known set of properties\n * and ignore unknown properties.\n */\nexport function type<Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>, Schema> {\n  return stType(schema) as any;\n}\n\n/**\n * Check if the current property is present in its parent object.\n *\n * @param ctx - The context to check.\n * @returns `true` if the property is present, `false` otherwise.\n */\nfunction hasOptional(ctx: Context): boolean {\n  const property: string = ctx.path[ctx.path.length - 1];\n  const parent: Record<string, unknown> = ctx.branch[ctx.branch.length - 2];\n\n  return property in parent;\n}\n\n/**\n * Augment a struct to allow exact-optional values. Exact-optional values can\n * be omitted but cannot be `undefined`.\n *\n * ```ts\n * const foo = object({ bar: exactOptional(string()) });\n * type Foo = Infer<typeof foo>;\n * // Foo = { bar?: string }\n * ```\n *\n * @param struct - The struct to augment.\n * @returns The augmented struct.\n */\nexport function exactOptional<Type, Schema>(\n  struct: Struct<Type, Schema>,\n): Struct<Type | ExactOptionalTag, Schema> {\n  return new Struct({\n    ...struct,\n\n    validator: (value, ctx) =>\n      !hasOptional(ctx) || struct.validator(value, ctx),\n\n    refiner: (value, ctx) =>\n      !hasOptional(ctx) || struct.refiner(value as Type, ctx),\n  });\n}\n\n/**\n * Assert that a value is valid according to a struct.\n *\n * It is similar to superstruct's mask function, but it does not ignore extra\n * properties.\n *\n * @param value - Value to check.\n * @param struct - Struct to validate the value against.\n * @param message - Error message to throw if the value is not valid.\n * @returns The value if it is valid.\n */\nexport function strictMask<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  message?: string,\n): Type {\n  assert(value, struct, message);\n  return value;\n}\n\n/**\n * Extracts the type from a struct definition and asserts that it matches the\n * expected type. If the types do not match, the type `never` is returned.\n *\n * @param StructType - The struct type to infer.\n * @param ExpectedType - The expected type.\n */\nexport type InferEquals<StructType extends Struct<any, any>, ExpectedType> =\n  Equals<Infer<StructType>, ExpectedType> extends true\n    ? Infer<StructType>\n    : never;\n\n/**\n * Create a custom union struct that uses a `selector` function for choosing\n * the validation path.\n *\n * @param selector - The selector function choosing the struct to validate with.\n * @returns The `superstruct` struct, which validates that the value satisfies\n * one of the structs.\n */\nexport function selectiveUnion<Selector extends (value: any) => AnyStruct>(\n  selector: Selector,\n): Struct<Infer<ReturnType<Selector>>, null> {\n  return new Struct({\n    type: 'union',\n    schema: null,\n\n    *entries(value: any, context: any): ReturnType<Struct['entries']> {\n      yield* selector(value).entries(value, context);\n    },\n\n    *refiner(value, context): ReturnType<Struct['refiner']> {\n      yield* selector(value).refiner(value, context);\n    },\n\n    coercer(value, context): ReturnType<Struct['coercer']> {\n      return selector(value).coercer(value, context);\n    },\n\n    validator(value, context): ReturnType<Struct['validator']> {\n      // This only validates the root of the struct, entries does the rest of\n      // the work.\n      return selector(value).validator(value, context);\n    },\n  });\n}\n"]}

dist/superstruct.d.cts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"superstruct.d.cts","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EAIP,8BAA8B;AAC/B,OAAO,KAAK,EACV,KAAK,EAEL,YAAY,EACZ,MAAM,EACN,WAAW,EACX,MAAM,EACN,QAAQ,EACR,SAAS,EACV,8BAA8B;AAE/B,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAgB;AAGtC,OAAO,CAAC,MAAM,mBAAmB,EAAE,OAAO,MAAM,CAAC;AAEjD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,OAAO,mBAAmB,CAAC;CAClC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CAAC,GAAG,EAAE,IAAI,IAAI;KAClC,CAAC,IAAI,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;CACxC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,CAAC,MAAM,SAAS,MAAM,IAAI,MAAM,CAC1D,MAAM,EACN,gBAAgB,CACjB,GACC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,SAAS,YAAY,IAAI,QAAQ,CAC5D,gBAAgB,CAAC,WAAW,CAAC;KAAG,CAAC,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAAC,CACzE,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,SAAS,YAAY,EAChD,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAEpC;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,MAAM,SAAS,YAAY,EAC9C,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAEpC;AAeD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EACxC,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAC3B,MAAM,CAAC,IAAI,GAAG,gBAAgB,EAAE,MAAM,CAAC,CAUzC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EACrC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,EAC5B,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAGN;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CACrB,UAAU,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EACnC,YAAY,IACV,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,SAAS,IAAI,GACpD,KAAK,CAAC,UAAU,CAAC,GACjB,KAAK,CAAC;AAEV;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,CAAC,KAAK,EAAE,GAAG,KAAK,SAAS,EACvE,QAAQ,EAAE,QAAQ,GACjB,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,CAuB3C"}
+{"version":3,"file":"superstruct.d.cts","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EAIP,8BAA8B;AAC/B,OAAO,KAAK,EACV,KAAK,EAEL,YAAY,EACZ,MAAM,EACN,WAAW,EACX,MAAM,EACN,QAAQ,EACR,SAAS,EACV,8BAA8B;AAE/B,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAgB;AAGtC,OAAO,CAAC,MAAM,mBAAmB,EAAE,OAAO,MAAM,CAAC;AAEjD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,OAAO,mBAAmB,CAAC;CAClC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CAAC,GAAG,EAAE,IAAI,IAAI;KAClC,CAAC,IAAI,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;CACxC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,CAAC,MAAM,SAAS,MAAM,IAAI,MAAM,CAC1D,MAAM,EACN,gBAAgB,CACjB,GACC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,SAAS,YAAY,IAAI,QAAQ,CAC5D,gBAAgB,CAAC,WAAW,CAAC;KAAG,CAAC,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAAC,CACzE,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,SAAS,YAAY,EAChD,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAEpC;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,MAAM,SAAS,YAAY,EAC9C,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAEpC;AAeD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EACxC,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAC3B,MAAM,CAAC,IAAI,GAAG,gBAAgB,EAAE,MAAM,CAAC,CAUzC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EACrC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,EAC5B,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAGN;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CAAC,UAAU,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,YAAY,IACvE,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,SAAS,IAAI,GAChD,KAAK,CAAC,UAAU,CAAC,GACjB,KAAK,CAAC;AAEZ;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,CAAC,KAAK,EAAE,GAAG,KAAK,SAAS,EACvE,QAAQ,EAAE,QAAQ,GACjB,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,CAuB3C"}

dist/superstruct.d.mts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"superstruct.d.mts","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EAIP,8BAA8B;AAC/B,OAAO,KAAK,EACV,KAAK,EAEL,YAAY,EACZ,MAAM,EACN,WAAW,EACX,MAAM,EACN,QAAQ,EACR,SAAS,EACV,8BAA8B;AAE/B,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAgB;AAGtC,OAAO,CAAC,MAAM,mBAAmB,EAAE,OAAO,MAAM,CAAC;AAEjD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,OAAO,mBAAmB,CAAC;CAClC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CAAC,GAAG,EAAE,IAAI,IAAI;KAClC,CAAC,IAAI,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;CACxC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,CAAC,MAAM,SAAS,MAAM,IAAI,MAAM,CAC1D,MAAM,EACN,gBAAgB,CACjB,GACC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,SAAS,YAAY,IAAI,QAAQ,CAC5D,gBAAgB,CAAC,WAAW,CAAC;KAAG,CAAC,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAAC,CACzE,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,SAAS,YAAY,EAChD,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAEpC;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,MAAM,SAAS,YAAY,EAC9C,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAEpC;AAeD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EACxC,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAC3B,MAAM,CAAC,IAAI,GAAG,gBAAgB,EAAE,MAAM,CAAC,CAUzC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EACrC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,EAC5B,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAGN;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CACrB,UAAU,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EACnC,YAAY,IACV,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,SAAS,IAAI,GACpD,KAAK,CAAC,UAAU,CAAC,GACjB,KAAK,CAAC;AAEV;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,CAAC,KAAK,EAAE,GAAG,KAAK,SAAS,EACvE,QAAQ,EAAE,QAAQ,GACjB,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,CAuB3C"}
+{"version":3,"file":"superstruct.d.mts","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EAIP,8BAA8B;AAC/B,OAAO,KAAK,EACV,KAAK,EAEL,YAAY,EACZ,MAAM,EACN,WAAW,EACX,MAAM,EACN,QAAQ,EACR,SAAS,EACV,8BAA8B;AAE/B,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAgB;AAGtC,OAAO,CAAC,MAAM,mBAAmB,EAAE,OAAO,MAAM,CAAC;AAEjD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,OAAO,mBAAmB,CAAC;CAClC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CAAC,GAAG,EAAE,IAAI,IAAI;KAClC,CAAC,IAAI,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;CACxC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,CAAC,MAAM,SAAS,MAAM,IAAI,MAAM,CAC1D,MAAM,EACN,gBAAgB,CACjB,GACC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,SAAS,YAAY,IAAI,QAAQ,CAC5D,gBAAgB,CAAC,WAAW,CAAC;KAAG,CAAC,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAAC,CACzE,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,SAAS,YAAY,EAChD,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAEpC;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,MAAM,SAAS,YAAY,EAC9C,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAEpC;AAeD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EACxC,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAC3B,MAAM,CAAC,IAAI,GAAG,gBAAgB,EAAE,MAAM,CAAC,CAUzC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EACrC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,EAC5B,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAGN;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CAAC,UAAU,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,YAAY,IACvE,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,SAAS,IAAI,GAChD,KAAK,CAAC,UAAU,CAAC,GACjB,KAAK,CAAC;AAEZ;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,CAAC,KAAK,EAAE,GAAG,KAAK,SAAS,EACvE,QAAQ,EAAE,QAAQ,GACjB,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,CAuB3C"}

dist/superstruct.mjs.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"superstruct.mjs","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,MAAM,EACN,MAAM,IAAI,QAAQ,EAClB,IAAI,IAAI,MAAM,EACf,8BAA8B;AAwD/B;;;;;;GAMG;AACH,MAAM,UAAU,MAAM,CACpB,MAAc;IAEd,OAAO,QAAQ,CAAC,MAAM,CAAQ,CAAC;AACjC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,IAAI,CAClB,MAAc;IAEd,OAAO,MAAM,CAAC,MAAM,CAAQ,CAAC;AAC/B,CAAC;AAED;;;;;GAKG;AACH,SAAS,WAAW,CAAC,GAAY;IAC/B,MAAM,QAAQ,GAAW,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvD,MAAM,MAAM,GAA4B,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAE1E,OAAO,QAAQ,IAAI,MAAM,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAC3B,MAA4B;IAE5B,OAAO,IAAI,MAAM,CAAC;QAChB,GAAG,MAAM;QAET,SAAS,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACxB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC;QAEnD,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACtB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAa,EAAE,GAAG,CAAC;KAC1D,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,UAAU,CACxB,KAAc,EACd,MAA4B,EAC5B,OAAgB;IAEhB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,KAAK,CAAC;AACf,CAAC;AAgBD;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAC5B,QAAkB;IAElB,OAAO,IAAI,MAAM,CAAC;QAChB,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,IAAI;QAEZ,CAAC,OAAO,CAAC,KAAU,EAAE,OAAY;YAC/B,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO;YACrB,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,OAAO,CAAC,KAAK,EAAE,OAAO;YACpB,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,SAAS,CAAC,KAAK,EAAE,OAAO;YACtB,uEAAuE;YACvE,YAAY;YACZ,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACnD,CAAC;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["import {\n  Struct,\n  assert,\n  object as stObject,\n  type as stType,\n} from '@metamask/superstruct';\nimport type {\n  Infer,\n  Context,\n  ObjectSchema,\n  OmitBy,\n  Optionalize,\n  PickBy,\n  Simplify,\n  AnyStruct,\n} from '@metamask/superstruct';\n\nimport type { Equals } from './types';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ndeclare const ExactOptionalSymbol: unique symbol;\n\nexport type ExactOptionalTag = {\n  type: typeof ExactOptionalSymbol;\n};\n\n/**\n * Exclude type `Type` from the properties of `Obj`.\n *\n * ```ts\n * type Foo = { a: string | null; b: number };\n * type Bar = ExcludeType<Foo, null>;\n * // Bar = { a: string, b: number }\n * ```\n */\nexport type ExcludeType<Obj, Type> = {\n  [K in keyof Obj]: Exclude<Obj[K], Type>;\n};\n\n/**\n * Make optional all properties that have the `ExactOptionalTag` type.\n *\n * ```ts\n * type Foo = { a: string | ExactOptionalTag; b: number};\n * type Bar = ExactOptionalize<Foo>;\n * // Bar = { a?: string; b: number}\n * ```\n */\nexport type ExactOptionalize<Schema extends object> = OmitBy<\n  Schema,\n  ExactOptionalTag\n> &\n  Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;\n\n/**\n * Infer a type from an superstruct object schema.\n */\nexport type ObjectType<Schema extends ObjectSchema> = Simplify<\n  ExactOptionalize<Optionalize<{ [K in keyof Schema]: Infer<Schema[K]> }>>\n>;\n\n/**\n * Change the return type of a superstruct's `object` function to support\n * exact optional properties.\n *\n * @param schema - The object schema.\n * @returns A struct representing an object with a known set of properties.\n */\nexport function object<Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>, Schema> {\n  return stObject(schema) as any;\n}\n\n/**\n * Change the return type of a superstruct's `type` function to support\n * exact optional properties.\n *\n * @param schema - The object schema.\n * @returns A struct representing an object with a known set of properties\n * and ignore unknown properties.\n */\nexport function type<Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>, Schema> {\n  return stType(schema) as any;\n}\n\n/**\n * Check if the current property is present in its parent object.\n *\n * @param ctx - The context to check.\n * @returns `true` if the property is present, `false` otherwise.\n */\nfunction hasOptional(ctx: Context): boolean {\n  const property: string = ctx.path[ctx.path.length - 1];\n  const parent: Record<string, unknown> = ctx.branch[ctx.branch.length - 2];\n\n  return property in parent;\n}\n\n/**\n * Augment a struct to allow exact-optional values. Exact-optional values can\n * be omitted but cannot be `undefined`.\n *\n * ```ts\n * const foo = object({ bar: exactOptional(string()) });\n * type Foo = Infer<typeof foo>;\n * // Foo = { bar?: string }\n * ```\n *\n * @param struct - The struct to augment.\n * @returns The augmented struct.\n */\nexport function exactOptional<Type, Schema>(\n  struct: Struct<Type, Schema>,\n): Struct<Type | ExactOptionalTag, Schema> {\n  return new Struct({\n    ...struct,\n\n    validator: (value, ctx) =>\n      !hasOptional(ctx) || struct.validator(value, ctx),\n\n    refiner: (value, ctx) =>\n      !hasOptional(ctx) || struct.refiner(value as Type, ctx),\n  });\n}\n\n/**\n * Assert that a value is valid according to a struct.\n *\n * It is similar to superstruct's mask function, but it does not ignore extra\n * properties.\n *\n * @param value - Value to check.\n * @param struct - Struct to validate the value against.\n * @param message - Error message to throw if the value is not valid.\n * @returns The value if it is valid.\n */\nexport function strictMask<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  message?: string,\n): Type {\n  assert(value, struct, message);\n  return value;\n}\n\n/**\n * Extracts the type from a struct definition and asserts that it matches the\n * expected type. If the types do not match, the type `never` is returned.\n *\n * @param StructType - The struct type to infer.\n * @param ExpectedType - The expected type.\n */\nexport type InferEquals<\n  StructType extends Struct<any, any>,\n  ExpectedType,\n> = Equals<Infer<StructType>, ExpectedType> extends true\n  ? Infer<StructType>\n  : never;\n\n/**\n * Create a custom union struct that uses a `selector` function for choosing\n * the validation path.\n *\n * @param selector - The selector function choosing the struct to validate with.\n * @returns The `superstruct` struct, which validates that the value satisfies\n * one of the structs.\n */\nexport function selectiveUnion<Selector extends (value: any) => AnyStruct>(\n  selector: Selector,\n): Struct<Infer<ReturnType<Selector>>, null> {\n  return new Struct({\n    type: 'union',\n    schema: null,\n\n    *entries(value: any, context: any): ReturnType<Struct['entries']> {\n      yield* selector(value).entries(value, context);\n    },\n\n    *refiner(value, context): ReturnType<Struct['refiner']> {\n      yield* selector(value).refiner(value, context);\n    },\n\n    coercer(value, context): ReturnType<Struct['coercer']> {\n      return selector(value).coercer(value, context);\n    },\n\n    validator(value, context): ReturnType<Struct['validator']> {\n      // This only validates the root of the struct, entries does the rest of\n      // the work.\n      return selector(value).validator(value, context);\n    },\n  });\n}\n"]}
+{"version":3,"file":"superstruct.mjs","sourceRoot":"","sources":["../src/superstruct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,MAAM,EACN,MAAM,IAAI,QAAQ,EAClB,IAAI,IAAI,MAAM,EACf,8BAA8B;AAwD/B;;;;;;GAMG;AACH,MAAM,UAAU,MAAM,CACpB,MAAc;IAEd,OAAO,QAAQ,CAAC,MAAM,CAAQ,CAAC;AACjC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,IAAI,CAClB,MAAc;IAEd,OAAO,MAAM,CAAC,MAAM,CAAQ,CAAC;AAC/B,CAAC;AAED;;;;;GAKG;AACH,SAAS,WAAW,CAAC,GAAY;IAC/B,MAAM,QAAQ,GAAW,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvD,MAAM,MAAM,GAA4B,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAE1E,OAAO,QAAQ,IAAI,MAAM,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAC3B,MAA4B;IAE5B,OAAO,IAAI,MAAM,CAAC;QAChB,GAAG,MAAM;QAET,SAAS,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACxB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC;QAEnD,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACtB,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAa,EAAE,GAAG,CAAC;KAC1D,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,UAAU,CACxB,KAAc,EACd,MAA4B,EAC5B,OAAgB;IAEhB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,KAAK,CAAC;AACf,CAAC;AAcD;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAC5B,QAAkB;IAElB,OAAO,IAAI,MAAM,CAAC;QAChB,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,IAAI;QAEZ,CAAC,OAAO,CAAC,KAAU,EAAE,OAAY;YAC/B,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO;YACrB,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,OAAO,CAAC,KAAK,EAAE,OAAO;YACpB,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,SAAS,CAAC,KAAK,EAAE,OAAO;YACtB,uEAAuE;YACvE,YAAY;YACZ,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACnD,CAAC;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["import {\n  Struct,\n  assert,\n  object as stObject,\n  type as stType,\n} from '@metamask/superstruct';\nimport type {\n  Infer,\n  Context,\n  ObjectSchema,\n  OmitBy,\n  Optionalize,\n  PickBy,\n  Simplify,\n  AnyStruct,\n} from '@metamask/superstruct';\n\nimport type { Equals } from './types';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ndeclare const ExactOptionalSymbol: unique symbol;\n\nexport type ExactOptionalTag = {\n  type: typeof ExactOptionalSymbol;\n};\n\n/**\n * Exclude type `Type` from the properties of `Obj`.\n *\n * ```ts\n * type Foo = { a: string | null; b: number };\n * type Bar = ExcludeType<Foo, null>;\n * // Bar = { a: string, b: number }\n * ```\n */\nexport type ExcludeType<Obj, Type> = {\n  [K in keyof Obj]: Exclude<Obj[K], Type>;\n};\n\n/**\n * Make optional all properties that have the `ExactOptionalTag` type.\n *\n * ```ts\n * type Foo = { a: string | ExactOptionalTag; b: number};\n * type Bar = ExactOptionalize<Foo>;\n * // Bar = { a?: string; b: number}\n * ```\n */\nexport type ExactOptionalize<Schema extends object> = OmitBy<\n  Schema,\n  ExactOptionalTag\n> &\n  Partial<ExcludeType<PickBy<Schema, ExactOptionalTag>, ExactOptionalTag>>;\n\n/**\n * Infer a type from an superstruct object schema.\n */\nexport type ObjectType<Schema extends ObjectSchema> = Simplify<\n  ExactOptionalize<Optionalize<{ [K in keyof Schema]: Infer<Schema[K]> }>>\n>;\n\n/**\n * Change the return type of a superstruct's `object` function to support\n * exact optional properties.\n *\n * @param schema - The object schema.\n * @returns A struct representing an object with a known set of properties.\n */\nexport function object<Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>, Schema> {\n  return stObject(schema) as any;\n}\n\n/**\n * Change the return type of a superstruct's `type` function to support\n * exact optional properties.\n *\n * @param schema - The object schema.\n * @returns A struct representing an object with a known set of properties\n * and ignore unknown properties.\n */\nexport function type<Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>, Schema> {\n  return stType(schema) as any;\n}\n\n/**\n * Check if the current property is present in its parent object.\n *\n * @param ctx - The context to check.\n * @returns `true` if the property is present, `false` otherwise.\n */\nfunction hasOptional(ctx: Context): boolean {\n  const property: string = ctx.path[ctx.path.length - 1];\n  const parent: Record<string, unknown> = ctx.branch[ctx.branch.length - 2];\n\n  return property in parent;\n}\n\n/**\n * Augment a struct to allow exact-optional values. Exact-optional values can\n * be omitted but cannot be `undefined`.\n *\n * ```ts\n * const foo = object({ bar: exactOptional(string()) });\n * type Foo = Infer<typeof foo>;\n * // Foo = { bar?: string }\n * ```\n *\n * @param struct - The struct to augment.\n * @returns The augmented struct.\n */\nexport function exactOptional<Type, Schema>(\n  struct: Struct<Type, Schema>,\n): Struct<Type | ExactOptionalTag, Schema> {\n  return new Struct({\n    ...struct,\n\n    validator: (value, ctx) =>\n      !hasOptional(ctx) || struct.validator(value, ctx),\n\n    refiner: (value, ctx) =>\n      !hasOptional(ctx) || struct.refiner(value as Type, ctx),\n  });\n}\n\n/**\n * Assert that a value is valid according to a struct.\n *\n * It is similar to superstruct's mask function, but it does not ignore extra\n * properties.\n *\n * @param value - Value to check.\n * @param struct - Struct to validate the value against.\n * @param message - Error message to throw if the value is not valid.\n * @returns The value if it is valid.\n */\nexport function strictMask<Type, Schema>(\n  value: unknown,\n  struct: Struct<Type, Schema>,\n  message?: string,\n): Type {\n  assert(value, struct, message);\n  return value;\n}\n\n/**\n * Extracts the type from a struct definition and asserts that it matches the\n * expected type. If the types do not match, the type `never` is returned.\n *\n * @param StructType - The struct type to infer.\n * @param ExpectedType - The expected type.\n */\nexport type InferEquals<StructType extends Struct<any, any>, ExpectedType> =\n  Equals<Infer<StructType>, ExpectedType> extends true\n    ? Infer<StructType>\n    : never;\n\n/**\n * Create a custom union struct that uses a `selector` function for choosing\n * the validation path.\n *\n * @param selector - The selector function choosing the struct to validate with.\n * @returns The `superstruct` struct, which validates that the value satisfies\n * one of the structs.\n */\nexport function selectiveUnion<Selector extends (value: any) => AnyStruct>(\n  selector: Selector,\n): Struct<Infer<ReturnType<Selector>>, null> {\n  return new Struct({\n    type: 'union',\n    schema: null,\n\n    *entries(value: any, context: any): ReturnType<Struct['entries']> {\n      yield* selector(value).entries(value, context);\n    },\n\n    *refiner(value, context): ReturnType<Struct['refiner']> {\n      yield* selector(value).refiner(value, context);\n    },\n\n    coercer(value, context): ReturnType<Struct['coercer']> {\n      return selector(value).coercer(value, context);\n    },\n\n    validator(value, context): ReturnType<Struct['validator']> {\n      // This only validates the root of the struct, entries does the rest of\n      // the work.\n      return selector(value).validator(value, context);\n    },\n  });\n}\n"]}

dist/types.cjs.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"types.cjs","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AAAA,uDAA2D;AAC3D,2CAAgD;AAEhD;;GAEG;AACU,QAAA,UAAU,GAAG,IAAA,qBAAa,EACrC,QAAQ,EACR,yEAAyE,CAC1E,CAAC;AACF;;GAEG;AACU,QAAA,eAAe,GAAG,kBAAU,CAAC,CAAC,oCAAoC;AAG/E;;;;;GAKG;AACU,QAAA,SAAS,GAAG,IAAA,oBAAM,EAAS,KAAK,EAAE,CAAC,KAAc,EAAE,EAAE;IAChE,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,KAAe,CAAC,CAAC;QACrC,OAAO,GAAG,CAAC,QAAQ,KAAK,OAAO,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC;IAC/D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC,CAAC;AAEH;;GAEG;AACU,QAAA,kBAAkB,GAAG,IAAA,qBAAa,EAC7C,cAAc,EACd,gBAAgB,CACjB,CAAC","sourcesContent":["import { define, type Infer } from '@metamask/superstruct';\nimport { definePattern } from '@metamask/utils';\n\n/**\n * UUIDv4 struct.\n */\nexport const UuidStruct = definePattern(\n  'UuidV4',\n  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu,\n);\n/**\n * Account ID (UUIDv4).\n */\nexport const AccountIdStruct = UuidStruct; // Alias for better naming purposes.\nexport type AccountId = Infer<typeof AccountIdStruct>; // Alias for better naming purposes.\n\n/**\n * Validates if a given value is a valid URL.\n *\n * @param value - The value to be validated.\n * @returns A boolean indicating if the value is a valid URL.\n */\nexport const UrlStruct = define<string>('Url', (value: unknown) => {\n  try {\n    const url = new URL(value as string);\n    return url.protocol === 'http:' || url.protocol === 'https:';\n  } catch {\n    return false;\n  }\n});\n\n/**\n * A string which contains a positive float number.\n */\nexport const StringNumberStruct = definePattern(\n  'StringNumber',\n  /^\\d+(\\.\\d+)?$/u,\n);\nexport type StringNumber = Infer<typeof StringNumberStruct>;\n\n/**\n * This is a helper type used by the {@link Equals} type.\n */\ntype EqualsHelper<Type> = <Dummy>() => Dummy extends Type ? 1 : 2;\n\n/**\n * A utility type that checks whether two types are exactly the same.\n *\n * This type evaluates to `true` if `TypeA` and `TypeB` are identical,\n * otherwise it evaluates to `false`.\n *\n * @template TypeA - The first type to compare.\n * @template TypeB - The second type to compare.\n *\n * @example\n * ```ts\n * // Example usage:\n * type Test1 = Equals<number, number>; // true\n * type Test2 = Equals<number, string>; // false\n * type Test3 = Equals<{ a: string }, { a: string }>; // true\n * type Test4 = Equals<{ a: string }, { a: number }>; // false\n * ```\n */\nexport type Equals<TypeA, TypeB> =\n  EqualsHelper<TypeA> extends EqualsHelper<TypeB> ? true : false;\n"]}
+{"version":3,"file":"types.cjs","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AAAA,uDAA+C;AAE/C,2CAAgD;AAEhD;;GAEG;AACU,QAAA,UAAU,GAAG,IAAA,qBAAa,EACrC,QAAQ,EACR,yEAAyE,CAC1E,CAAC;AACF;;GAEG;AACU,QAAA,eAAe,GAAG,kBAAU,CAAC,CAAC,oCAAoC;AAG/E;;;;;GAKG;AACU,QAAA,SAAS,GAAG,IAAA,oBAAM,EAAS,KAAK,EAAE,CAAC,KAAc,EAAE,EAAE;IAChE,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,KAAe,CAAC,CAAC;QACrC,OAAO,GAAG,CAAC,QAAQ,KAAK,OAAO,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC;IAC/D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC,CAAC;AAEH;;GAEG;AACU,QAAA,kBAAkB,GAAG,IAAA,qBAAa,EAC7C,cAAc,EACd,gBAAgB,CACjB,CAAC","sourcesContent":["import { define } from '@metamask/superstruct';\nimport type { Infer } from '@metamask/superstruct';\nimport { definePattern } from '@metamask/utils';\n\n/**\n * UUIDv4 struct.\n */\nexport const UuidStruct = definePattern(\n  'UuidV4',\n  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu,\n);\n/**\n * Account ID (UUIDv4).\n */\nexport const AccountIdStruct = UuidStruct; // Alias for better naming purposes.\nexport type AccountId = Infer<typeof AccountIdStruct>; // Alias for better naming purposes.\n\n/**\n * Validates if a given value is a valid URL.\n *\n * @param value - The value to be validated.\n * @returns A boolean indicating if the value is a valid URL.\n */\nexport const UrlStruct = define<string>('Url', (value: unknown) => {\n  try {\n    const url = new URL(value as string);\n    return url.protocol === 'http:' || url.protocol === 'https:';\n  } catch {\n    return false;\n  }\n});\n\n/**\n * A string which contains a positive float number.\n */\nexport const StringNumberStruct = definePattern(\n  'StringNumber',\n  /^\\d+(\\.\\d+)?$/u,\n);\nexport type StringNumber = Infer<typeof StringNumberStruct>;\n\n/**\n * This is a helper type used by the {@link Equals} type.\n */\ntype EqualsHelper<Type> = <Dummy>() => Dummy extends Type ? 1 : 2;\n\n/**\n * A utility type that checks whether two types are exactly the same.\n *\n * This type evaluates to `true` if `TypeA` and `TypeB` are identical,\n * otherwise it evaluates to `false`.\n *\n * @template TypeA - The first type to compare.\n * @template TypeB - The second type to compare.\n *\n * @example\n * ```ts\n * // Example usage:\n * type Test1 = Equals<number, number>; // true\n * type Test2 = Equals<number, string>; // false\n * type Test3 = Equals<{ a: string }, { a: string }>; // true\n * type Test4 = Equals<{ a: string }, { a: number }>; // false\n * ```\n */\nexport type Equals<TypeA, TypeB> =\n  EqualsHelper<TypeA> extends EqualsHelper<TypeB> ? true : false;\n"]}

dist/types.d.cts

@@ -1,2 +0,2 @@
-import { type Infer } from "@metamask/superstruct";
+import type { Infer } from "@metamask/superstruct";
 /**
@@ -3,0 +3,0 @@ * UUIDv4 struct.

dist/types.d.cts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"types.d.cts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,KAAK,EAAE,8BAA8B;AAG3D;;GAEG;AACH,eAAO,MAAM,UAAU,sDAGtB,CAAC;AACF;;GAEG;AACH,eAAO,MAAM,eAAe,sDAAa,CAAC;AAC1C,MAAM,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,sDAOpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB,sDAG9B,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE5D;;GAEG;AACH,KAAK,YAAY,CAAC,IAAI,IAAI,CAAC,KAAK,OAAO,KAAK,SAAS,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,MAAM,CAAC,KAAK,EAAE,KAAK,IAC7B,YAAY,CAAC,KAAK,CAAC,SAAS,YAAY,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC"}
+{"version":3,"file":"types.d.cts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,8BAA8B;AAGnD;;GAEG;AACH,eAAO,MAAM,UAAU,sDAGtB,CAAC;AACF;;GAEG;AACH,eAAO,MAAM,eAAe,sDAAa,CAAC;AAC1C,MAAM,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,sDAOpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB,sDAG9B,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE5D;;GAEG;AACH,KAAK,YAAY,CAAC,IAAI,IAAI,CAAC,KAAK,OAAO,KAAK,SAAS,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,MAAM,CAAC,KAAK,EAAE,KAAK,IAC7B,YAAY,CAAC,KAAK,CAAC,SAAS,YAAY,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC"}

dist/types.d.mts

@@ -1,2 +0,2 @@
-import { type Infer } from "@metamask/superstruct";
+import type { Infer } from "@metamask/superstruct";
 /**
@@ -3,0 +3,0 @@ * UUIDv4 struct.

dist/types.d.mts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"types.d.mts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,KAAK,EAAE,8BAA8B;AAG3D;;GAEG;AACH,eAAO,MAAM,UAAU,sDAGtB,CAAC;AACF;;GAEG;AACH,eAAO,MAAM,eAAe,sDAAa,CAAC;AAC1C,MAAM,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,sDAOpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB,sDAG9B,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE5D;;GAEG;AACH,KAAK,YAAY,CAAC,IAAI,IAAI,CAAC,KAAK,OAAO,KAAK,SAAS,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,MAAM,CAAC,KAAK,EAAE,KAAK,IAC7B,YAAY,CAAC,KAAK,CAAC,SAAS,YAAY,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC"}
+{"version":3,"file":"types.d.mts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,8BAA8B;AAGnD;;GAEG;AACH,eAAO,MAAM,UAAU,sDAGtB,CAAC;AACF;;GAEG;AACH,eAAO,MAAM,eAAe,sDAAa,CAAC;AAC1C,MAAM,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,sDAOpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB,sDAG9B,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE5D;;GAEG;AACH,KAAK,YAAY,CAAC,IAAI,IAAI,CAAC,KAAK,OAAO,KAAK,SAAS,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,MAAM,CAAC,KAAK,EAAE,KAAK,IAC7B,YAAY,CAAC,KAAK,CAAC,SAAS,YAAY,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC"}

dist/types.mjs.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"types.mjs","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAc,8BAA8B;AAC3D,OAAO,EAAE,aAAa,EAAE,wBAAwB;AAEhD;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,aAAa,CACrC,QAAQ,EACR,yEAAyE,CAC1E,CAAC;AACF;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC,CAAC,oCAAoC;AAG/E;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAS,KAAK,EAAE,CAAC,KAAc,EAAE,EAAE;IAChE,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,KAAe,CAAC,CAAC;QACrC,OAAO,GAAG,CAAC,QAAQ,KAAK,OAAO,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC;IAC/D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,aAAa,CAC7C,cAAc,EACd,gBAAgB,CACjB,CAAC","sourcesContent":["import { define, type Infer } from '@metamask/superstruct';\nimport { definePattern } from '@metamask/utils';\n\n/**\n * UUIDv4 struct.\n */\nexport const UuidStruct = definePattern(\n  'UuidV4',\n  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu,\n);\n/**\n * Account ID (UUIDv4).\n */\nexport const AccountIdStruct = UuidStruct; // Alias for better naming purposes.\nexport type AccountId = Infer<typeof AccountIdStruct>; // Alias for better naming purposes.\n\n/**\n * Validates if a given value is a valid URL.\n *\n * @param value - The value to be validated.\n * @returns A boolean indicating if the value is a valid URL.\n */\nexport const UrlStruct = define<string>('Url', (value: unknown) => {\n  try {\n    const url = new URL(value as string);\n    return url.protocol === 'http:' || url.protocol === 'https:';\n  } catch {\n    return false;\n  }\n});\n\n/**\n * A string which contains a positive float number.\n */\nexport const StringNumberStruct = definePattern(\n  'StringNumber',\n  /^\\d+(\\.\\d+)?$/u,\n);\nexport type StringNumber = Infer<typeof StringNumberStruct>;\n\n/**\n * This is a helper type used by the {@link Equals} type.\n */\ntype EqualsHelper<Type> = <Dummy>() => Dummy extends Type ? 1 : 2;\n\n/**\n * A utility type that checks whether two types are exactly the same.\n *\n * This type evaluates to `true` if `TypeA` and `TypeB` are identical,\n * otherwise it evaluates to `false`.\n *\n * @template TypeA - The first type to compare.\n * @template TypeB - The second type to compare.\n *\n * @example\n * ```ts\n * // Example usage:\n * type Test1 = Equals<number, number>; // true\n * type Test2 = Equals<number, string>; // false\n * type Test3 = Equals<{ a: string }, { a: string }>; // true\n * type Test4 = Equals<{ a: string }, { a: number }>; // false\n * ```\n */\nexport type Equals<TypeA, TypeB> =\n  EqualsHelper<TypeA> extends EqualsHelper<TypeB> ? true : false;\n"]}
+{"version":3,"file":"types.mjs","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,8BAA8B;AAE/C,OAAO,EAAE,aAAa,EAAE,wBAAwB;AAEhD;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,aAAa,CACrC,QAAQ,EACR,yEAAyE,CAC1E,CAAC;AACF;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC,CAAC,oCAAoC;AAG/E;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAS,KAAK,EAAE,CAAC,KAAc,EAAE,EAAE;IAChE,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,KAAe,CAAC,CAAC;QACrC,OAAO,GAAG,CAAC,QAAQ,KAAK,OAAO,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC;IAC/D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,aAAa,CAC7C,cAAc,EACd,gBAAgB,CACjB,CAAC","sourcesContent":["import { define } from '@metamask/superstruct';\nimport type { Infer } from '@metamask/superstruct';\nimport { definePattern } from '@metamask/utils';\n\n/**\n * UUIDv4 struct.\n */\nexport const UuidStruct = definePattern(\n  'UuidV4',\n  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu,\n);\n/**\n * Account ID (UUIDv4).\n */\nexport const AccountIdStruct = UuidStruct; // Alias for better naming purposes.\nexport type AccountId = Infer<typeof AccountIdStruct>; // Alias for better naming purposes.\n\n/**\n * Validates if a given value is a valid URL.\n *\n * @param value - The value to be validated.\n * @returns A boolean indicating if the value is a valid URL.\n */\nexport const UrlStruct = define<string>('Url', (value: unknown) => {\n  try {\n    const url = new URL(value as string);\n    return url.protocol === 'http:' || url.protocol === 'https:';\n  } catch {\n    return false;\n  }\n});\n\n/**\n * A string which contains a positive float number.\n */\nexport const StringNumberStruct = definePattern(\n  'StringNumber',\n  /^\\d+(\\.\\d+)?$/u,\n);\nexport type StringNumber = Infer<typeof StringNumberStruct>;\n\n/**\n * This is a helper type used by the {@link Equals} type.\n */\ntype EqualsHelper<Type> = <Dummy>() => Dummy extends Type ? 1 : 2;\n\n/**\n * A utility type that checks whether two types are exactly the same.\n *\n * This type evaluates to `true` if `TypeA` and `TypeB` are identical,\n * otherwise it evaluates to `false`.\n *\n * @template TypeA - The first type to compare.\n * @template TypeB - The second type to compare.\n *\n * @example\n * ```ts\n * // Example usage:\n * type Test1 = Equals<number, number>; // true\n * type Test2 = Equals<number, string>; // false\n * type Test3 = Equals<{ a: string }, { a: string }>; // true\n * type Test4 = Equals<{ a: string }, { a: number }>; // false\n * ```\n */\nexport type Equals<TypeA, TypeB> =\n  EqualsHelper<TypeA> extends EqualsHelper<TypeB> ? true : false;\n"]}

dist/typing.cjs

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expectTrue = expectTrue;
+exports.expectTrue = void 0;
 /**
@@ -20,2 +20,3 @@ * Assert that a type extends `true`. It can be used, for example, to assert
 }
+exports.expectTrue = expectTrue;
 //# sourceMappingURL=typing.cjs.map

dist/typing.cjs.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"typing.cjs","sourceRoot":"","sources":["../src/typing.ts"],"names":[],"mappings":";;AAoCA,gCAEC;AAfD;;;;;;;;;;;GAWG;AACH,6DAA6D;AAC7D,SAAgB,UAAU;IACxB,sBAAsB;AACxB,CAAC","sourcesContent":["/**\n * Omit keys from a union type.\n *\n * The normal `Omit` type does not distribute over unions. So we use this\n * workaround that applies `Omit` to each member of the union.\n *\n * See: <https://github.com/microsoft/TypeScript/issues/31501#issuecomment-1280579305>\n */\nexport type OmitUnion<Type, Key extends keyof any> = Type extends any\n  ? Omit<Type, Key>\n  : never;\n\n/**\n * Type that resolves to `true` if `Child` extends `Base`, otherwise `false`.\n *\n * @example\n * ```ts\n * type A = Extends<{a: string, b: string}, {a: string}>; // true\n * type B = Extends<{a: string}, {a: string, b: string}>; // false\n * ```\n */\nexport type Extends<Child, Base> = Child extends Base ? true : false;\n\n/**\n * Assert that a type extends `true`. It can be used, for example, to assert\n * that a given type extends another type.\n *\n * @example\n * ```ts\n * expectTrue<Extends<{a: string, b: string}, {a: string}>>(); // Ok\n * expectTrue<Extends<{a: string}, {a: string, b: string}>>(); // Error\n * ```\n *\n * This function follows the naming pattern used on `tsd`.\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function expectTrue<Type extends true>(): void {\n  // Intentionally empty\n}\n"]}
+{"version":3,"file":"typing.cjs","sourceRoot":"","sources":["../src/typing.ts"],"names":[],"mappings":";;;AAuBA;;;;;;;;;;;GAWG;AACH,6DAA6D;AAC7D,SAAgB,UAAU;IACxB,sBAAsB;AACxB,CAAC;AAFD,gCAEC","sourcesContent":["/**\n * Omit keys from a union type.\n *\n * The normal `Omit` type does not distribute over unions. So we use this\n * workaround that applies `Omit` to each member of the union.\n *\n * See: <https://github.com/microsoft/TypeScript/issues/31501#issuecomment-1280579305>\n */\nexport type OmitUnion<Type, Key extends keyof any> = Type extends any\n  ? Omit<Type, Key>\n  : never;\n\n/**\n * Type that resolves to `true` if `Child` extends `Base`, otherwise `false`.\n *\n * @example\n * ```ts\n * type A = Extends<{a: string, b: string}, {a: string}>; // true\n * type B = Extends<{a: string}, {a: string, b: string}>; // false\n * ```\n */\nexport type Extends<Child, Base> = Child extends Base ? true : false;\n\n/**\n * Assert that a type extends `true`. It can be used, for example, to assert\n * that a given type extends another type.\n *\n * @example\n * ```ts\n * expectTrue<Extends<{a: string, b: string}, {a: string}>>(); // Ok\n * expectTrue<Extends<{a: string}, {a: string, b: string}>>(); // Error\n * ```\n *\n * This function follows the naming pattern used on `tsd`.\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function expectTrue<Type extends true>(): void {\n  // Intentionally empty\n}\n"]}

package.json

 {
   "name": "@metamask/keyring-utils",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "MetaMask Keyring utils",
   "keywords": [
-    "metamask",
-    "keyring"
+    "keyring",
+    "metamask"
   ],
@@ -13,2 +13,3 @@ "homepage": "https://github.com/MetaMask/accounts/tree/main/packages/keyring-utils#readme",
   },
+  "license": "MIT",
   "repository": {
@@ -18,2 +19,8 @@ "type": "git",
   },
+  "files": [
+    "dist/"
+  ],
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.cts",
   "exports": {
@@ -29,11 +36,12 @@ ".": {
       }
-    }
+    },
+    "./package.json": "./package.json"
   },
-  "main": "./dist/index.cjs",
-  "types": "./dist/index.d.cts",
-  "files": [
-    "dist/"
-  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "scripts": {
-    "build": "ts-bridge --project tsconfig.build.json --no-references",
+    "build": "ts-bridge --project tsconfig.build.json --verbose --clean --no-references",
+    "build:all": "ts-bridge --project tsconfig.build.json --verbose --clean",
     "build:clean": "yarn build --clean",
@@ -44,7 +52,9 @@ "build:docs": "typedoc",
     "publish:preview": "yarn npm publish --tag preview",
+    "since-latest-release": "../../scripts/since-latest-release.sh",
     "test": "yarn test:source && yarn test:types",
-    "test:clean": "jest --clearCache",
-    "test:source": "jest && jest-it-up",
+    "test:clean": "NODE_OPTIONS=--experimental-vm-modules jest --clearCache",
+    "test:source": "NODE_OPTIONS=--experimental-vm-modules jest --reporters=jest-silent-reporter",
     "test:types": "../../scripts/tsd-test.sh ./src",
-    "test:watch": "jest --watch"
+    "test:verbose": "NODE_OPTIONS=--experimental-vm-modules jest --verbose",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch"
   },
@@ -54,3 +64,3 @@ "dependencies": {
     "@metamask/superstruct": "^3.1.0",
-    "@metamask/utils": "^11.1.0",
+    "@metamask/utils": "^11.11.0",
     "bitcoin-address-validation": "^2.2.3"
@@ -61,3 +71,3 @@ },
     "@lavamoat/preinstall-always-fail": "^2.1.0",
-    "@metamask/auto-changelog": "^3.4.4",
+    "@metamask/auto-changelog": "^6.1.0",
     "@ts-bridge/cli": "^0.6.3",
@@ -75,11 +85,13 @@ "@types/jest": "^29.5.12",
     "typedoc": "^0.25.13",
-    "typescript": "~5.6.3"
+    "typescript": "~5.3.3"
   },
+  "tsd": {
+    "compilerOptions": {
+      "composite": "false"
+    },
+    "directory": "src"
+  },
   "engines": {
     "node": "^18.18 || >=20"
   },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
   "lavamoat": {
@@ -89,9 +101,3 @@ "allowScripts": {
     }
-  },
-  "tsd": {
-    "directory": "src",
-    "compilerOptions": {
-      "composite": "false"
-    }
   }
 }

Fixed alerts

No License Found

License

License information could not be found.

Improved metrics

Total package byte prevSize

145407

5.8%

Number of package files

76

1.33%

Number of low license alerts

0

-100%

Lines of code

495

0.61%

Dependency changes

• Updated

  @metamask/utils@^11.11.0