@module-federation/devtools 0.0.0-docs-remove-invalid-lark-link-20251205062649

package/dist/lib/component/Layout/index_module.css

@@ -0,0 +1,48 @@
+.select_084ab {
+  margin-top: 1vh;
+}
+
+.card_084ab {
+  display: flex;
+  height: 4vh;
+  align-items: center;
+}
+.card_084ab .appName_084ab {
+  margin: 1vh 0;
+}
+
+.tagContainer_084ab {
+  display: flex;
+  align-items: center;
+  margin-bottom: 1vh;
+  color: rgb(78, 89, 105);
+}
+.tagContainer_084ab .tag_084ab {
+  margin-left: 1vw;
+}
+
+.header_084ab {
+  display: flex;
+  align-items: center;
+  margin: 1vh 0;
+}
+.header_084ab .add_084ab {
+  margin: 0 0.5vw;
+}
+.header_084ab .title_084ab {
+  margin: 0 0.5vw;
+}
+.header_084ab .status_084ab {
+  display: flex;
+  flex: 1 1;
+  justify-content: flex-end;
+  align-items: center;
+}
+.header_084ab .status_084ab .switch_084ab {
+  margin-left: 0.5vw;
+}
+.header_084ab .badge_084ab {
+  display: flex;
+  transform: scale(1.6);
+  margin: 0 0.6vw;
+}

package/dist/lib/init.js

@@ -0,0 +1,9 @@
+"use strict";
+if (process.env.NODE_ENV === "development") {
+  const createProxy = () => new Proxy(() => Promise.resolve({}), {
+    get: () => {
+      return createProxy();
+    }
+  });
+  window.chrome = createProxy();
+}

package/dist/lib/template/constant.js

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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 __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 constant_exports = {};
+__export(constant_exports, {
+  BROWSER_ENV_KEY: () => BROWSER_ENV_KEY,
+  ENABLEHMR: () => ENABLEHMR,
+  FormID: () => FormID,
+  __EAGER_SHARE__: () => __EAGER_SHARE__,
+  __ENABLE_FAST_REFRESH__: () => __ENABLE_FAST_REFRESH__,
+  __FEDERATION_DEVTOOLS__: () => __FEDERATION_DEVTOOLS__,
+  defaultDataItem: () => defaultDataItem,
+  defaultModuleData: () => defaultModuleData,
+  proxyFormField: () => proxyFormField,
+  statusInfo: () => statusInfo
+});
+module.exports = __toCommonJS(constant_exports);
+const FormID = "FormID";
+const ENABLEHMR = "enableHMR";
+const proxyFormField = "proxyFormField";
+const defaultDataItem = {
+  key: "",
+  value: "",
+  checked: true
+};
+const defaultModuleData = {
+  proxyFormField: [
+    __spreadValues({}, defaultDataItem)
+  ]
+};
+const statusInfo = {
+  noProxy: {
+    status: "noProxy",
+    message: "Modules are not currently proxied",
+    color: "#698cee"
+  },
+  processing: {
+    status: "processing",
+    message: "Obtaining remote module information",
+    color: "#FF7D00"
+  },
+  success: {
+    status: "success",
+    message: "The proxy configuration has taken effect and the corresponding page has been automatically refreshed.",
+    color: "#50b042"
+  },
+  error: {
+    status: "error",
+    message: "Calculating Snapshot failed, please confirm whether the package information is correct",
+    color: "#F53F3F"
+  }
+};
+const __ENABLE_FAST_REFRESH__ = "enableFastRefresh";
+const __EAGER_SHARE__ = "eagerShare";
+const BROWSER_ENV_KEY = "MF_ENV";
+const __FEDERATION_DEVTOOLS__ = "__MF_DEVTOOLS__";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BROWSER_ENV_KEY,
+  ENABLEHMR,
+  FormID,
+  __EAGER_SHARE__,
+  __ENABLE_FAST_REFRESH__,
+  __FEDERATION_DEVTOOLS__,
+  defaultDataItem,
+  defaultModuleData,
+  proxyFormField,
+  statusInfo
+});

package/dist/lib/template/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 template_exports = {};
+module.exports = __toCommonJS(template_exports);
+__reExport(template_exports, require("./constant"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./constant")
+});

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

@@ -0,0 +1,215 @@
+"use strict";
+var __defProp = Object.defineProperty;
+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 __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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_sdk = require("@module-federation/sdk");
+var import__ = require("../index");
+var import_sdk2 = require("../sdk");
+var import_constant = require("../../template/constant");
+var _a;
+const SUPPORT_PKGS = ["react", "react-dom"];
+const fetchAndExecuteUmdSync = (url) => {
+  try {
+    const response = new XMLHttpRequest();
+    response.open("GET", url, false);
+    response.overrideMimeType("text/plain");
+    response.send();
+    if (response.status === 200) {
+      const scriptContent = response.responseText;
+      const moduleFunction = new Function(scriptContent);
+      return moduleFunction(window);
+    } else {
+      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 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();
+if ((devtoolsMessage == null ? void 0 : devtoolsMessage[import_constant.__ENABLE_FAST_REFRESH__]) && (devtoolsMessage == null ? void 0 : devtoolsMessage[import_constant.__EAGER_SHARE__])) {
+  const [_name, version] = devtoolsMessage[import_constant.__EAGER_SHARE__];
+  fetchAndExecuteUmdSync((0, import__.getUnpkgUrl)("react", version));
+  fetchAndExecuteUmdSync((0, import__.getUnpkgUrl)("react-dom", version));
+}
+const fastRefreshPlugin = () => {
+  return {
+    name: "mf-fast-refresh-plugin",
+    beforeInit(_a2) {
+      var _b = _a2, { userOptions } = _b, args = __objRest(_b, ["userOptions"]);
+      const shareInfo = userOptions.shared;
+      const twinsShareInfo = args.shareInfo;
+      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 __spreadValues({
+          userOptions
+        }, args);
+      }
+      if (shareInfo && (0, import__.isObject)(shareInfo)) {
+        let orderResolve;
+        const orderPromise = new Promise((resolve) => {
+          orderResolve = resolve;
+        });
+        Object.keys(shareInfo).forEach((share) => __async(this, null, function* () {
+          const sharedArr = Array.isArray(shareInfo[share]) ? shareInfo[share] : [shareInfo[share]];
+          let twinsSharedArr;
+          if (twinsShareInfo) {
+            twinsSharedArr = Array.isArray(twinsShareInfo[share]) ? twinsShareInfo[share] : [twinsShareInfo[share]];
+          }
+          sharedArr.forEach((shared, idx) => {
+            var _a3;
+            if (!SUPPORT_PKGS.includes(share)) {
+              return;
+            }
+            if ((_a3 = shared.shareConfig) == null ? void 0 : _a3.eager) {
+              if (!(devtoolsMessage2 == null ? void 0 : devtoolsMessage2[import_constant.__EAGER_SHARE__])) {
+                const eagerShare = [];
+                eagerShare.push(share, shared.version);
+                devtoolsMessage2[import_constant.__EAGER_SHARE__] = eagerShare;
+                localStorage.setItem(
+                  import_constant.__FEDERATION_DEVTOOLS__,
+                  JSON.stringify(devtoolsMessage2)
+                );
+                window.location.reload();
+              }
+              if (share === "react-dom") {
+                shared.lib = () => window.ReactDOM;
+              }
+              if (share === "react") {
+                shared.lib = () => window.React;
+              }
+              return;
+            }
+            let get;
+            if (share === "react") {
+              get = () => (0, import_sdk.loadScript)((0, import__.getUnpkgUrl)(share, shared.version), {
+                attrs: {
+                  defer: false,
+                  async: false,
+                  "data-mf-injected": "true"
+                }
+              }).then(() => {
+                orderResolve();
+              });
+            }
+            if (share === "react-dom") {
+              get = () => orderPromise.then(
+                () => (0, import_sdk.loadScript)((0, import__.getUnpkgUrl)(share, shared.version), {
+                  attrs: { defer: true, async: false }
+                })
+              );
+            }
+            if (typeof get === "function") {
+              if (share === "react") {
+                shared.get = () => __async(this, null, function* () {
+                  if (!window.React) {
+                    yield get();
+                    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 = () => window.React;
+                  return () => window.React;
+                });
+              }
+              if (share === "react-dom") {
+                shared.get = () => __async(this, null, function* () {
+                  if (!window.ReactDOM) {
+                    yield get();
+                  }
+                  shared.lib = () => window.ReactDOM;
+                  return () => window.ReactDOM;
+                });
+              }
+              if (twinsShareInfo) {
+                twinsSharedArr[idx].get = shared.get;
+              }
+            }
+          });
+        }));
+        return __spreadValues({
+          userOptions
+        }, args);
+      } else {
+        return __spreadValues({
+          userOptions
+        }, args);
+      }
+    }
+  };
+};
+if (!(window == null ? void 0 : window.__FEDERATION__)) {
+  (0, import_sdk2.definePropertyGlobalVal)(window, "__FEDERATION__", {});
+  (0, import_sdk2.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/lib/utils/chrome/index.js

@@ -0,0 +1,245 @@
+"use strict";
+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,
+  setChromeStorage: () => setChromeStorage
+});
+module.exports = __toCommonJS(chrome_exports);
+var import_constant = require("../../template/constant");
+var import_sdk2 = require("../sdk");
+__reExport(chrome_exports, require("./storage"), module.exports);
+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
+};
+function getCurrentTabId() {
+  return TabInfo.currentTabId;
+}
+function getInspectWindowTabId() {
+  return new Promise((resolve, reject) => {
+    var _a;
+    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 = tabs.find(
+              (tab) => tab.id === tabId
+            );
+            window.targetTab = target;
+          });
+          console.log(
+            "chrome.devtools.inspectedWindow.tabId",
+            chrome.devtools.inspectedWindow.tabId
+          );
+          TabInfo.currentTabId = tabId;
+          resolve(tabId);
+          if (error) {
+            reject(error);
+          }
+        }
+      );
+    } else {
+      if (window.targetTab && window.targetTab.id) {
+        const tabId = window.targetTab.id;
+        TabInfo.currentTabId = tabId;
+        resolve(tabId);
+      } else {
+        throw Error(`can't get active tab`);
+      }
+    }
+  });
+}
+const getGlobalModuleInfo = (callback) => __async(void 0, null, function* () {
+  yield sleep(300);
+  chrome.runtime.onMessage.addListener(
+    (message) => {
+      const { origin, data } = message;
+      if (!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 = JSON.parse(
+        JSON.stringify(data == null ? void 0 : data.moduleInfo)
+      );
+      if (data == null ? void 0 : data.updateModule) {
+        const moduleIds = Object.keys(window.__FEDERATION__.originModuleInfo);
+        const shouldUpdate = !moduleIds.some(
+          (id) => id.includes(data.updateModule.name)
+        );
+        if (shouldUpdate) {
+          const destination = data.updateModule.entry || data.updateModule.version;
+          window.__FEDERATION__.originModuleInfo[`${data.updateModule.name}:${destination}`] = {
+            remoteEntry: destination,
+            version: destination
+          };
+        }
+      }
+      window.__FEDERATION__.moduleInfo = JSON.parse(
+        JSON.stringify(window.__FEDERATION__.originModuleInfo)
+      );
+      callback(window.__FEDERATION__.moduleInfo);
+    }
+  );
+  const postMessageStartUrl = getUrl("post-message-start.js");
+  yield injectScript(injectPostMessage, false, postMessageStartUrl);
+});
+const getTabs = (queryOptions = {}) => chrome.tabs.query(queryOptions);
+const getScope = () => __async(void 0, null, function* () {
+  const activeTab = window.targetTab;
+  const favIconUrl = activeTab == null ? void 0 : activeTab.favIconUrl;
+  return favIconUrl || "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(() => {
+    console.log("InjectScript success, excuteScript:", args);
+  }).catch((e) => {
+    console.log(e, "InjectScript fail, excuteScript:", args);
+  });
+});
+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,
+  setChromeStorage,
+  ...require("./storage")
+});

package/dist/lib/utils/chrome/post-message-init.js

@@ -0,0 +1,6 @@
+"use strict";
+var import_index = require("./index");
+const postMessageUrl = (0, import_index.getUrl)("post-message.js");
+const script = document.createElement("script");
+script.src = postMessageUrl;
+document.getElementsByTagName("html")[0].appendChild(script);

package/dist/lib/utils/chrome/post-message-listener.js

@@ -0,0 +1,21 @@
+"use strict";
+if (window.moduleHandler) {
+  window.removeEventListener("message", window.moduleHandler);
+} else {
+  window.moduleHandler = (event) => {
+    const { origin, data } = event;
+    if (!data.moduleInfo) {
+      return;
+    }
+    chrome.runtime.sendMessage({
+      origin,
+      data: {
+        moduleInfo: data.moduleInfo,
+        updateModule: data.updateModule
+      }
+    }).catch(() => {
+      return false;
+    });
+  };
+}
+window.addEventListener("message", window.moduleHandler);

package/dist/lib/utils/chrome/post-message-start.js

@@ -0,0 +1,9 @@
+"use strict";
+var _a;
+const moduleInfo = (_a = window == null ? void 0 : window.__FEDERATION__) == null ? void 0 : _a.moduleInfo;
+window.postMessage(
+  {
+    moduleInfo
+  },
+  "*"
+);