@metamask/utils 8.4.0 → 8.5.0

package/dist/keyring.d.mts

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

package/dist/keyring.d.mts.map

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

package/dist/keyring.mjs

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

package/dist/keyring.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"keyring.mjs","sourceRoot":"","sources":["../src/keyring.ts"],"names":[],"mappings":"","sourcesContent":["import type { TypedTransaction, TxData } from '@ethereumjs/tx';\n\nimport type { Eip1024EncryptedData } from './encryption-types';\nimport type { Hex } from './hex';\nimport type { Json } from './json';\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<State extends Json> = {\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<State>;\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<State extends Json> = {\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<State>;\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: State): 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<TxData>;\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 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: 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  generateRandomMnemonic?(): void;\n\n  /**\n   * Destroy the keyring.\n   */\n  destroy?(): Promise<void>;\n};\n"]}

package/dist/logging.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModuleLogger = exports.createProjectLogger = void 0;
+const debug_1 = __importDefault(require("debug"));
+const globalLogger = (0, debug_1.default)('metamask');
+/**
+ * Creates a logger via the `debug` library whose log messages will be tagged
+ * using the name of your project. By default, such messages will be
+ * suppressed, but you can reveal them by setting the `DEBUG` environment
+ * variable to `metamask:<projectName>`. You can also set this variable to
+ * `metamask:*` if you want to see log messages from all MetaMask projects that
+ * are also using this function to create their loggers.
+ *
+ * @param projectName - The name of your project. This should be the name of
+ * your NPM package if you're developing one.
+ * @returns An instance of `debug`.
+ */
+function createProjectLogger(projectName) {
+    return globalLogger.extend(projectName);
+}
+exports.createProjectLogger = createProjectLogger;
+/**
+ * Creates a logger via the `debug` library which is derived from the logger for
+ * the whole project whose log messages will be tagged using the name of your
+ * module. By default, such messages will be suppressed, but you can reveal them
+ * by setting the `DEBUG` environment variable to
+ * `metamask:<projectName>:<moduleName>`. You can also set this variable to
+ * `metamask:<projectName>:*` if you want to see log messages from the project,
+ * or `metamask:*` if you want to see log messages from all MetaMask projects.
+ *
+ * @param projectLogger - The logger created via {@link createProjectLogger}.
+ * @param moduleName - The name of your module. You could use the name of the
+ * file where you're using this logger or some other name.
+ * @returns An instance of `debug`.
+ */
+function createModuleLogger(projectLogger, moduleName) {
+    return projectLogger.extend(moduleName);
+}
+exports.createModuleLogger = createModuleLogger;
+//# sourceMappingURL=logging.cjs.map

package/dist/logging.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.cjs","sourceRoot":"","sources":["../src/logging.ts"],"names":[],"mappings":";;;;;;AACA,kDAA0B;AAE1B,MAAM,YAAY,GAAG,IAAA,eAAK,EAAC,UAAU,CAAC,CAAC;AAEvC;;;;;;;;;;;GAWG;AACH,SAAgB,mBAAmB,CAAC,WAAmB;IACrD,OAAO,YAAY,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;AAC1C,CAAC;AAFD,kDAEC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,kBAAkB,CAChC,aAAuB,EACvB,UAAkB;IAElB,OAAO,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;AAC1C,CAAC;AALD,gDAKC","sourcesContent":["import type { Debugger } from 'debug';\nimport debug from 'debug';\n\nconst globalLogger = debug('metamask');\n\n/**\n * Creates a logger via the `debug` library whose log messages will be tagged\n * using the name of your project. By default, such messages will be\n * suppressed, but you can reveal them by setting the `DEBUG` environment\n * variable to `metamask:<projectName>`. You can also set this variable to\n * `metamask:*` if you want to see log messages from all MetaMask projects that\n * are also using this function to create their loggers.\n *\n * @param projectName - The name of your project. This should be the name of\n * your NPM package if you're developing one.\n * @returns An instance of `debug`.\n */\nexport function createProjectLogger(projectName: string): Debugger {\n  return globalLogger.extend(projectName);\n}\n\n/**\n * Creates a logger via the `debug` library which is derived from the logger for\n * the whole project whose log messages will be tagged using the name of your\n * module. By default, such messages will be suppressed, but you can reveal them\n * by setting the `DEBUG` environment variable to\n * `metamask:<projectName>:<moduleName>`. You can also set this variable to\n * `metamask:<projectName>:*` if you want to see log messages from the project,\n * or `metamask:*` if you want to see log messages from all MetaMask projects.\n *\n * @param projectLogger - The logger created via {@link createProjectLogger}.\n * @param moduleName - The name of your module. You could use the name of the\n * file where you're using this logger or some other name.\n * @returns An instance of `debug`.\n */\nexport function createModuleLogger(\n  projectLogger: Debugger,\n  moduleName: string,\n): Debugger {\n  return projectLogger.extend(moduleName);\n}\n"]}

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

@@ -1,4 +1,4 @@
-import type { Debugger } from 'debug';
+import type { Debugger } from "debug";
 /**
  * Creates a logger via the `debug` library whose log messages will be tagged
  * using the name of your project. By default, such messages will be
@@ -27,4 +27,4 @@ export declare function createProjectLogger(projectName: string): Debugger;
  * @returns An instance of `debug`.
  */
 export declare function createModuleLogger(projectLogger: Debugger, moduleName: string): Debugger;
-//# sourceMappingURL=logging.d.ts.map
+//# sourceMappingURL=logging.d.cts.map

package/dist/logging.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.cts","sourceRoot":"","sources":["../src/logging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc;AAKtC;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,CAEjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,QAAQ,EACvB,UAAU,EAAE,MAAM,GACjB,QAAQ,CAEV"}

package/dist/logging.d.mts

@@ -0,0 +1,30 @@
+import type { Debugger } from "debug";
+/**
+ * Creates a logger via the `debug` library whose log messages will be tagged
+ * using the name of your project. By default, such messages will be
+ * suppressed, but you can reveal them by setting the `DEBUG` environment
+ * variable to `metamask:<projectName>`. You can also set this variable to
+ * `metamask:*` if you want to see log messages from all MetaMask projects that
+ * are also using this function to create their loggers.
+ *
+ * @param projectName - The name of your project. This should be the name of
+ * your NPM package if you're developing one.
+ * @returns An instance of `debug`.
+ */
+export declare function createProjectLogger(projectName: string): Debugger;
+/**
+ * Creates a logger via the `debug` library which is derived from the logger for
+ * the whole project whose log messages will be tagged using the name of your
+ * module. By default, such messages will be suppressed, but you can reveal them
+ * by setting the `DEBUG` environment variable to
+ * `metamask:<projectName>:<moduleName>`. You can also set this variable to
+ * `metamask:<projectName>:*` if you want to see log messages from the project,
+ * or `metamask:*` if you want to see log messages from all MetaMask projects.
+ *
+ * @param projectLogger - The logger created via {@link createProjectLogger}.
+ * @param moduleName - The name of your module. You could use the name of the
+ * file where you're using this logger or some other name.
+ * @returns An instance of `debug`.
+ */
+export declare function createModuleLogger(projectLogger: Debugger, moduleName: string): Debugger;
+//# sourceMappingURL=logging.d.mts.map

package/dist/logging.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.mts","sourceRoot":"","sources":["../src/logging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc;AAKtC;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,CAEjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,QAAQ,EACvB,UAAU,EAAE,MAAM,GACjB,QAAQ,CAEV"}

package/dist/logging.mjs

@@ -1,10 +1,35 @@
-import {
-  createModuleLogger,
-  createProjectLogger
-} from "./chunk-RIRDOQPX.mjs";
-import "./chunk-X66SUIEF.mjs";
-export {
-  createModuleLogger,
-  createProjectLogger
-};
+import debug from "debug";
+const globalLogger = debug('metamask');
+/**
+ * Creates a logger via the `debug` library whose log messages will be tagged
+ * using the name of your project. By default, such messages will be
+ * suppressed, but you can reveal them by setting the `DEBUG` environment
+ * variable to `metamask:<projectName>`. You can also set this variable to
+ * `metamask:*` if you want to see log messages from all MetaMask projects that
+ * are also using this function to create their loggers.
+ *
+ * @param projectName - The name of your project. This should be the name of
+ * your NPM package if you're developing one.
+ * @returns An instance of `debug`.
+ */
+export function createProjectLogger(projectName) {
+    return globalLogger.extend(projectName);
+}
+/**
+ * Creates a logger via the `debug` library which is derived from the logger for
+ * the whole project whose log messages will be tagged using the name of your
+ * module. By default, such messages will be suppressed, but you can reveal them
+ * by setting the `DEBUG` environment variable to
+ * `metamask:<projectName>:<moduleName>`. You can also set this variable to
+ * `metamask:<projectName>:*` if you want to see log messages from the project,
+ * or `metamask:*` if you want to see log messages from all MetaMask projects.
+ *
+ * @param projectLogger - The logger created via {@link createProjectLogger}.
+ * @param moduleName - The name of your module. You could use the name of the
+ * file where you're using this logger or some other name.
+ * @returns An instance of `debug`.
+ */
+export function createModuleLogger(projectLogger, moduleName) {
+    return projectLogger.extend(moduleName);
+}
 //# sourceMappingURL=logging.mjs.map

package/dist/logging.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"logging.mjs","sourceRoot":"","sources":["../src/logging.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,cAAc;AAE1B,MAAM,YAAY,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC;AAEvC;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,mBAAmB,CAAC,WAAmB;IACrD,OAAO,YAAY,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB,CAChC,aAAuB,EACvB,UAAkB;IAElB,OAAO,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;AAC1C,CAAC","sourcesContent":["import type { Debugger } from 'debug';\nimport debug from 'debug';\n\nconst globalLogger = debug('metamask');\n\n/**\n * Creates a logger via the `debug` library whose log messages will be tagged\n * using the name of your project. By default, such messages will be\n * suppressed, but you can reveal them by setting the `DEBUG` environment\n * variable to `metamask:<projectName>`. You can also set this variable to\n * `metamask:*` if you want to see log messages from all MetaMask projects that\n * are also using this function to create their loggers.\n *\n * @param projectName - The name of your project. This should be the name of\n * your NPM package if you're developing one.\n * @returns An instance of `debug`.\n */\nexport function createProjectLogger(projectName: string): Debugger {\n  return globalLogger.extend(projectName);\n}\n\n/**\n * Creates a logger via the `debug` library which is derived from the logger for\n * the whole project whose log messages will be tagged using the name of your\n * module. By default, such messages will be suppressed, but you can reveal them\n * by setting the `DEBUG` environment variable to\n * `metamask:<projectName>:<moduleName>`. You can also set this variable to\n * `metamask:<projectName>:*` if you want to see log messages from the project,\n * or `metamask:*` if you want to see log messages from all MetaMask projects.\n *\n * @param projectLogger - The logger created via {@link createProjectLogger}.\n * @param moduleName - The name of your module. You could use the name of the\n * file where you're using this logger or some other name.\n * @returns An instance of `debug`.\n */\nexport function createModuleLogger(\n  projectLogger: Debugger,\n  moduleName: string,\n): Debugger {\n  return projectLogger.extend(moduleName);\n}\n"]}

package/dist/misc.cjs

@@ -0,0 +1,149 @@
+"use strict";
+//
+// Types
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateNumberSize = exports.calculateStringSize = exports.isASCII = exports.isPlainObject = exports.ESCAPE_CHARACTERS_REGEXP = exports.JsonSize = exports.getKnownPropertyNames = exports.hasProperty = exports.isObject = exports.isNullOrUndefined = exports.isNonEmptyArray = void 0;
+//
+// Type Guards
+//
+/**
+ * A {@link NonEmptyArray} type guard.
+ *
+ * @template Element - The non-empty array member type.
+ * @param value - The value to check.
+ * @returns Whether the value is a non-empty array.
+ */
+function isNonEmptyArray(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+exports.isNonEmptyArray = isNonEmptyArray;
+/**
+ * Type guard for "nullishness".
+ *
+ * @param value - Any value.
+ * @returns `true` if the value is null or undefined, `false` otherwise.
+ */
+function isNullOrUndefined(value) {
+    return value === null || value === undefined;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+/**
+ * A type guard for {@link RuntimeObject}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the specified value has a runtime type of `object` and is
+ * neither `null` nor an `Array`.
+ */
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+exports.isObject = isObject;
+//
+// Other utility functions
+//
+/**
+ * A type guard for ensuring an object has a property.
+ *
+ * @param objectToCheck - The object to check.
+ * @param name - The property name to check for.
+ * @returns Whether the specified object has an own property with the specified
+ * name, regardless of whether it is enumerable or not.
+ */
+const hasProperty = (objectToCheck, name) => Object.hasOwnProperty.call(objectToCheck, name);
+exports.hasProperty = hasProperty;
+/**
+ * `Object.getOwnPropertyNames()` is intentionally generic: it returns the
+ * immediate property names of an object, but it cannot make guarantees about
+ * the contents of that object, so the type of the property names is merely
+ * `string[]`. While this is technically accurate, it is also unnecessary if we
+ * have an object with a type that we own (such as an enum).
+ *
+ * @param object - The plain object.
+ * @returns The own property names of the object which are assigned a type
+ * derived from the object itself.
+ */
+function getKnownPropertyNames(object) {
+    return Object.getOwnPropertyNames(object);
+}
+exports.getKnownPropertyNames = getKnownPropertyNames;
+/**
+ * Predefined sizes (in Bytes) of specific parts of JSON structure.
+ */
+var JsonSize;
+(function (JsonSize) {
+    JsonSize[JsonSize["Null"] = 4] = "Null";
+    JsonSize[JsonSize["Comma"] = 1] = "Comma";
+    JsonSize[JsonSize["Wrapper"] = 1] = "Wrapper";
+    JsonSize[JsonSize["True"] = 4] = "True";
+    JsonSize[JsonSize["False"] = 5] = "False";
+    JsonSize[JsonSize["Quote"] = 1] = "Quote";
+    JsonSize[JsonSize["Colon"] = 1] = "Colon";
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    JsonSize[JsonSize["Date"] = 24] = "Date";
+})(JsonSize = exports.JsonSize || (exports.JsonSize = {}));
+/**
+ * Regular expression with pattern matching for (special) escaped characters.
+ */
+exports.ESCAPE_CHARACTERS_REGEXP = /"|\\|\n|\r|\t/gu;
+/**
+ * Check if the value is plain object.
+ *
+ * @param value - Value to be checked.
+ * @returns True if an object is the plain JavaScript object,
+ * false if the object is not plain (e.g. function).
+ */
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    try {
+        let proto = value;
+        while (Object.getPrototypeOf(proto) !== null) {
+            proto = Object.getPrototypeOf(proto);
+        }
+        return Object.getPrototypeOf(value) === proto;
+    }
+    catch (_) {
+        return false;
+    }
+}
+exports.isPlainObject = isPlainObject;
+/**
+ * Check if character is ASCII.
+ *
+ * @param character - Character.
+ * @returns True if a character code is ASCII, false if not.
+ */
+function isASCII(character) {
+    return character.charCodeAt(0) <= 127;
+}
+exports.isASCII = isASCII;
+/**
+ * Calculate string size.
+ *
+ * @param value - String value to calculate size.
+ * @returns Number of bytes used to store whole string value.
+ */
+function calculateStringSize(value) {
+    const size = value.split('').reduce((total, character) => {
+        if (isASCII(character)) {
+            return total + 1;
+        }
+        return total + 2;
+    }, 0);
+    // Also detect characters that need backslash escape
+    return size + (value.match(exports.ESCAPE_CHARACTERS_REGEXP) ?? []).length;
+}
+exports.calculateStringSize = calculateStringSize;
+/**
+ * Calculate size of a number ofter JSON serialization.
+ *
+ * @param value - Number value to calculate size.
+ * @returns Number of bytes used to store whole number in JSON.
+ */
+function calculateNumberSize(value) {
+    return value.toString().length;
+}
+exports.calculateNumberSize = calculateNumberSize;
+//# sourceMappingURL=misc.cjs.map

package/dist/misc.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.cjs","sourceRoot":"","sources":["../src/misc.ts"],"names":[],"mappings":"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","sourcesContent":["//\n// Types\n//\n\n/**\n * Makes every specified property of the specified object type mutable.\n *\n * @template ObjectValue - The object whose readonly properties to make mutable.\n * @template TargetKey - The property key(s) to make mutable.\n */\nexport type Mutable<\n  ObjectValue extends Record<string, unknown>,\n  TargetKey extends keyof ObjectValue,\n> = {\n  -readonly [Key in keyof Pick<ObjectValue, TargetKey>]: ObjectValue[Key];\n} & {\n  [Key in keyof Omit<ObjectValue, TargetKey>]: ObjectValue[Key];\n};\n\n/**\n * Useful for representing some value that _might_ be present and / or complete.\n *\n * @template Value - The value that might be present or complete.\n */\nexport type PartialOrAbsent<Value> = Partial<Value> | null | undefined;\n\n/**\n * Like {@link Array}, but always non-empty.\n *\n * @template Element - The non-empty array member type.\n */\nexport type NonEmptyArray<Element> = [Element, ...Element[]];\n\n/**\n * A JavaScript object that is not `null`, a function, or an array.\n */\nexport type RuntimeObject = Record<PropertyKey, unknown>;\n\n//\n// Type Guards\n//\n\n/**\n * A {@link NonEmptyArray} type guard.\n *\n * @template Element - The non-empty array member type.\n * @param value - The value to check.\n * @returns Whether the value is a non-empty array.\n */\nexport function isNonEmptyArray<Element>(\n  value: Element[],\n): value is NonEmptyArray<Element> {\n  return Array.isArray(value) && value.length > 0;\n}\n\n/**\n * Type guard for \"nullishness\".\n *\n * @param value - Any value.\n * @returns `true` if the value is null or undefined, `false` otherwise.\n */\nexport function isNullOrUndefined(value: unknown): value is null | undefined {\n  return value === null || value === undefined;\n}\n\n/**\n * A type guard for {@link RuntimeObject}.\n *\n * @param value - The value to check.\n * @returns Whether the specified value has a runtime type of `object` and is\n * neither `null` nor an `Array`.\n */\nexport function isObject(value: unknown): value is RuntimeObject {\n  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);\n}\n\n//\n// Other utility functions\n//\n\n/**\n * A type guard for ensuring an object has a property.\n *\n * @param objectToCheck - The object to check.\n * @param name - The property name to check for.\n * @returns Whether the specified object has an own property with the specified\n * name, regardless of whether it is enumerable or not.\n */\nexport const hasProperty = <\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  ObjectToCheck extends Object,\n  Property extends PropertyKey,\n>(\n  objectToCheck: ObjectToCheck,\n  name: Property,\n): objectToCheck is ObjectToCheck &\n  Record<\n    Property,\n    Property extends keyof ObjectToCheck ? ObjectToCheck[Property] : unknown\n  > => Object.hasOwnProperty.call(objectToCheck, name);\n\n/**\n * `Object.getOwnPropertyNames()` is intentionally generic: it returns the\n * immediate property names of an object, but it cannot make guarantees about\n * the contents of that object, so the type of the property names is merely\n * `string[]`. While this is technically accurate, it is also unnecessary if we\n * have an object with a type that we own (such as an enum).\n *\n * @param object - The plain object.\n * @returns The own property names of the object which are assigned a type\n * derived from the object itself.\n */\nexport function getKnownPropertyNames<Key extends PropertyKey>(\n  object: Partial<Record<Key, any>>,\n): Key[] {\n  return Object.getOwnPropertyNames(object) as Key[];\n}\n\nexport type PlainObject = Record<number | string | symbol, unknown>;\n\n/**\n * Predefined sizes (in Bytes) of specific parts of JSON structure.\n */\nexport enum JsonSize {\n  Null = 4,\n  Comma = 1,\n  Wrapper = 1,\n  True = 4,\n  False = 5,\n  Quote = 1,\n  Colon = 1,\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  Date = 24,\n}\n\n/**\n * Regular expression with pattern matching for (special) escaped characters.\n */\nexport const ESCAPE_CHARACTERS_REGEXP = /\"|\\\\|\\n|\\r|\\t/gu;\n\n/**\n * Check if the value is plain object.\n *\n * @param value - Value to be checked.\n * @returns True if an object is the plain JavaScript object,\n * false if the object is not plain (e.g. function).\n */\nexport function isPlainObject(value: unknown): value is PlainObject {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n\n  try {\n    let proto = value;\n    while (Object.getPrototypeOf(proto) !== null) {\n      proto = Object.getPrototypeOf(proto);\n    }\n\n    return Object.getPrototypeOf(value) === proto;\n  } catch (_) {\n    return false;\n  }\n}\n\n/**\n * Check if character is ASCII.\n *\n * @param character - Character.\n * @returns True if a character code is ASCII, false if not.\n */\nexport function isASCII(character: string) {\n  return character.charCodeAt(0) <= 127;\n}\n\n/**\n * Calculate string size.\n *\n * @param value - String value to calculate size.\n * @returns Number of bytes used to store whole string value.\n */\nexport function calculateStringSize(value: string): number {\n  const size = value.split('').reduce((total, character) => {\n    if (isASCII(character)) {\n      return total + 1;\n    }\n    return total + 2;\n  }, 0);\n\n  // Also detect characters that need backslash escape\n  return size + (value.match(ESCAPE_CHARACTERS_REGEXP) ?? []).length;\n}\n\n/**\n * Calculate size of a number ofter JSON serialization.\n *\n * @param value - Number value to calculate size.\n * @returns Number of bytes used to store whole number in JSON.\n */\nexport function calculateNumberSize(value: number): number {\n  return value.toString().length;\n}\n"]}

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

@@ -4,7 +4,7 @@
  * @template ObjectValue - The object whose readonly properties to make mutable.
  * @template TargetKey - The property key(s) to make mutable.
  */
-export declare type Mutable<ObjectValue extends Record<string, unknown>, TargetKey extends keyof ObjectValue> = {
+export type Mutable<ObjectValue extends Record<string, unknown>, TargetKey extends keyof ObjectValue> = {
     -readonly [Key in keyof Pick<ObjectValue, TargetKey>]: ObjectValue[Key];
 } & {
     [Key in keyof Omit<ObjectValue, TargetKey>]: ObjectValue[Key];
@@ -14,17 +14,17 @@ export declare type Mutable<ObjectValue extends Record<string, unknown>, TargetK
  *
  * @template Value - The value that might be present or complete.
  */
-export declare type PartialOrAbsent<Value> = Partial<Value> | null | undefined;
+export type PartialOrAbsent<Value> = Partial<Value> | null | undefined;
 /**
  * Like {@link Array}, but always non-empty.
  *
  * @template Element - The non-empty array member type.
  */
-export declare type NonEmptyArray<Element> = [Element, ...Element[]];
+export type NonEmptyArray<Element> = [Element, ...Element[]];
 /**
  * A JavaScript object that is not `null`, a function, or an array.
  */
-export declare type RuntimeObject = Record<PropertyKey, unknown>;
+export type RuntimeObject = Record<PropertyKey, unknown>;
 /**
  * A {@link NonEmptyArray} type guard.
  *
@@ -69,7 +69,7 @@ export declare const hasProperty: <ObjectToCheck extends Object, Property extend
  * derived from the object itself.
  */
 export declare function getKnownPropertyNames<Key extends PropertyKey>(object: Partial<Record<Key, any>>): Key[];
-export declare type PlainObject = Record<number | string | symbol, unknown>;
+export type PlainObject = Record<number | string | symbol, unknown>;
 /**
  * Predefined sizes (in Bytes) of specific parts of JSON structure.
  */
@@ -116,4 +116,4 @@ export declare function calculateStringSize(value: string): number;
  * @returns Number of bytes used to store whole number in JSON.
  */
 export declare function calculateNumberSize(value: number): number;
-//# sourceMappingURL=misc.d.ts.map
+//# sourceMappingURL=misc.d.cts.map

package/dist/misc.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.d.cts","sourceRoot":"","sources":["../src/misc.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CACjB,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3C,SAAS,SAAS,MAAM,WAAW,IACjC;IACF,CAAC,UAAU,GAAG,IAAI,MAAM,IAAI,CAAC,WAAW,EAAE,SAAS,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC;CACxE,GAAG;KACD,GAAG,IAAI,MAAM,IAAI,CAAC,WAAW,EAAE,SAAS,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC;CAC9D,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,eAAe,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;AAEvE;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;AAE7D;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;AAMzD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EACrC,KAAK,EAAE,OAAO,EAAE,GACf,KAAK,IAAI,aAAa,CAAC,OAAO,CAAC,CAEjC;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,GAAG,SAAS,CAE3E;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAE/D;AAMD;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,2OAW8B,CAAC;AAEvD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,SAAS,WAAW,EAC3D,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,GAChC,GAAG,EAAE,CAEP;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpE;;GAEG;AACH,oBAAY,QAAQ;IAClB,IAAI,IAAI;IACR,KAAK,IAAI;IACT,OAAO,IAAI;IACX,IAAI,IAAI;IACR,KAAK,IAAI;IACT,KAAK,IAAI;IACT,KAAK,IAAI;IAET,IAAI,KAAK;CACV;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB,QAAoB,CAAC;AAE1D;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAelE;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,WAExC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUzD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD"}