@aptos-labs/ts-sdk 1.35.0-zeta.2 → 1.36.0

package/dist/esm/chunk-WLTQHGIJ.mjs

@@ -1,177 +0,0 @@
-import {
-  getTableItem,
-  getTableItemsData,
-  getTableItemsMetadata
-} from "./chunk-YT7V6AVJ.mjs";
-import {
-  waitForIndexerOnVersion
-} from "./chunk-WXQUBQK4.mjs";
-
-// src/api/table.ts
-var Table = class {
-  /**
-   * Initializes a new instance of the Aptos client with the specified configuration.
-   * This allows you to interact with the Aptos blockchain using the provided settings.
-   *
-   * @param config - The configuration settings for the Aptos client.
-   *
-   * @example
-   * ```typescript
-   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-   *
-   * async function runExample() {
-   *     // Create a new Aptos client with testnet configuration
-   *     const config = new AptosConfig({ network: Network.TESTNET });
-   *     const aptos = new Aptos(config);
-   *
-   *     console.log("Aptos client initialized:", aptos);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group Table
-   */
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Queries for a specific item in a table identified by the handle and the key for the item.
-   * This function allows you to retrieve structured data from a table in the Aptos blockchain.
-   *
-   * @param args.handle A pointer to where that table is stored.
-   * @param args.data Object that describes the table item, including key and value types.
-   * @param args.data.key_type The Move type of the table key.
-   * @param args.data.value_type The Move type of the table value.
-   * @param args.data.key The value of the table key.
-   * @param args.options.ledgerVersion The ledger version to query; if not provided, it will get the latest version.
-   *
-   * @returns Table item value rendered in JSON.
-   *
-   * @example
-   * ```typescript
-   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-   *
-   * const config = new AptosConfig({ network: Network.TESTNET });
-   * const aptos = new Aptos(config);
-   *
-   * async function runExample() {
-   *   // Retrieve a table item from the Aptos blockchain
-   *   const tableItem = await aptos.getTableItem({
-   *     handle: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca",
-   *     data: {
-   *       key_type: "address", // Move type of table key
-   *       value_type: "u128", // Move type of table value
-   *       key: "0x619dc29a0aac8fa146714058e8dd6d2d0f3bdf5f6331907bf91f3acd81e6935" // Value of table key
-   *     },
-   *   });
-   *
-   *   console.log(tableItem);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group Table
-   */
-  async getTableItem(args) {
-    return getTableItem({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Queries for table items data with optional filtering and pagination.
-   * This function allows you to retrieve specific data from a table based on provided criteria.
-   *
-   * @param args - The arguments for querying table items data.
-   * @param args.minimumLedgerVersion - Optional minimum ledger version to wait for before querying.
-   * @param args.options - Optional parameters for pagination and filtering.
-   * @param args.options.where - Conditions to filter the response.
-   * @param args.options.offset - The number of items to skip before starting to collect the result set.
-   * @param args.options.limit - The maximum number of items to return.
-   * @param args.options.orderBy - The criteria to order the results.
-   *
-   * Note: This query calls the indexer server.
-   *
-   * @example
-   * ```typescript
-   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-   *
-   * const config = new AptosConfig({ network: Network.TESTNET });
-   * const aptos = new Aptos(config);
-   *
-   * async function runExample() {
-   *   // Retrieve table items data with specific filtering options
-   *   const data = await aptos.getTableItemsData({
-   *     minimumLedgerVersion: 1, // specify your own minimum ledger version if needed
-   *     options: {
-   *       where: {
-   *         table_handle: { _eq: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca" },
-   *         transaction_version: { _eq: "0" }
-   *       },
-   *       limit: 10, // specify your own limit if needed
-   *     },
-   *   });
-   *
-   *   console.log(data);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   *
-   * @returns GetTableItemsDataResponse
-   * @group Table
-   */
-  async getTableItemsData(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: "default_processor" /* DEFAULT */
-    });
-    return getTableItemsData({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Queries for the metadata of table items, allowing for filtering and pagination.
-   *
-   * @param args - The parameters for the query.
-   * @param args.minimumLedgerVersion - Optional minimum ledger version to wait for before querying.
-   * @param args.options - Optional parameters for pagination and filtering.
-   * @param args.options.where - Conditions to filter the response.
-   * @param args.options.offset - The offset for pagination.
-   * @param args.options.limit - The maximum number of items to return.
-   * @param args.options.orderBy - The order in which to return the items.
-   *
-   * Note that this query calls the indexer server.
-   *
-   * @example
-   * ```typescript
-   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-   *
-   * const config = new AptosConfig({ network: Network.TESTNET });
-   * const aptos = new Aptos(config);
-   *
-   * async function runExample() {
-   *   // Fetching table items metadata with a filter condition
-   *   const data = await aptos.getTableItemsMetadata({
-   *     minimumLedgerVersion: 1, // specify your own minimum ledger version if needed
-   *     options: {
-   *       where: { handle: { _eq: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca" } },
-   *       limit: 10, // specify your own limit if needed
-   *     },
-   *   });
-   *
-   *   console.log(data);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   *
-   * @returns GetTableItemsMetadataResponse
-   * @group Table
-   */
-  async getTableItemsMetadata(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: "default_processor" /* DEFAULT */
-    });
-    return getTableItemsMetadata({ aptosConfig: this.config, ...args });
-  }
-};
-
-export {
-  Table
-};
-//# sourceMappingURL=chunk-WLTQHGIJ.mjs.map

package/dist/esm/chunk-WUM247HF.mjs

@@ -1,125 +0,0 @@
-import {
-  AbstractKeylessAccount
-} from "./chunk-ILTEOGFF.mjs";
-import {
-  KeylessPublicKey,
-  getIssAudAndUidVal
-} from "./chunk-T573PCIR.mjs";
-import {
-  Deserializer
-} from "./chunk-NUT2VOX2.mjs";
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/account/KeylessAccount.ts
-var KeylessAccount = class _KeylessAccount extends AbstractKeylessAccount {
-  // Use the static constructor 'create' instead.
-  /**
-   * Use the static generator `create(...)` instead.
-   * Creates an instance of the KeylessAccount with an optional proof.
-   *
-   * @param args - The parameters for creating a KeylessAccount.
-   * @param args.address - Optional account address associated with the KeylessAccount.
-   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
-   * @param args.iss - A JWT issuer.
-   * @param args.uidKey - The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.
-   * @param args.uidVal - The unique id for this user, intended to be a stable user identifier.
-   * @param args.aud - The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's
-   * OIDC registration with the identity provider.
-   * @param args.pepper - A hexadecimal input used for additional security.
-   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
-   * @param args.proofFetchCallback - Optional callback function for fetching proof.
-   * @param args.jwt - A JSON Web Token used for authentication.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  constructor(args) {
-    const publicKey = KeylessPublicKey.create(args);
-    super({ publicKey, ...args });
-    this.publicKey = publicKey;
-  }
-  /**
-   * Serializes the transaction data into a format suitable for transmission or storage.
-   * This function ensures that both the transaction bytes and the proof are properly serialized.
-   *
-   * @param serializer - The serializer instance used to convert the transaction data into bytes.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  serialize(serializer) {
-    super.serialize(serializer);
-  }
-  /**
-   * Deserializes the provided deserializer to create a KeylessAccount instance.
-   * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.
-   *
-   * @param deserializer - The deserializer instance used to retrieve the serialized data.
-   * @returns A KeylessAccount instance created from the deserialized data.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  static deserialize(deserializer) {
-    const { address, proof, ephemeralKeyPair, jwt, uidKey, pepper, verificationKeyHash } = AbstractKeylessAccount.partialDeserialize(deserializer);
-    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
-    return new _KeylessAccount({
-      address,
-      proof,
-      ephemeralKeyPair,
-      iss,
-      uidKey,
-      uidVal,
-      aud,
-      pepper,
-      jwt,
-      verificationKeyHash
-    });
-  }
-  /**
-   * Deserialize bytes using this account's information.
-   *
-   * @param bytes The bytes being interpreted.
-   * @returns
-   */
-  static fromBytes(bytes) {
-    return _KeylessAccount.deserialize(new Deserializer(Hex.hexInputToUint8Array(bytes)));
-  }
-  /**
-   * Creates a KeylessAccount instance using the provided parameters.
-   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.
-   * This is used instead of the KeylessAccount constructor.
-   *
-   * @param args - The parameters for creating a KeylessAccount.
-   * @param args.address - Optional account address associated with the KeylessAccount.
-   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
-   * @param args.jwt - A JSON Web Token used for authentication.
-   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
-   * @param args.pepper - A hexadecimal input used for additional security.
-   * @param args.uidKey - Optional key for user identification, defaults to "sub".
-   * @param args.proofFetchCallback - Optional callback function for fetching proof.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  static create(args) {
-    const { address, proof, jwt, ephemeralKeyPair, pepper, uidKey = "sub", proofFetchCallback, verificationKey } = args;
-    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
-    return new _KeylessAccount({
-      address,
-      proof,
-      ephemeralKeyPair,
-      iss,
-      uidKey,
-      uidVal,
-      aud,
-      pepper,
-      jwt,
-      proofFetchCallback,
-      verificationKeyHash: verificationKey ? verificationKey.hash() : void 0
-    });
-  }
-};
-
-export {
-  KeylessAccount
-};
-//# sourceMappingURL=chunk-WUM247HF.mjs.map

package/dist/esm/chunk-WXQUBQK4.mjs

@@ -1,19 +0,0 @@
-import {
-  waitForIndexer
-} from "./chunk-BU43ZFDJ.mjs";
-
-// src/api/utils.ts
-async function waitForIndexerOnVersion(args) {
-  if (args.minimumLedgerVersion !== void 0) {
-    await waitForIndexer({
-      aptosConfig: args.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: args.processorType
-    });
-  }
-}
-
-export {
-  waitForIndexerOnVersion
-};
-//# sourceMappingURL=chunk-WXQUBQK4.mjs.map

package/dist/esm/chunk-X4N5BN3S.mjs

@@ -1,40 +0,0 @@
-import {
-  generateViewFunctionPayload
-} from "./chunk-IJ7XCPP3.mjs";
-import {
-  postBinaryAptosFullNode
-} from "./chunk-6T3V5LXK.mjs";
-import {
-  Serializer
-} from "./chunk-C7T6GW5P.mjs";
-
-// src/internal/experimental.ts
-async function viewBinary(args) {
-  const { aptosConfig, payload, options } = args;
-  const viewFunctionPayload = await generateViewFunctionPayload({
-    ...payload,
-    aptosConfig
-  });
-  const serializer = new Serializer();
-  viewFunctionPayload.serialize(serializer);
-  const bytes = serializer.toUint8Array();
-  const { data } = await postBinaryAptosFullNode({
-    aptosConfig,
-    path: "view",
-    originMethod: "view",
-    contentType: "application/x.aptos.view_function+bcs" /* BCS_VIEW_FUNCTION */,
-    acceptType: "application/x-bcs" /* BCS */,
-    params: { ledger_version: options?.ledgerVersion },
-    body: bytes
-  });
-  const array = new Uint8Array(data);
-  if (options?.convert) {
-    return options.convert(array);
-  }
-  return array;
-}
-
-export {
-  viewBinary
-};
-//# sourceMappingURL=chunk-X4N5BN3S.mjs.map

package/dist/esm/chunk-XIBOO3WF.mjs

@@ -1,168 +0,0 @@
-import {
-  bytesToBigIntLE,
-  padAndPackBytesWithLen,
-  poseidonHash
-} from "./chunk-APM7OSLS.mjs";
-import {
-  EphemeralPublicKey,
-  EphemeralSignature
-} from "./chunk-UOHCJOXI.mjs";
-import {
-  Ed25519PrivateKey
-} from "./chunk-TFW6N66T.mjs";
-import {
-  floorToWholeHour,
-  nowInSeconds
-} from "./chunk-RQS33JAS.mjs";
-import {
-  Deserializer
-} from "./chunk-NUT2VOX2.mjs";
-import {
-  Serializable
-} from "./chunk-C7T6GW5P.mjs";
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/account/EphemeralKeyPair.ts
-import { randomBytes } from "@noble/hashes/utils";
-var TWO_WEEKS_IN_SECONDS = 1209600;
-var _EphemeralKeyPair = class _EphemeralKeyPair extends Serializable {
-  /**
-   * Creates an instance of the class with a specified private key, optional expiry date, and optional blinder.
-   * This constructor initializes the public key, sets the expiry date to a default value if not provided,
-   * generates a blinder if not supplied, and calculates the nonce based on the public key, expiry date, and blinder.
-   *
-   * @param args - The parameters for constructing the instance.
-   * @param args.privateKey - The private key used for creating the instance.
-   * @param args.expiryDateSecs - Optional expiry date in seconds from the current time. Defaults to two weeks from now.
-   * @param args.blinder - Optional blinder value. If not provided, a new blinder will be generated.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  constructor(args) {
-    super();
-    const { privateKey, expiryDateSecs, blinder } = args;
-    this.privateKey = privateKey;
-    this.publicKey = new EphemeralPublicKey(privateKey.publicKey());
-    this.expiryDateSecs = expiryDateSecs || floorToWholeHour(nowInSeconds() + TWO_WEEKS_IN_SECONDS);
-    this.blinder = blinder !== void 0 ? Hex.fromHexInput(blinder).toUint8Array() : generateBlinder();
-    const fields = padAndPackBytesWithLen(this.publicKey.bcsToBytes(), 93);
-    fields.push(BigInt(this.expiryDateSecs));
-    fields.push(bytesToBigIntLE(this.blinder));
-    const nonceHash = poseidonHash(fields);
-    this.nonce = nonceHash.toString();
-  }
-  /**
-   * Returns the public key of the key pair.
-   * @return EphemeralPublicKey
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  getPublicKey() {
-    return this.publicKey;
-  }
-  /**
-   * Checks if the current time has surpassed the expiry date of the key pair.
-   * @return boolean - Returns true if the key pair is expired, otherwise false.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  isExpired() {
-    const currentTimeSecs = Math.floor(Date.now() / 1e3);
-    return currentTimeSecs > this.expiryDateSecs;
-  }
-  /**
-   * Serializes the object's properties into a format suitable for transmission or storage.
-   * This function is essential for preparing the object data for serialization processes.
-   *
-   * @param serializer - The serializer instance used to serialize the object's properties.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(this.publicKey.variant);
-    serializer.serializeBytes(this.privateKey.toUint8Array());
-    serializer.serializeU64(this.expiryDateSecs);
-    serializer.serializeFixedBytes(this.blinder);
-  }
-  /**
-   * Deserializes an ephemeral key pair from the provided deserializer.
-   * This function helps in reconstructing an ephemeral key pair, which is essential for cryptographic operations.
-   *
-   * @param deserializer - The deserializer instance used to read the serialized data.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  static deserialize(deserializer) {
-    const variantIndex = deserializer.deserializeUleb128AsU32();
-    let privateKey;
-    switch (variantIndex) {
-      case 0 /* Ed25519 */:
-        privateKey = Ed25519PrivateKey.deserialize(deserializer);
-        break;
-      default:
-        throw new Error(`Unknown variant index for EphemeralPublicKey: ${variantIndex}`);
-    }
-    const expiryDateSecs = deserializer.deserializeU64();
-    const blinder = deserializer.deserializeFixedBytes(31);
-    return new _EphemeralKeyPair({ privateKey, expiryDateSecs: Number(expiryDateSecs), blinder });
-  }
-  /**
-   * Deserialize a byte array into an EphemeralKeyPair object.
-   * This function allows you to reconstruct an EphemeralKeyPair from its serialized byte representation.
-   *
-   * @param bytes - The byte array representing the serialized EphemeralKeyPair.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  static fromBytes(bytes) {
-    return _EphemeralKeyPair.deserialize(new Deserializer(bytes));
-  }
-  /**
-   * Generates a new ephemeral key pair with an optional expiry date.
-   * This function allows you to create a temporary key pair for secure operations.
-   *
-   * @param args - Optional parameters for key pair generation.
-   * @param args.scheme - The type of key pair to use for the EphemeralKeyPair. Only Ed25519 is supported for now.
-   * @param args.expiryDateSecs - The date of expiry for the key pair in seconds.
-   * @returns An instance of EphemeralKeyPair containing the generated private key and expiry date.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  static generate(args) {
-    let privateKey;
-    switch (args?.scheme) {
-      case 0 /* Ed25519 */:
-      default:
-        privateKey = Ed25519PrivateKey.generate();
-    }
-    return new _EphemeralKeyPair({ privateKey, expiryDateSecs: args?.expiryDateSecs });
-  }
-  /**
-   * Sign the given data using the private key, returning an ephemeral signature.
-   * This function is essential for creating a secure signature that can be used for authentication or verification purposes.
-   *
-   * @param data - The data to be signed, provided in HexInput format.
-   * @returns EphemeralSignature - The resulting ephemeral signature.
-   * @throws Error - Throws an error if the EphemeralKeyPair has expired.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  sign(data) {
-    if (this.isExpired()) {
-      throw new Error("EphemeralKeyPair has expired");
-    }
-    return new EphemeralSignature(this.privateKey.sign(data));
-  }
-};
-_EphemeralKeyPair.BLINDER_LENGTH = 31;
-var EphemeralKeyPair = _EphemeralKeyPair;
-function generateBlinder() {
-  return randomBytes(EphemeralKeyPair.BLINDER_LENGTH);
-}
-
-export {
-  EphemeralKeyPair
-};
-//# sourceMappingURL=chunk-XIBOO3WF.mjs.map

package/dist/esm/chunk-XQFUKBY7.mjs

@@ -1,136 +0,0 @@
-import {
-  aptosBinaryRequest,
-  aptosRequest
-} from "./chunk-G34CJDST.mjs";
-
-// src/client/get.ts
-async function get(options) {
-  const { aptosConfig, overrides, params, contentType, acceptType, path, originMethod, type } = options;
-  const url = aptosConfig.getRequestUrl(type);
-  return aptosRequest(
-    {
-      url,
-      method: "GET",
-      originMethod,
-      path,
-      contentType,
-      acceptType,
-      params,
-      overrides: {
-        ...aptosConfig.clientConfig,
-        ...overrides
-      }
-    },
-    aptosConfig,
-    options.type
-  );
-}
-async function getBinary(options) {
-  const { aptosConfig, overrides, params, contentType, acceptType, path, originMethod, type } = options;
-  const url = aptosConfig.getRequestUrl(type);
-  return aptosBinaryRequest(
-    {
-      url,
-      method: "GET",
-      originMethod,
-      path,
-      contentType,
-      acceptType,
-      params,
-      overrides: {
-        ...aptosConfig.clientConfig,
-        ...overrides
-      }
-    },
-    aptosConfig,
-    options.type
-  );
-}
-async function getAptosFullNode(options) {
-  const { aptosConfig } = options;
-  return get({
-    ...options,
-    type: "Fullnode" /* FULLNODE */,
-    overrides: {
-      ...aptosConfig.clientConfig,
-      ...aptosConfig.fullnodeConfig,
-      ...options.overrides,
-      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS }
-    }
-  });
-}
-async function getBinaryAptosFullNode(options) {
-  const { aptosConfig } = options;
-  return getBinary({
-    ...options,
-    type: "Fullnode" /* FULLNODE */,
-    overrides: {
-      ...aptosConfig.clientConfig,
-      ...aptosConfig.fullnodeConfig,
-      ...options.overrides,
-      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS }
-    }
-  });
-}
-async function getAptosPepperService(options) {
-  return get({ ...options, type: "Pepper" /* PEPPER */ });
-}
-async function paginateWithCursor(options) {
-  const out = [];
-  let cursor;
-  const requestParams = options.params;
-  do {
-    const response = await get({
-      type: "Fullnode" /* FULLNODE */,
-      aptosConfig: options.aptosConfig,
-      originMethod: options.originMethod,
-      path: options.path,
-      params: requestParams,
-      overrides: options.overrides
-    });
-    cursor = response.headers["x-aptos-cursor"];
-    delete response.headers;
-    out.push(...response.data);
-    requestParams.start = cursor;
-  } while (cursor !== null && cursor !== void 0);
-  return out;
-}
-async function paginateWithObfuscatedCursor(options) {
-  const out = [];
-  let cursor;
-  const requestParams = options.params;
-  const totalLimit = requestParams.limit;
-  do {
-    const response = await get({
-      type: "Fullnode" /* FULLNODE */,
-      aptosConfig: options.aptosConfig,
-      originMethod: options.originMethod,
-      path: options.path,
-      params: requestParams,
-      overrides: options.overrides
-    });
-    cursor = response.headers["x-aptos-cursor"];
-    delete response.headers;
-    out.push(...response.data);
-    requestParams.offset = cursor;
-    if (totalLimit !== void 0) {
-      const newLimit = totalLimit - out.length;
-      if (newLimit <= 0) {
-        break;
-      }
-      requestParams.limit = newLimit;
-    }
-  } while (cursor !== null && cursor !== void 0);
-  return out;
-}
-
-export {
-  get,
-  getBinary,
-  getAptosFullNode,
-  getBinaryAptosFullNode,
-  getAptosPepperService,
-  paginateWithCursor,
-  paginateWithObfuscatedCursor
-};
-//# sourceMappingURL=chunk-XQFUKBY7.mjs.map