zalo-toolkit 1.0.2 → 1.0.4

package/dist/cjs/models/Listen.cjs

@@ -122,6 +122,7 @@ exports.PingType = void 0;
     PingType[PingType["SwitchToBackground"] = 3] = "SwitchToBackground";
     PingType[PingType["BackgroundKeepAlive"] = 4] = "BackgroundKeepAlive";
 })(exports.PingType || (exports.PingType = {}));
+const DEFAULT_RETRY_DELAYS = [1000, 10000, 30000, 60000];
 exports.EventTypes = void 0;
 (function (EventTypes) {
     EventTypes["GOT_CLEAR_UNREADS"] = "GOT_CLEAR_UNREADS";
@@ -132,3 +133,34 @@ exports.EventTypes = void 0;
     EventTypes["SOCKET_STATE_CHANGED"] = "ON_SOCKET_STT_CHANGED";
     EventTypes["DONE_CHECK_OVERFLOW"] = "DONE_CHECK_OVERFLOW";
 })(exports.EventTypes || (exports.EventTypes = {}));
+const MessageTypes = {
+    '516': 'SESSION_OFFLINE',
+    '517': 'SESSION_OFFLINE',
+    '518': 'OFFLINE_ACK_ONE_ONE',
+    '519': 'OFFLINE_ACK_GROUP',
+    '543': 'INIT_SESSION',
+    '544': 'ACK_INIT_SESSION',
+    '545': 'INIT_SESSION',
+    '546': 'RECEIVE_ACK_GROUP_SESSIONS_STALE',
+    '548': 'NOTIFY_DELETE_KEY',
+    '549': 'REQUEST_PREKEYS',
+    '559': 'RECEIVE_ACK_PROCESS_INIT_GROUP_FAILED',
+    '561': 'INIT_SESSION_GROUP',
+    '580': 'DISABLE_E2EE',
+    '581': 'ENABLE_E2EE',
+    '582': 'RECEIVE_DOWNGRADE_E2EE_GROUP',
+};
+const SignalCommands = {
+    INIT: {
+        OFFLINE_ACK_GROUP: 519},
+    ACK: {
+        DELETE_QUEUE_ACK_ONEONE: 557,
+        DELETE_QUEUE_ACK_GROUP: 558,
+    },
+};
+const MAX_CHUNK_WS = 5;
+
+exports.DEFAULT_RETRY_DELAYS = DEFAULT_RETRY_DELAYS;
+exports.MAX_CHUNK_WS = MAX_CHUNK_WS;
+exports.MessageTypes = MessageTypes;
+exports.SignalCommands = SignalCommands;

package/dist/cjs/socket/config-socket.cjs

@@ -0,0 +1,203 @@
+'use strict';
+
+var Listen = require('../models/Listen.cjs');
+var WebSocket = require('ws');
+
+class ConfigSocket {
+    constructor(ws, features, ctx, listen) {
+        this.overflowTracker = {};
+        this.offlineCmds = new Map();
+        this.offlineWaiter = new Map();
+        this.pollId = {};
+        this.isDoneOffline = false;
+        this.emitter = ws;
+        this.features = features;
+        this.ctx = ctx;
+        this.listen = listen;
+    }
+    getLastActionIdsForSocket(socketKey) {
+        const defaultResult = { lastId: 1, preIds: [] };
+        if (this.pollId.hasOwnProperty(socketKey)) {
+            const { lastId } = this.pollId[socketKey];
+            const preIds = this.pollId[socketKey].control.getLastActionIdsArray(lastId).slice(0, 10);
+            return { lastId, preIds };
+        }
+        return defaultResult;
+    }
+    immediateDoNextOfflineReq(cmd) {
+        var _a;
+        return !((_a = this.features.socket.none_ids_queue) === null || _a === void 0 ? void 0 : _a.includes(cmd + ''));
+    }
+    getSocketState() {
+        return this.emitter ? this.emitter.readyState : -1;
+    }
+    sendWs(payload) {
+        if (this.emitter && this.getSocketState() === WebSocket.WebSocket.OPEN) {
+            const encodedData = new TextEncoder().encode(JSON.stringify(payload.data));
+            const dataLength = encodedData.length;
+            const data = new DataView(Buffer.alloc(4 + dataLength).buffer);
+            data.setUint8(0, payload.version);
+            data.setInt32(1, payload.cmd, true);
+            data.setInt8(3, payload.subCmd);
+            encodedData.forEach((e, i) => {
+                data.setUint8(4 + i, e);
+            });
+            this.emitter.send(data);
+        }
+    }
+    async doGetOffline(cmd, subCmd, first, lastActionId) {
+        var _a;
+        if (typeof cmd !== 'number' || typeof subCmd !== 'number') {
+            return;
+        }
+        const requestPayload = {
+            cmd,
+            subCmd,
+            data: {
+                first,
+                reqId: this.listen.genNextReqId(),
+                lastId: 1,
+                preIds: [],
+            },
+            version: 1,
+        };
+        if (!((_a = this.features.socket.none_ids_queue) === null || _a === void 0 ? void 0 : _a.includes(`${cmd}`))) {
+            const trackerKey = `${cmd}_${subCmd}`;
+            this.offlineWaiter.set(trackerKey, this.createOfflineWaiter());
+            const { lastId, preIds } = this.getLastActionIdsForSocket(`${cmd}_${subCmd}`);
+            requestPayload.data.lastId = lastActionId !== undefined ? lastActionId : lastId;
+            requestPayload.data.preIds = preIds;
+        }
+        this.sendWs(requestPayload);
+    }
+    createOfflineWaiter() {
+        const waiter = { resolve: null, reject: null, promise: null };
+        const promise = new Promise((resolve, reject) => {
+            waiter.resolve = resolve;
+            waiter.reject = reject;
+        });
+        waiter.promise = promise;
+        return waiter;
+    }
+    ackOfflineQueue(isGroup, data) {
+        const command = isGroup ? Listen.SignalCommands.ACK.DELETE_QUEUE_ACK_GROUP : Listen.SignalCommands.ACK.DELETE_QUEUE_ACK_ONEONE;
+        return this.requestAsyncV2({
+            cmd: command,
+            data: { data },
+        });
+    }
+    isValidSendPayload(payload) {
+        if (!payload || !payload.cmd || payload.data == null) {
+            return false;
+        }
+        return true;
+    }
+    getReqId(e) {
+        return [Listen.MessageCommand.PingActive].includes(e) ? `cmd_${e}` : this.listen.genNextReqId();
+    }
+    addCommonParams(payload) {
+        const reqId = this.getReqId(payload.cmd);
+        return Object.assign(Object.assign({}, payload), { data: Object.assign(Object.assign({}, payload.data), { reqId }) });
+    }
+    requestAsyncV2(payload) {
+        return new Promise((resolve, reject) => {
+            if (!this.isValidSendPayload(payload)) {
+                return reject('Invalid params');
+            }
+            const requestData = this.addCommonParams(payload);
+            this.sendWs(requestData);
+        });
+    }
+    async onOfflineData(cmd, subCmd, data, options = { isLastQueue: false }) {
+        var _a;
+        if (this.features.e2ee.debug.make_slow_pull_offline && this.features.e2ee.debug.enable) {
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+        }
+        if (((_a = this.features.socket.none_ids_queue) === null || _a === void 0 ? void 0 : _a.includes(`${cmd}`)) && data.data.delivereds.length) {
+            const delivereds = [...data.data.delivereds];
+            const isAckGroup = cmd === Listen.SignalCommands.INIT.OFFLINE_ACK_GROUP;
+            const chunkPromises = [];
+            while (delivereds.length > 0) {
+                const chunk = delivereds.splice(0, Listen.MAX_CHUNK_WS);
+                chunkPromises.push(this.ackOfflineQueue(isAckGroup, { delivereds: chunk }));
+            }
+            await Promise.all(chunkPromises).catch((error) => console.log(['Error when deleting queue offline {}'], error));
+        }
+    }
+    async onGotOffline(cmd, subCmd, data) {
+        var _a;
+        if (data && data.data) {
+            // this.webStartUp.onPollData(`${cmd}_${subCmd}`, data);
+            // this.checkQueueOverflow(cmd, subCmd, data);
+            if (data.data.more) {
+                const lastActionId = (_a = data.data) === null || _a === void 0 ? void 0 : _a.lastActionId;
+                if (this.immediateDoNextOfflineReq(cmd)) {
+                    await this.doGetOffline(cmd, subCmd, false, lastActionId);
+                    this.onOfflineData(cmd, subCmd, data, { isLastQueue: false });
+                }
+                else {
+                    await this.onOfflineData(cmd, subCmd, data, { isLastQueue: false });
+                    await this.doGetOffline(cmd, subCmd, false, lastActionId);
+                }
+            }
+            else {
+                const trackerKey = `${cmd}_${subCmd}`;
+                const isLastQueue = this.offlineWaiter.size === 1;
+                // this.webStartUp.onEndPoll(trackerKey, data.data.lastActionId);
+                this.onOfflineData(cmd, subCmd, data, { isLastQueue });
+                this.onDoneOfflineQueue(trackerKey);
+            }
+        }
+    }
+    checkQueueOverflow(cmd, subCmd, data) {
+        var _a, _b, _c;
+        const trackerKey = `${cmd}_${subCmd}`;
+        if (this.overflowTracker[trackerKey] !== undefined)
+            return;
+        if (!this.offlineCmds.has(cmd))
+            return;
+        const isEvicted = ((_c = (_b = (_a = data === null || data === void 0 ? void 0 : data.data) === null || _a === void 0 ? void 0 : _a.queueStatus) === null || _b === void 0 ? void 0 : _b[trackerKey]) === null || _c === void 0 ? void 0 : _c.evict) === 1;
+        this.overflowTracker[trackerKey] = isEvicted;
+        const trackerKeys = Object.keys(this.overflowTracker);
+        if (this.offlineCmds.size === trackerKeys.length) {
+            const overflowedKeys = trackerKeys.filter((key) => this.overflowTracker[key]);
+            this.emitter.emit(Listen.EventTypes.DONE_CHECK_OVERFLOW, overflowedKeys);
+        }
+    }
+    handleSocketMsg(cmd, payload) {
+        if (!this.features.e2ee.enable && this.features.e2ee.skip_on_disabled) {
+            return;
+        }
+        const actionHandler = Listen.MessageTypes[cmd];
+        if (!actionHandler) {
+            throw new Error(`Unsupported action type: ${cmd}`);
+        }
+        return this.emitter.emit(actionHandler, {
+            cmd,
+            payload,
+        });
+    }
+    onDoneOfflineQueue(queueId) {
+        const waiter = this.offlineWaiter.get(queueId);
+        if (waiter) {
+            // Resolve the waiter and remove it from the map
+            waiter.resolve(true);
+            this.offlineWaiter.delete(queueId);
+            // If all waiters are done, process the completion of all offline tasks
+            if (this.offlineWaiter.size === 0) {
+                this.onDoneOfflineAll();
+                // this.processPending(null);
+            }
+        }
+    }
+    onDoneOfflineAll() {
+        this.isDoneOffline = true;
+        // Clear offline timer if it's set
+        if (this.offlineTimer) {
+            clearTimeout(this.offlineTimer);
+            this.offlineTimer = null;
+        }
+    }
+}
+
+exports.ConfigSocket = ConfigSocket;

package/dist/cjs/utils.cjs

@@ -1,18 +1,18 @@
 'use strict';
 
 var cryptojs = require('crypto-js');
-require('json-bigint');
+var JSONBig = require('json-bigint');
 var crypto = require('node:crypto');
 require('node:fs');
 var path = require('node:path');
-require('pako');
+var pako = require('pako');
 var SparkMD5 = require('spark-md5');
 var ToughCookie = require('tough-cookie');
 var sharp = require('sharp');
 var context = require('./context.cjs');
 var ZaloApiError = require('./Errors/ZaloApiError.cjs');
-require('./models/FriendEvent.cjs');
-require('./models/GroupEvent.cjs');
+var FriendEvent = require('./models/FriendEvent.cjs');
+var GroupEvent = require('./models/GroupEvent.cjs');
 
 // export const isBun = typeof Bun !== "undefined";
 function hasOwn(obj, key) {
@@ -192,6 +192,17 @@ function decodeRespAES(key, data) {
         padding: cryptojs.pad.Pkcs7,
     }).toString(cryptojs.enc.Utf8);
 }
+function decodeBase64ToBuffer(data) {
+    return Buffer.from(data, 'base64');
+}
+function decodeUnit8Array(data) {
+    try {
+        return new TextDecoder().decode(data);
+    }
+    catch (_a) {
+        return null;
+    }
+}
 function encodeAES(secretKey, data, t = 0) {
     try {
         const key = cryptojs.enc.Base64.parse(secretKey);
@@ -295,6 +306,41 @@ async function getGifMetaData(file) {
         height: gifData.height,
     };
 }
+async function decodeEventData(parsed, cipherKey) {
+    if (typeof parsed.data !== 'string')
+        throw new ZaloApiError.ZaloApiError(`Invalid data, expected string but got ${typeof parsed.data}`);
+    if (typeof parsed.encrypt !== 'number')
+        throw new ZaloApiError.ZaloApiError(`Invalid encrypt type, expected number but got ${typeof parsed.encrypt}`);
+    if (parsed.encrypt < 0 || parsed.encrypt > 3)
+        throw new ZaloApiError.ZaloApiError(`Invalid encrypt type, expected 0-3 but got ${parsed.encrypt}`);
+    const rawData = parsed.data;
+    const encryptType = parsed.encrypt;
+    if (encryptType === 0)
+        return JSON.parse(rawData);
+    const decodedBuffer = decodeBase64ToBuffer(encryptType === 1 ? rawData : decodeURIComponent(rawData));
+    let decryptedBuffer = decodedBuffer;
+    if (encryptType !== 1) {
+        if (cipherKey && decodedBuffer.length >= 48) {
+            const algorithm = {
+                name: 'AES-GCM',
+                iv: decodedBuffer.subarray(0, 16),
+                tagLength: 128,
+                additionalData: decodedBuffer.subarray(16, 32),
+            };
+            const dataSource = decodedBuffer.subarray(32);
+            const cryptoKey = await crypto.subtle.importKey('raw', decodeBase64ToBuffer(cipherKey), algorithm, false, ['decrypt']);
+            decryptedBuffer = await crypto.subtle.decrypt(algorithm, cryptoKey, dataSource);
+        }
+        else {
+            throw new ZaloApiError.ZaloApiError('Invalid data length or missing cipher key');
+        }
+    }
+    const decompressedBuffer = encryptType === 3 ? new Uint8Array(decryptedBuffer) : pako.inflate(decryptedBuffer);
+    const decodedData = decodeUnit8Array(decompressedBuffer);
+    if (!decodedData)
+        return;
+    return JSONBig.parse(decodedData);
+}
 function getMd5LargeFileObject(file) {
     return new Promise(async (resolve, reject) => {
         let chunkSize = 2097152, // Read in chunks of 2MB
@@ -409,6 +455,80 @@ function removeUndefinedKeys(e) {
             delete e[t];
     return e;
 }
+function getGroupEventType(act) {
+    if (act == 'join_request')
+        return GroupEvent.GroupEventType.JOIN_REQUEST;
+    if (act == 'join')
+        return GroupEvent.GroupEventType.JOIN;
+    if (act == 'leave')
+        return GroupEvent.GroupEventType.LEAVE;
+    if (act == 'remove_member')
+        return GroupEvent.GroupEventType.REMOVE_MEMBER;
+    if (act == 'block_member')
+        return GroupEvent.GroupEventType.BLOCK_MEMBER;
+    if (act == 'update_setting')
+        return GroupEvent.GroupEventType.UPDATE_SETTING;
+    if (act == 'update_avatar')
+        return GroupEvent.GroupEventType.UPDATE_AVATAR;
+    if (act == 'update')
+        return GroupEvent.GroupEventType.UPDATE;
+    if (act == 'new_link')
+        return GroupEvent.GroupEventType.NEW_LINK;
+    if (act == 'add_admin')
+        return GroupEvent.GroupEventType.ADD_ADMIN;
+    if (act == 'remove_admin')
+        return GroupEvent.GroupEventType.REMOVE_ADMIN;
+    if (act == 'new_pin_topic')
+        return GroupEvent.GroupEventType.NEW_PIN_TOPIC;
+    if (act == 'update_pin_topic')
+        return GroupEvent.GroupEventType.UPDATE_PIN_TOPIC;
+    if (act == 'update_topic')
+        return GroupEvent.GroupEventType.UPDATE_TOPIC;
+    if (act == 'update_board')
+        return GroupEvent.GroupEventType.UPDATE_BOARD;
+    if (act == 'remove_board')
+        return GroupEvent.GroupEventType.REMOVE_BOARD;
+    if (act == 'reorder_pin_topic')
+        return GroupEvent.GroupEventType.REORDER_PIN_TOPIC;
+    if (act == 'unpin_topic')
+        return GroupEvent.GroupEventType.UNPIN_TOPIC;
+    if (act == 'remove_topic')
+        return GroupEvent.GroupEventType.REMOVE_TOPIC;
+    if (act == 'accept_remind')
+        return GroupEvent.GroupEventType.ACCEPT_REMIND;
+    if (act == 'reject_remind')
+        return GroupEvent.GroupEventType.REJECT_REMIND;
+    if (act == 'remind_topic')
+        return GroupEvent.GroupEventType.REMIND_TOPIC;
+    return GroupEvent.GroupEventType.UNKNOWN;
+}
+function getFriendEventType(act) {
+    if (act == 'add')
+        return FriendEvent.FriendEventType.ADD;
+    if (act == 'remove')
+        return FriendEvent.FriendEventType.REMOVE;
+    if (act == 'block')
+        return FriendEvent.FriendEventType.BLOCK;
+    if (act == 'unblock')
+        return FriendEvent.FriendEventType.UNBLOCK;
+    if (act == 'block_call')
+        return FriendEvent.FriendEventType.BLOCK_CALL;
+    if (act == 'unblock_call')
+        return FriendEvent.FriendEventType.UNBLOCK_CALL;
+    if (act == 'req_v2')
+        return FriendEvent.FriendEventType.REQUEST;
+    if (act == 'reject')
+        return FriendEvent.FriendEventType.REJECT_REQUEST;
+    if (act == 'undo_req')
+        return FriendEvent.FriendEventType.UNDO_REQUEST;
+    if (act == 'seen_fr_req')
+        return FriendEvent.FriendEventType.SEEN_FRIEND_REQUEST;
+    if (act == 'pin_unpin')
+        return FriendEvent.FriendEventType.PIN_UNPIN;
+    if (act == 'pin_create')
+        return FriendEvent.FriendEventType.PIN_CREATE;
+    return FriendEvent.FriendEventType.UNKNOWN;
+}
 async function handleZaloResponse(ctx, response, isEncrypted = true) {
     const result = {
         data: null,
@@ -511,16 +631,73 @@ function getSecChUaPlatform(userAgent = '') {
     }
     return '"Unknown"';
 }
+class FibonacciRetry {
+    constructor(maxItem = 2000, delta = 10, saltRange = 0.2) {
+        this.caches = [1, 2];
+        this.maxItem = maxItem;
+        this.delta = delta;
+        this.saltRange = saltRange;
+    }
+    /**
+     * Lấy giá trị Fibonacci tại index e (1-based)
+     * @param index - Thứ tự Fibonacci cần lấy (1-based)
+     * @returns Giá trị Fibonacci tương ứng
+     */
+    getFibo(index) {
+        if (index <= 0)
+            throw new Error('Index must be greater than 0');
+        if (this.caches.length >= index) {
+            return this.caches[index - 1];
+        }
+        let next = 1;
+        for (let i = this.caches.length; i < index; i++) {
+            const len = this.caches.length;
+            next = this.caches[len - 1] + this.caches[len - 2];
+            this.caches.push(next);
+        }
+        if (this.caches.length > this.maxItem + this.delta) {
+            this.caches = this.caches.slice(0, this.maxItem);
+        }
+        return next;
+    }
+    /**
+     * Tính toán thời gian retry tiếp theo dựa vào số lần retry hiện tại
+     * @param count - Lần retry thứ mấy (1-based)
+     * @param multiplier - Hệ số nhân (delay mỗi lần retry)
+     * @param maxDelay - Giới hạn tối đa delay (ms)
+     * @returns Số mili giây cần chờ trước khi retry tiếp theo
+     */
+    getNextRetry(count, multiplier, maxDelay) {
+        if (count <= 0)
+            throw new Error('Count must be greater than 0');
+        if (multiplier <= 0)
+            throw new Error('Multiplier must be greater than 0');
+        const fiboValue = this.getFibo(count);
+        const baseDelay = fiboValue * multiplier;
+        const randomFactor = 1 + this.saltRange * Math.random();
+        if (maxDelay !== undefined && baseDelay > maxDelay) {
+            return maxDelay * randomFactor;
+        }
+        return baseDelay * randomFactor;
+    }
+}
 function handleQueueStatus(queueStatus) {
     for (const key in queueStatus) {
         delete queueStatus[key].ids;
     }
     return queueStatus;
 }
+function looksLikeJson(str) {
+    return /^[\[{].*[\]}]$/.test(str.trim());
+}
 
+exports.FibonacciRetry = FibonacciRetry;
 exports.ParamsEncryptor = ParamsEncryptor;
 exports.apiFactory = apiFactory;
 exports.decodeAES = decodeAES;
+exports.decodeBase64ToBuffer = decodeBase64ToBuffer;
+exports.decodeEventData = decodeEventData;
+exports.decodeUnit8Array = decodeUnit8Array;
 exports.decryptResp = decryptResp;
 exports.encodeAES = encodeAES;
 exports.encryptPin = encryptPin;
@@ -529,8 +706,10 @@ exports.generateZaloUUID = generateZaloUUID;
 exports.getClientMessageType = getClientMessageType;
 exports.getDefaultHeaders = getDefaultHeaders;
 exports.getFileExtension = getFileExtension;
+exports.getFriendEventType = getFriendEventType;
 exports.getFullTimeFromMillisecond = getFullTimeFromMillisecond;
 exports.getGifMetaData = getGifMetaData;
+exports.getGroupEventType = getGroupEventType;
 exports.getImageMetaData = getImageMetaData;
 exports.getMd5LargeFileObject = getMd5LargeFileObject;
 exports.getSecChUaPlatform = getSecChUaPlatform;
@@ -539,6 +718,7 @@ exports.handleQueueStatus = handleQueueStatus;
 exports.handleZaloResponse = handleZaloResponse;
 exports.hasOwn = hasOwn;
 exports.logger = logger;
+exports.looksLikeJson = looksLikeJson;
 exports.makeURL = makeURL;
 exports.removeUndefinedKeys = removeUndefinedKeys;
 exports.request = request;

package/dist/cjs/zalo.cjs

@@ -7,6 +7,7 @@ var context = require('./context.cjs');
 var ZaloApiError = require('./Errors/ZaloApiError.cjs');
 var utils = require('./utils.cjs');
 var apis = require('./apis.cjs');
+var listen = require('./apis/listen.cjs');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -133,6 +134,9 @@ class Zalo {
     async getUserInfo(ctx) {
         return await loginQR.getUserInfo(ctx);
     }
+    listener(api) {
+        return new listen.Listener(api);
+    }
 }
 
 exports.Zalo = Zalo;

package/dist/zalo.d.ts

@@ -1,6 +1,7 @@
 import * as ToughCookie from 'tough-cookie';
 import { type ContextBase, type Options, type ServerInfo } from './context.js';
 import { ZaloAPI, type ZaloAPIOptions } from './apis.js';
+import { Listener } from './apis/listen.js';
 export type Credentials = {
     imei: string;
     cookie: ToughCookie.Cookie[] | ToughCookie.SerializedCookie[] | {
@@ -68,4 +69,5 @@ export declare class Zalo {
         error_code: number;
         error_message: string;
     } | undefined>;
+    listener(api: ZaloAPI): Listener;
 }

package/dist/zalo.js

@@ -5,6 +5,7 @@ import { createContext, isContextSession } from './context.js';
 import { ZaloApiError } from './Errors/ZaloApiError.js';
 import { generateZaloUUID, logger } from './utils.js';
 import { ZaloAPI } from './apis.js';
+import { Listener } from './apis/listen.js';
 export class Zalo {
     constructor(options = {}) {
         this.options = options;
@@ -111,4 +112,7 @@ export class Zalo {
     async getUserInfo(ctx) {
         return await getUserInfo(ctx);
     }
+    listener(api) {
+        return new Listener(api);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zalo-toolkit",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Unofficial Zalo API for JavaScript",
   "main": "dist/index.js",
   "type": "module",