@module-federation/devtools 0.0.0-perf-devtools-20260107043700 → 0.0.0-perf-website-code-usage-20260914033703

package/dist/types/utils/chrome/fast-refresh.js

@@ -0,0 +1,329 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var import__ = require("../index");
+var import_sdk = require("../sdk");
+var import_constant = require("../../template/constant");
+var _a;
+const SUPPORT_PKGS = ["react", "react-dom"];
+const DEFAULT_SHARE_SCOPE = "default";
+const DEFAULT_GLOBAL_KEY_MAP = {
+  react: "React",
+  "react-dom": "ReactDOM"
+};
+const sanitizeWindowKey = (value) => value.replace(/[^a-zA-Z0-9_$]/g, "_");
+const getShareScopes = (scope) => Array.isArray(scope) && scope.length ? scope : [DEFAULT_SHARE_SCOPE];
+const getDefaultGlobalKey = (pkgName) => DEFAULT_GLOBAL_KEY_MAP[pkgName];
+const getScopedGlobalKey = (scope, pkgName) => `${sanitizeWindowKey(scope)}_${sanitizeWindowKey(pkgName)}`;
+const getWindowValue = (key) => window[key];
+const setWindowValue = (key, value) => {
+  window[key] = value;
+};
+const setScopeGlobals = (pkgName, scopes, source) => {
+  if (!source) {
+    return source;
+  }
+  scopes.forEach((scope) => {
+    setWindowValue(getScopedGlobalKey(scope, pkgName), source);
+  });
+  return source;
+};
+const getScopeGlobal = (pkgName, scopes) => {
+  for (const scope of scopes) {
+    const scopeGlobal = getWindowValue(getScopedGlobalKey(scope, pkgName));
+    if (scopeGlobal) {
+      return scopeGlobal;
+    }
+  }
+  return void 0;
+};
+const getEagerShareInfo = (eagerShare) => {
+  if (!Array.isArray(eagerShare) || eagerShare.length < 2) {
+    return null;
+  }
+  const [, version, scopes] = eagerShare;
+  if (typeof version !== "string") {
+    return null;
+  }
+  return {
+    version,
+    scopes: getShareScopes(scopes)
+  };
+};
+const updateEagerShareInfo = (devtoolsMessage2, pkgName, version, scopes) => {
+  const existing = getEagerShareInfo(devtoolsMessage2[import_constant.__EAGER_SHARE__]);
+  const mergedScopes = Array.from(
+    /* @__PURE__ */ new Set([...(existing == null ? void 0 : existing.scopes) || [], ...scopes])
+  );
+  devtoolsMessage2[import_constant.__EAGER_SHARE__] = [pkgName, version, mergedScopes];
+  return {
+    shouldReload: !existing || existing.version !== version
+  };
+};
+const requestUmdSourceSync = (url) => {
+  try {
+    const response = new XMLHttpRequest();
+    response.open("GET", url, false);
+    response.overrideMimeType("text/plain");
+    response.send();
+    if (response.status === 200) {
+      return response.responseText;
+    }
+    throw new Error(
+      `Failed to load module from ${url}: HTTP ${response.status}`
+    );
+  } catch (error) {
+    throw new Error(`Failed to fetch module from ${url}: ${error.message}`);
+  }
+};
+const requestUmdSource = (url) => new Promise((resolve, reject) => {
+  try {
+    const response = new XMLHttpRequest();
+    response.open("GET", url, true);
+    response.overrideMimeType("text/plain");
+    response.onload = () => {
+      if (response.status === 200) {
+        resolve(response.responseText);
+        return;
+      }
+      reject(
+        new Error(
+          `Failed to load module from ${url}: HTTP ${response.status}`
+        )
+      );
+    };
+    response.onerror = () => {
+      reject(new Error(`Failed to fetch module from ${url}`));
+    };
+    response.send();
+  } catch (error) {
+    reject(new Error(`Failed to fetch module from ${url}: ${error.message}`));
+  }
+});
+const createUmdSandbox = (pkgName, scopes) => {
+  const sandboxTarget = /* @__PURE__ */ Object.create(null);
+  const sandbox = new Proxy(sandboxTarget, {
+    get(target, key) {
+      if (typeof key === "symbol") {
+        return Reflect.get(target, key);
+      }
+      if (key in target) {
+        return target[key];
+      }
+      const value = window[key];
+      return typeof value === "function" ? value.bind(window) : value;
+    },
+    set(target, key, value) {
+      target[key] = value;
+      return true;
+    },
+    has(target, key) {
+      return key in target || key in window;
+    }
+  });
+  sandboxTarget.window = sandbox;
+  sandboxTarget.self = sandbox;
+  sandboxTarget.globalThis = sandbox;
+  sandboxTarget.global = sandbox;
+  sandboxTarget.document = window.document;
+  if (pkgName === "react-dom") {
+    sandboxTarget.React = getScopeGlobal("react", scopes);
+  }
+  return sandbox;
+};
+const executeUmdModule = (scriptContent, pkgName, scopes) => {
+  const sandbox = createUmdSandbox(pkgName, scopes);
+  const moduleFunction = new Function(
+    "window",
+    "self",
+    "globalThis",
+    "global",
+    "document",
+    "exports",
+    "module",
+    "define",
+    "require",
+    scriptContent
+  );
+  moduleFunction.call(
+    sandbox,
+    sandbox,
+    sandbox,
+    sandbox,
+    sandbox,
+    sandbox.document,
+    void 0,
+    void 0,
+    void 0,
+    void 0
+  );
+  return sandbox[getDefaultGlobalKey(pkgName)];
+};
+const loadUmdModuleSync = (pkgName, version, scopes) => executeUmdModule(
+  requestUmdSourceSync((0, import__.getUnpkgUrl)(pkgName, version)),
+  pkgName,
+  scopes
+);
+const loadUmdModule = (pkgName, version, scopes) => __async(exports, null, function* () {
+  return executeUmdModule(
+    yield requestUmdSource((0, import__.getUnpkgUrl)(pkgName, version)),
+    pkgName,
+    scopes
+  );
+});
+const getDevtoolsMessage = () => {
+  const devtoolsMessageStr = localStorage.getItem(import_constant.__FEDERATION_DEVTOOLS__);
+  if (devtoolsMessageStr) {
+    try {
+      return JSON.parse(devtoolsMessageStr);
+    } catch (e) {
+      console.debug("Fast Refresh Plugin Error: ", e);
+    }
+  }
+  return null;
+};
+const devtoolsMessage = getDevtoolsMessage();
+const eagerShareInfo = getEagerShareInfo(devtoolsMessage == null ? void 0 : devtoolsMessage[import_constant.__EAGER_SHARE__]);
+if ((devtoolsMessage == null ? void 0 : devtoolsMessage[import_constant.__ENABLE_FAST_REFRESH__]) && eagerShareInfo) {
+  const { version, scopes } = eagerShareInfo;
+  setScopeGlobals("react", scopes, loadUmdModuleSync("react", version, scopes));
+  setScopeGlobals(
+    "react-dom",
+    scopes,
+    loadUmdModuleSync("react-dom", version, scopes)
+  );
+}
+const fastRefreshPlugin = () => {
+  let orderResolve;
+  const orderPromise = new Promise((resolve) => {
+    orderResolve = resolve;
+  });
+  return {
+    name: "mf-fast-refresh-plugin",
+    beforeRegisterShare(args) {
+      var _a2;
+      const { pkgName, shared } = args;
+      if (!SUPPORT_PKGS.includes(pkgName)) {
+        return args;
+      }
+      const supportPkgName = pkgName;
+      const shareScopes = getShareScopes(shared.scope);
+      let enableFastRefresh = false;
+      let devtoolsMessage2 = {};
+      const devtoolsMessageStr = localStorage.getItem(import_constant.__FEDERATION_DEVTOOLS__);
+      if (devtoolsMessageStr) {
+        try {
+          devtoolsMessage2 = JSON.parse(devtoolsMessageStr);
+          enableFastRefresh = devtoolsMessage2 == null ? void 0 : devtoolsMessage2[import_constant.__ENABLE_FAST_REFRESH__];
+        } catch (e) {
+          console.debug("Fast Refresh Plugin Error: ", e);
+        }
+      }
+      if (!enableFastRefresh) {
+        return args;
+      }
+      if (((_a2 = shared.shareConfig) == null ? void 0 : _a2.eager) || shared.lib) {
+        if (!(devtoolsMessage2 == null ? void 0 : devtoolsMessage2[import_constant.__EAGER_SHARE__])) {
+          const eagerShareInfo2 = updateEagerShareInfo(
+            devtoolsMessage2,
+            pkgName,
+            shared.version,
+            shareScopes
+          );
+          localStorage.setItem(
+            import_constant.__FEDERATION_DEVTOOLS__,
+            JSON.stringify(devtoolsMessage2)
+          );
+          if (eagerShareInfo2.shouldReload) {
+            window.location.reload();
+          }
+        } else {
+          updateEagerShareInfo(
+            devtoolsMessage2,
+            pkgName,
+            shared.version,
+            shareScopes
+          );
+          localStorage.setItem(
+            import_constant.__FEDERATION_DEVTOOLS__,
+            JSON.stringify(devtoolsMessage2)
+          );
+        }
+        if (pkgName === "react-dom") {
+          shared.lib = () => getScopeGlobal(supportPkgName, shareScopes);
+        }
+        if (pkgName === "react") {
+          shared.lib = () => getScopeGlobal(supportPkgName, shareScopes);
+        }
+        return args;
+      }
+      let get;
+      if (pkgName === "react") {
+        get = () => loadUmdModule(supportPkgName, shared.version, shareScopes).then((moduleValue) => {
+          setScopeGlobals(supportPkgName, shareScopes, moduleValue);
+          return moduleValue;
+        }).then(() => {
+          orderResolve();
+        });
+      }
+      if (pkgName === "react-dom") {
+        get = () => orderPromise.then(
+          () => loadUmdModule(supportPkgName, shared.version, shareScopes)
+        ).then((result) => {
+          setScopeGlobals(supportPkgName, shareScopes, result);
+          return result;
+        });
+      }
+      if (typeof get === "function") {
+        const finalGet = get;
+        if (pkgName === "react") {
+          shared.get = () => __async(this, null, function* () {
+            if (!getScopeGlobal(supportPkgName, shareScopes)) {
+              yield finalGet();
+              console.warn(
+                "[Module Federation HMR]: You are using Module Federation Devtools to debug online host, it will cause your project load Dev mode React and ReactDOM. If not in this mode, please disable it in Module Federation Devtools"
+              );
+            }
+            shared.lib = () => getScopeGlobal(supportPkgName, shareScopes);
+            return () => getScopeGlobal(supportPkgName, shareScopes);
+          });
+        }
+        if (pkgName === "react-dom") {
+          shared.get = () => __async(this, null, function* () {
+            if (!getScopeGlobal(supportPkgName, shareScopes)) {
+              yield finalGet();
+            }
+            shared.lib = () => getScopeGlobal(supportPkgName, shareScopes);
+            return () => getScopeGlobal(supportPkgName, shareScopes);
+          });
+        }
+      }
+      return args;
+    }
+  };
+};
+if (!(window == null ? void 0 : window.__FEDERATION__)) {
+  (0, import_sdk.definePropertyGlobalVal)(window, "__FEDERATION__", {});
+  (0, import_sdk.definePropertyGlobalVal)(window, "__VMOK__", window.__FEDERATION__);
+}
+if (!(window == null ? void 0 : window.__FEDERATION__.__GLOBAL_PLUGIN__)) {
+  window.__FEDERATION__.__GLOBAL_PLUGIN__ = [];
+}
+(_a = window.__FEDERATION__.__GLOBAL_PLUGIN__) == null ? void 0 : _a.push(fastRefreshPlugin());

package/dist/types/utils/chrome/index.js

@@ -0,0 +1,321 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var chrome_exports = {};
+__export(chrome_exports, {
+  TabInfo: () => TabInfo,
+  getCurrentTabId: () => getCurrentTabId,
+  getGlobalModuleInfo: () => getGlobalModuleInfo,
+  getInspectWindowTabId: () => getInspectWindowTabId,
+  getScope: () => getScope,
+  getTabs: () => getTabs,
+  getUrl: () => getUrl,
+  injectPostMessage: () => injectPostMessage,
+  injectScript: () => injectScript,
+  injectToast: () => injectToast,
+  normalizeModuleInfoPayload: () => normalizeModuleInfoPayload,
+  refreshModuleInfo: () => refreshModuleInfo,
+  setChromeStorage: () => setChromeStorage,
+  setTargetTab: () => setTargetTab,
+  syncActiveTab: () => syncActiveTab
+});
+module.exports = __toCommonJS(chrome_exports);
+var import_constant = require("../../template/constant");
+var import_sdk2 = require("../sdk");
+var import_safe_post_message = require("./safe-post-message");
+__reExport(chrome_exports, require("./storage"), module.exports);
+const isModuleInfoRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const isModuleInfoSyncMessage = (value) => isModuleInfoRecord(value) && ("moduleInfo" in value || "updateModule" in value || "share" in value);
+const normalizeModuleInfoPayload = (moduleInfo) => {
+  const sanitized = (0, import_safe_post_message.sanitizePostMessagePayload)(moduleInfo);
+  if (!isModuleInfoRecord(sanitized)) {
+    return {};
+  }
+  return Object.entries(sanitized).reduce(
+    (moduleMap, [moduleId, snapshot]) => {
+      if (moduleId === "extendInfos" || isModuleInfoRecord(snapshot)) {
+        moduleMap[moduleId] = snapshot;
+      }
+      return moduleMap;
+    },
+    {}
+  );
+};
+const sleep = (num) => {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve();
+    }, num);
+  });
+};
+const injectPostMessage = (postMessageUrl) => {
+  const script = document.createElement("script");
+  script.src = postMessageUrl;
+  document.getElementsByTagName("head")[0].appendChild(script);
+};
+const TabInfo = {
+  currentTabId: 0
+};
+const setTargetTab = (tab) => {
+  if (!tab || typeof tab.id !== "number") {
+    return;
+  }
+  window.targetTab = tab;
+  TabInfo.currentTabId = tab.id;
+};
+const syncActiveTab = (tabId) => __async(void 0, null, function* () {
+  try {
+    if (typeof tabId === "number") {
+      const tab = yield chrome.tabs.get(tabId);
+      setTargetTab(tab);
+      return tab;
+    }
+    const tabs = yield getTabs({
+      active: true,
+      lastFocusedWindow: true
+    });
+    const activeTab = Array.isArray(tabs) ? tabs[0] : void 0;
+    setTargetTab(activeTab);
+    return activeTab;
+  } catch (error) {
+    console.warn("[Module Federation Devtools] syncActiveTab failed", error);
+    return void 0;
+  }
+});
+function getCurrentTabId() {
+  return TabInfo.currentTabId;
+}
+function getInspectWindowTabId() {
+  return new Promise((resolve, reject) => {
+    var _a, _b;
+    if ((_a = chrome == null ? void 0 : chrome.devtools) == null ? void 0 : _a.inspectedWindow) {
+      if (chrome.isDevMode) {
+        resolve(0);
+      }
+      chrome.devtools.inspectedWindow.eval(
+        'typeof window.__FEDERATION__ !== "undefined" || typeof window.__VMOK__ !== "undefined"',
+        function(info, error) {
+          const { tabId } = chrome.devtools.inspectedWindow;
+          getTabs().then((tabs) => {
+            const target = Array.isArray(tabs) ? tabs.find((tab) => tab.id === tabId) : void 0;
+            setTargetTab(target);
+          });
+          console.log(
+            "chrome.devtools.inspectedWindow.tabId",
+            chrome.devtools.inspectedWindow.tabId
+          );
+          TabInfo.currentTabId = tabId;
+          resolve(tabId);
+          if (error) {
+            reject(error);
+          }
+        }
+      );
+    } else {
+      if ((_b = window.targetTab) == null ? void 0 : _b.id) {
+        const tabId = window.targetTab.id;
+        TabInfo.currentTabId = tabId;
+        resolve(tabId);
+      } else {
+        throw Error(`can't get active tab`);
+      }
+    }
+  });
+}
+const refreshModuleInfo = () => __async(void 0, null, function* () {
+  var _a;
+  if (typeof window !== "undefined" && ((_a = window.__FEDERATION__) == null ? void 0 : _a.moduleInfo)) {
+  }
+  yield sleep(50);
+  const postMessageStartUrl = getUrl("post-message-start.js");
+  yield injectScript(injectPostMessage, false, postMessageStartUrl);
+});
+const getGlobalModuleInfo = (callback) => __async(void 0, null, function* () {
+  var _a, _b;
+  if (typeof window !== "undefined" && ((_a = window.__FEDERATION__) == null ? void 0 : _a.moduleInfo)) {
+    callback(normalizeModuleInfoPayload((_b = window.__FEDERATION__) == null ? void 0 : _b.moduleInfo));
+  }
+  yield sleep(300);
+  const listener = (message) => {
+    const { data } = message;
+    if (!isModuleInfoSyncMessage(data) || (data == null ? void 0 : data.appInfos)) {
+      return;
+    }
+    if (!(window == null ? void 0 : window.__FEDERATION__)) {
+      (0, import_sdk2.definePropertyGlobalVal)(window, "__FEDERATION__", {});
+      (0, import_sdk2.definePropertyGlobalVal)(window, "__VMOK__", window.__FEDERATION__);
+    }
+    window.__FEDERATION__.originModuleInfo = "moduleInfo" in data ? normalizeModuleInfoPayload(data.moduleInfo) : normalizeModuleInfoPayload(
+      window.__FEDERATION__.originModuleInfo || window.__FEDERATION__.moduleInfo
+    );
+    const updateModule = data.updateModule;
+    if (isModuleInfoRecord(updateModule) && typeof updateModule.name === "string") {
+      const updateModuleName = updateModule.name;
+      const moduleIds = Object.keys(window.__FEDERATION__.originModuleInfo);
+      const shouldUpdate = !moduleIds.some(
+        (id) => id.includes(updateModuleName)
+      );
+      if (shouldUpdate) {
+        const destination = typeof updateModule.entry === "string" ? updateModule.entry : typeof updateModule.version === "string" ? updateModule.version : void 0;
+        if (destination) {
+          window.__FEDERATION__.originModuleInfo[`${updateModuleName}:${destination}`] = {
+            remoteEntry: destination,
+            version: destination
+          };
+        }
+      }
+    }
+    if (data == null ? void 0 : data.share) {
+      window.__FEDERATION__.__SHARE__ = (0, import_safe_post_message.sanitizePostMessagePayload)(
+        data.share
+      );
+    }
+    window.__FEDERATION__.moduleInfo = normalizeModuleInfoPayload(
+      window.__FEDERATION__.originModuleInfo
+    );
+    console.log("getGlobalModuleInfo window", window.__FEDERATION__);
+    callback(window.__FEDERATION__.moduleInfo);
+  };
+  chrome.runtime.onMessage.addListener(listener);
+  yield refreshModuleInfo();
+  return () => chrome.runtime.onMessage.removeListener(listener);
+});
+const getTabs = (queryOptions = {}) => chrome.tabs.query(queryOptions);
+const getScope = () => __async(void 0, null, function* () {
+  const activeTab = window.targetTab;
+  const tabId = activeTab == null ? void 0 : activeTab.id;
+  return tabId ? String(tabId) : "noScope";
+});
+const injectScript = (excuteScript, world = false, ...args) => __async(void 0, null, function* () {
+  yield getInspectWindowTabId();
+  return chrome.scripting.executeScript({
+    target: {
+      tabId: getCurrentTabId()
+    },
+    func: excuteScript,
+    world: world ? "MAIN" : "ISOLATED",
+    args
+  }).then((results) => {
+    var _a;
+    console.log("InjectScript success, excuteScript:", args);
+    if (Array.isArray(results) && results.length) {
+      return (_a = results[0]) == null ? void 0 : _a.result;
+    }
+    return void 0;
+  }).catch((e) => {
+    console.log(e, "InjectScript fail, excuteScript:", args);
+    return void 0;
+  });
+});
+const getUrl = (file) => {
+  try {
+    const pathSet = chrome.runtime.getURL(file).split("/");
+    const fileName = pathSet.pop();
+    pathSet.push("static", "js", fileName);
+    return pathSet.join("/");
+  } catch (e) {
+    return "";
+  }
+};
+const injectToast = (toastUtilUrl, e2eFlag) => {
+  const ele = document.querySelector(`[data-e2e=${e2eFlag}]`);
+  if (ele) {
+    return;
+  }
+  const scriptToast = document.createElement("script");
+  scriptToast.src = toastUtilUrl;
+  scriptToast.dataset.e2e = e2eFlag;
+  document.getElementsByTagName("head")[0].appendChild(scriptToast);
+};
+const setChromeStorage = (formData) => {
+  getScope().then((scope) => __async(void 0, null, function* () {
+    const data = yield chrome.storage.sync.get("FormID");
+    const storeData = data[import_constant.FormID];
+    const scopes = Object.keys(storeData || {});
+    let filterOutDatedData = storeData || {};
+    const { length } = scopes;
+    if (length >= 10) {
+      filterOutDatedData = scopes.slice(0, length - 3).reduce((memo, cur) => {
+        memo[cur] = storeData[cur];
+        return memo;
+      }, {});
+    }
+    const existRules = storeData == null ? void 0 : storeData[scope];
+    chrome.storage.sync.set({
+      [import_constant.FormID]: __spreadProps(__spreadValues({}, filterOutDatedData), {
+        [scope]: __spreadValues(__spreadValues({}, existRules), formData)
+      })
+    });
+  }));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TabInfo,
+  getCurrentTabId,
+  getGlobalModuleInfo,
+  getInspectWindowTabId,
+  getScope,
+  getTabs,
+  getUrl,
+  injectPostMessage,
+  injectScript,
+  injectToast,
+  normalizeModuleInfoPayload,
+  refreshModuleInfo,
+  setChromeStorage,
+  setTargetTab,
+  syncActiveTab,
+  ...require("./storage")
+});

package/dist/types/utils/chrome/messages.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var messages_exports = {};
+__export(messages_exports, {
+  MESSAGE_ACTIVE_TAB_CHANGED: () => MESSAGE_ACTIVE_TAB_CHANGED,
+  MESSAGE_OBSERVABILITY_DEVTOOLS_EVENT: () => MESSAGE_OBSERVABILITY_DEVTOOLS_EVENT,
+  MESSAGE_OPEN_SIDE_PANEL: () => MESSAGE_OPEN_SIDE_PANEL,
+  OBSERVABILITY_DEVTOOLS_SOURCE: () => OBSERVABILITY_DEVTOOLS_SOURCE,
+  OBSERVABILITY_DEVTOOLS_STORAGE_KEY: () => OBSERVABILITY_DEVTOOLS_STORAGE_KEY
+});
+module.exports = __toCommonJS(messages_exports);
+const MESSAGE_OPEN_SIDE_PANEL = "mf-devtools/open-side-panel";
+const MESSAGE_ACTIVE_TAB_CHANGED = "mf-devtools/active-tab-changed";
+const MESSAGE_OBSERVABILITY_DEVTOOLS_EVENT = "mf-devtools/observability-event";
+const OBSERVABILITY_DEVTOOLS_SOURCE = "module-federation/observability";
+const OBSERVABILITY_DEVTOOLS_STORAGE_KEY = "__MF_DEVTOOLS_OBSERVABILITY_CONFIG__";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MESSAGE_ACTIVE_TAB_CHANGED,
+  MESSAGE_OBSERVABILITY_DEVTOOLS_EVENT,
+  MESSAGE_OPEN_SIDE_PANEL,
+  OBSERVABILITY_DEVTOOLS_SOURCE,
+  OBSERVABILITY_DEVTOOLS_STORAGE_KEY
+});