@vc-shell/framework 1.2.4-beta.8 → 2.0.0-alpha.1

package/dist/vendor-module-federation-runtime-core-D5G-s9nP.js

@@ -0,0 +1,2202 @@
+import { r as D } from "./vendor-module-federation-sdk-DM4AJRa7.js";
+import { r as ee } from "./vendor-module-federation-error-codes-DdVwX11j.js";
+var Se = {}, Z = {}, Le;
+function L() {
+  if (Le) return Z;
+  Le = 1;
+  let a = /* @__PURE__ */ D();
+  const l = "[ Federation Runtime ]", y = (0, a.createLogger)(l);
+  function p(u, m) {
+    u || _(m);
+  }
+  function _(u) {
+    throw u instanceof Error ? (u.message.startsWith(l) || (u.message = `${l}: ${u.message}`), u) : new Error(`${l}: ${u}`);
+  }
+  function g(u) {
+    u instanceof Error && (u.message.startsWith(l) || (u.message = `${l}: ${u.message}`)), y.warn(u);
+  }
+  return Z.assert = p, Z.error = _, Z.logger = y, Z.warn = g, Z;
+}
+var F = {}, Ce;
+function B() {
+  if (Ce) return F;
+  Ce = 1;
+  const a = L();
+  let l = /* @__PURE__ */ D();
+  function y(o, r) {
+    return o.findIndex((i) => i === r) === -1 && o.push(r), o;
+  }
+  function p(o) {
+    return "version" in o && o.version ? `${o.name}:${o.version}` : "entry" in o && o.entry ? `${o.name}:${o.entry}` : `${o.name}`;
+  }
+  function _(o) {
+    return typeof o.entry < "u";
+  }
+  function g(o) {
+    return !o.entry.includes(".json");
+  }
+  async function u(o, r) {
+    try {
+      return await o();
+    } catch (i) {
+      !r && a.warn(i);
+      return;
+    }
+  }
+  function m(o) {
+    return o && typeof o == "object";
+  }
+  const T = Object.prototype.toString;
+  function f(o) {
+    return T.call(o) === "[object Object]";
+  }
+  function S(o, r) {
+    const i = /^(https?:)?\/\//i;
+    return o.replace(i, "").replace(/\/$/, "") === r.replace(i, "").replace(/\/$/, "");
+  }
+  function e(o) {
+    return Array.isArray(o) ? o : [o];
+  }
+  function E(o) {
+    const r = {
+      url: "",
+      type: "global",
+      globalName: ""
+    };
+    return (0, l.isBrowserEnv)() || (0, l.isReactNativeEnv)() || !("ssrRemoteEntry" in o) ? "remoteEntry" in o ? {
+      url: o.remoteEntry,
+      type: o.remoteEntryType,
+      globalName: o.globalName
+    } : r : "ssrRemoteEntry" in o ? {
+      url: o.ssrRemoteEntry || r.url,
+      type: o.ssrRemoteEntryType || r.type,
+      globalName: o.globalName
+    } : r;
+  }
+  const k = (o, r) => {
+    let i;
+    return o.endsWith("/") ? i = o.slice(0, -1) : i = o, r.startsWith(".") && (r = r.slice(1)), i = i + r, i;
+  };
+  return F.addUniqueItem = y, F.arrayOptions = e, F.getFMId = p, F.getRemoteEntryInfoFromSnapshot = E, F.isObject = m, F.isPlainObject = f, F.isPureRemoteEntry = g, F.isRemoteInfoWithEntry = _, F.isStaticResourcesEqual = S, F.objectToString = T, F.processModuleAlias = k, F.safeWrapper = u, F;
+}
+var G = {}, Fe;
+function K() {
+  if (Fe) return G;
+  Fe = 1;
+  const a = L(), l = B();
+  let y = /* @__PURE__ */ D();
+  const p = typeof globalThis == "object" ? globalThis : window, _ = (() => {
+    try {
+      return document.defaultView;
+    } catch {
+      return p;
+    }
+  })(), g = _;
+  function u(s, b, R) {
+    Object.defineProperty(s, b, {
+      value: R,
+      configurable: !1,
+      writable: !0
+    });
+  }
+  function m(s, b) {
+    return Object.hasOwnProperty.call(s, b);
+  }
+  m(p, "__GLOBAL_LOADING_REMOTE_ENTRY__") || u(p, "__GLOBAL_LOADING_REMOTE_ENTRY__", {});
+  const T = p.__GLOBAL_LOADING_REMOTE_ENTRY__;
+  function f(s) {
+    m(s, "__VMOK__") && !m(s, "__FEDERATION__") && u(s, "__FEDERATION__", s.__VMOK__), m(s, "__FEDERATION__") || (u(s, "__FEDERATION__", {
+      __GLOBAL_PLUGIN__: [],
+      __INSTANCES__: [],
+      moduleInfo: {},
+      __SHARE__: {},
+      __MANIFEST_LOADING__: {},
+      __PRELOADED_MAP__: /* @__PURE__ */ new Map()
+    }), u(s, "__VMOK__", s.__FEDERATION__)), s.__FEDERATION__.__GLOBAL_PLUGIN__ ??= [], s.__FEDERATION__.__INSTANCES__ ??= [], s.__FEDERATION__.moduleInfo ??= {}, s.__FEDERATION__.__SHARE__ ??= {}, s.__FEDERATION__.__MANIFEST_LOADING__ ??= {}, s.__FEDERATION__.__PRELOADED_MAP__ ??= /* @__PURE__ */ new Map();
+  }
+  f(p), f(_);
+  function S() {
+    p.__FEDERATION__.__GLOBAL_PLUGIN__ = [], p.__FEDERATION__.__INSTANCES__ = [], p.__FEDERATION__.moduleInfo = {}, p.__FEDERATION__.__SHARE__ = {}, p.__FEDERATION__.__MANIFEST_LOADING__ = {}, Object.keys(T).forEach((s) => {
+      delete T[s];
+    });
+  }
+  function e(s) {
+    p.__FEDERATION__.__INSTANCES__.push(s);
+  }
+  function E() {
+    return p.__FEDERATION__.__DEBUG_CONSTRUCTOR__;
+  }
+  function k(s, b = (0, y.isDebugMode)()) {
+    b && (p.__FEDERATION__.__DEBUG_CONSTRUCTOR__ = s, p.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "2.1.0");
+  }
+  function o(s, b) {
+    if (typeof b == "string") {
+      if (s[b]) return {
+        value: s[b],
+        key: b
+      };
+      {
+        const R = Object.keys(s);
+        for (const q of R) {
+          const [$, H] = q.split(":"), P = `${$}:${b}`, O = s[P];
+          if (O) return {
+            value: O,
+            key: P
+          };
+        }
+        return {
+          value: void 0,
+          key: b
+        };
+      }
+    } else throw new Error("key must be string");
+  }
+  const r = () => _.__FEDERATION__.moduleInfo, i = (s, b) => {
+    const R = o(b, l.getFMId(s)).value;
+    if (R && !R.version && "version" in s && s.version && (R.version = s.version), R) return R;
+    if ("version" in s && s.version) {
+      const { version: q, ...$ } = s, H = l.getFMId($), P = o(_.__FEDERATION__.moduleInfo, H).value;
+      if (P?.version === q) return P;
+    }
+  }, n = (s) => i(s, _.__FEDERATION__.moduleInfo), d = (s, b) => {
+    const R = l.getFMId(s);
+    return _.__FEDERATION__.moduleInfo[R] = b, _.__FEDERATION__.moduleInfo;
+  }, v = (s) => (_.__FEDERATION__.moduleInfo = {
+    ..._.__FEDERATION__.moduleInfo,
+    ...s
+  }, () => {
+    const b = Object.keys(s);
+    for (const R of b) delete _.__FEDERATION__.moduleInfo[R];
+  }), A = (s, b) => {
+    const R = b || `__FEDERATION_${s}:custom__`;
+    return {
+      remoteEntryKey: R,
+      entryExports: p[R]
+    };
+  }, c = (s) => {
+    const { __GLOBAL_PLUGIN__: b } = _.__FEDERATION__;
+    s.forEach((R) => {
+      b.findIndex((q) => q.name === R.name) === -1 ? b.push(R) : a.warn(`The plugin ${R.name} has been registered.`);
+    });
+  }, h = () => _.__FEDERATION__.__GLOBAL_PLUGIN__, t = (s) => p.__FEDERATION__.__PRELOADED_MAP__.get(s), I = (s) => p.__FEDERATION__.__PRELOADED_MAP__.set(s, !0);
+  return G.CurrentGlobal = p, G.Global = g, G.addGlobalSnapshot = v, G.getGlobalFederationConstructor = E, G.getGlobalHostPlugins = h, G.getGlobalSnapshot = r, G.getGlobalSnapshotInfoByModuleInfo = n, G.getInfoWithoutType = o, G.getPreloaded = t, G.getRemoteEntryExports = A, G.getTargetSnapshotInfoByModuleInfo = i, G.globalLoading = T, G.nativeGlobal = _, G.registerGlobalPlugins = c, G.resetFederationGlobalInfo = S, G.setGlobalFederationConstructor = k, G.setGlobalFederationInstance = e, G.setGlobalSnapshotInfoByModuleInfo = d, G.setPreloaded = I, G;
+}
+var Ee = {}, z = {}, W = {}, De;
+function yt() {
+  if (De) return W;
+  De = 1;
+  const a = "[0-9A-Za-z-]+", l = `(?:\\+(${a}(?:\\.${a})*))`, y = "0|[1-9]\\d*", p = "[0-9]+", _ = "\\d*[a-zA-Z-][a-zA-Z0-9-]*", g = `(?:${p}|${_})`, u = `(?:-?(${g}(?:\\.${g})*))`, m = `(?:${y}|${_})`, T = `(?:-(${m}(?:\\.${m})*))`, f = `${y}|x|X|\\*`, S = `[v=\\s]*(${f})(?:\\.(${f})(?:\\.(${f})(?:${T})?${l}?)?)?`, e = `^\\s*(${S})\\s+-\\s+(${S})\\s*$`, E = `[v=\\s]*${`(${p})\\.(${p})\\.(${p})`}${u}?${l}?`, k = "((?:<|>)?=?)", o = `(\\s*)${k}\\s*(${E}|${S})`, r = "(?:~>?)", i = `(\\s*)${r}\\s+`, n = "(?:\\^)", d = `(\\s*)${n}\\s+`, v = "(<|>)?=?\\s*\\*", A = `^${n}${S}$`, c = `v?${`(${y})\\.(${y})\\.(${y})`}${T}?${l}?`, h = `^${r}${S}$`, t = `^${k}\\s*${S}$`, I = `^${k}\\s*(${c})$|^$`, s = "^\\s*>=\\s*0.0.0\\s*$";
+  return W.caret = A, W.caretTrim = d, W.comparator = I, W.comparatorTrim = o, W.gte0 = s, W.hyphenRange = e, W.star = v, W.tilde = h, W.tildeTrim = i, W.xRange = t, W;
+}
+var xe;
+function St() {
+  if (xe) return z;
+  xe = 1;
+  const a = yt();
+  function l(u) {
+    return new RegExp(u);
+  }
+  function y(u) {
+    return !u || u.toLowerCase() === "x" || u === "*";
+  }
+  function p(...u) {
+    return (m) => u.reduce((T, f) => f(T), m);
+  }
+  function _(u) {
+    return u.match(l(a.comparator));
+  }
+  function g(u, m, T, f) {
+    const S = `${u}.${m}.${T}`;
+    return f ? `${S}-${f}` : S;
+  }
+  return z.combineVersion = g, z.extractComparator = _, z.isXVersion = y, z.parseRegex = l, z.pipe = p, z;
+}
+var U = {}, We;
+function kt() {
+  if (We) return U;
+  We = 1;
+  const a = yt(), l = St();
+  function y(e) {
+    return e.replace(l.parseRegex(a.hyphenRange), (E, k, o, r, i, n, d, v, A, c, h, t) => (l.isXVersion(o) ? k = "" : l.isXVersion(r) ? k = `>=${o}.0.0` : l.isXVersion(i) ? k = `>=${o}.${r}.0` : k = `>=${k}`, l.isXVersion(A) ? v = "" : l.isXVersion(c) ? v = `<${Number(A) + 1}.0.0-0` : l.isXVersion(h) ? v = `<${A}.${Number(c) + 1}.0-0` : t ? v = `<=${A}.${c}.${h}-${t}` : v = `<=${v}`, `${k} ${v}`.trim()));
+  }
+  function p(e) {
+    return e.replace(l.parseRegex(a.comparatorTrim), "$1$2$3");
+  }
+  function _(e) {
+    return e.replace(l.parseRegex(a.tildeTrim), "$1~");
+  }
+  function g(e) {
+    return e.replace(l.parseRegex(a.caretTrim), "$1^");
+  }
+  function u(e) {
+    return e.trim().split(/\s+/).map((E) => E.replace(l.parseRegex(a.caret), (k, o, r, i, n) => l.isXVersion(o) ? "" : l.isXVersion(r) ? `>=${o}.0.0 <${Number(o) + 1}.0.0-0` : l.isXVersion(i) ? o === "0" ? `>=${o}.${r}.0 <${o}.${Number(r) + 1}.0-0` : `>=${o}.${r}.0 <${Number(o) + 1}.0.0-0` : n ? o === "0" ? r === "0" ? `>=${o}.${r}.${i}-${n} <${o}.${r}.${Number(i) + 1}-0` : `>=${o}.${r}.${i}-${n} <${o}.${Number(r) + 1}.0-0` : `>=${o}.${r}.${i}-${n} <${Number(o) + 1}.0.0-0` : o === "0" ? r === "0" ? `>=${o}.${r}.${i} <${o}.${r}.${Number(i) + 1}-0` : `>=${o}.${r}.${i} <${o}.${Number(r) + 1}.0-0` : `>=${o}.${r}.${i} <${Number(o) + 1}.0.0-0`)).join(" ");
+  }
+  function m(e) {
+    return e.trim().split(/\s+/).map((E) => E.replace(l.parseRegex(a.tilde), (k, o, r, i, n) => l.isXVersion(o) ? "" : l.isXVersion(r) ? `>=${o}.0.0 <${Number(o) + 1}.0.0-0` : l.isXVersion(i) ? `>=${o}.${r}.0 <${o}.${Number(r) + 1}.0-0` : n ? `>=${o}.${r}.${i}-${n} <${o}.${Number(r) + 1}.0-0` : `>=${o}.${r}.${i} <${o}.${Number(r) + 1}.0-0`)).join(" ");
+  }
+  function T(e) {
+    return e.split(/\s+/).map((E) => E.trim().replace(l.parseRegex(a.xRange), (k, o, r, i, n, d) => {
+      const v = l.isXVersion(r), A = v || l.isXVersion(i), c = A || l.isXVersion(n);
+      return o === "=" && c && (o = ""), d = "", v ? o === ">" || o === "<" ? "<0.0.0-0" : "*" : o && c ? (A && (i = 0), n = 0, o === ">" ? (o = ">=", A ? (r = Number(r) + 1, i = 0, n = 0) : (i = Number(i) + 1, n = 0)) : o === "<=" && (o = "<", A ? r = Number(r) + 1 : i = Number(i) + 1), o === "<" && (d = "-0"), `${o + r}.${i}.${n}${d}`) : A ? `>=${r}.0.0${d} <${Number(r) + 1}.0.0-0` : c ? `>=${r}.${i}.0${d} <${r}.${Number(i) + 1}.0-0` : k;
+    })).join(" ");
+  }
+  function f(e) {
+    return e.trim().replace(l.parseRegex(a.star), "");
+  }
+  function S(e) {
+    return e.trim().replace(l.parseRegex(a.gte0), "");
+  }
+  return U.parseCaretTrim = g, U.parseCarets = u, U.parseComparatorTrim = p, U.parseGTE0 = S, U.parseHyphen = y, U.parseStar = f, U.parseTildeTrim = _, U.parseTildes = m, U.parseXRanges = T, U;
+}
+var be = {}, Ue;
+function Tt() {
+  if (Ue) return be;
+  Ue = 1;
+  function a(g, u) {
+    return g = Number(g) || g, u = Number(u) || u, g > u ? 1 : g === u ? 0 : -1;
+  }
+  function l(g, u) {
+    const { preRelease: m } = g, { preRelease: T } = u;
+    if (m === void 0 && T) return 1;
+    if (m && T === void 0) return -1;
+    if (m === void 0 && T === void 0) return 0;
+    for (let f = 0, S = m.length; f <= S; f++) {
+      const e = m[f], E = T[f];
+      if (e !== E)
+        return e === void 0 && E === void 0 ? 0 : e ? E ? a(e, E) : -1 : 1;
+    }
+    return 0;
+  }
+  function y(g, u) {
+    return a(g.major, u.major) || a(g.minor, u.minor) || a(g.patch, u.patch) || l(g, u);
+  }
+  function p(g, u) {
+    return g.version === u.version;
+  }
+  function _(g, u) {
+    switch (g.operator) {
+      case "":
+      case "=":
+        return p(g, u);
+      case ">":
+        return y(g, u) < 0;
+      case ">=":
+        return p(g, u) || y(g, u) < 0;
+      case "<":
+        return y(g, u) > 0;
+      case "<=":
+        return p(g, u) || y(g, u) > 0;
+      case void 0:
+        return !0;
+      default:
+        return !1;
+    }
+  }
+  return be.compare = _, be;
+}
+var Be;
+function Et() {
+  if (Be) return Ee;
+  Be = 1;
+  const a = St(), l = kt(), y = Tt();
+  function p(u) {
+    return a.pipe(l.parseCarets, l.parseTildes, l.parseXRanges, l.parseStar)(u);
+  }
+  function _(u) {
+    return a.pipe(l.parseHyphen, l.parseComparatorTrim, l.parseTildeTrim, l.parseCaretTrim)(u.trim()).split(/\s+/).join(" ");
+  }
+  function g(u, m) {
+    if (!u) return !1;
+    const T = a.extractComparator(u);
+    if (!T) return !1;
+    const [, f, , S, e, E, k] = T, o = {
+      operator: f,
+      version: a.combineVersion(S, e, E, k),
+      major: S,
+      minor: e,
+      patch: E,
+      preRelease: k?.split(".")
+    }, r = m.split("||");
+    for (const i of r) {
+      const n = i.trim();
+      if (!n || n === "*" || n === "x") return !0;
+      try {
+        const d = _(n);
+        if (!d.trim()) return !0;
+        const v = d.split(" ").map((h) => p(h)).join(" ");
+        if (!v.trim()) return !0;
+        const A = v.split(/\s+/).map((h) => l.parseGTE0(h)).filter(Boolean);
+        if (A.length === 0) continue;
+        let c = !0;
+        for (const h of A) {
+          const t = a.extractComparator(h);
+          if (!t) {
+            c = !1;
+            break;
+          }
+          const [, I, , s, b, R, q] = t;
+          if (!y.compare({
+            operator: I,
+            version: a.combineVersion(s, b, R, q),
+            major: s,
+            minor: b,
+            patch: R,
+            preRelease: q?.split(".")
+          }, o)) {
+            c = !1;
+            break;
+          }
+        }
+        if (c) return !0;
+      } catch (d) {
+        console.error(`[semver] Error processing range part "${n}":`, d);
+        continue;
+      }
+    }
+    return !1;
+  }
+  return Ee.satisfy = g, Ee;
+}
+var j = {}, de = {}, Ve;
+function se() {
+  if (Ve) return de;
+  Ve = 1;
+  const a = "default", l = "global";
+  return de.DEFAULT_REMOTE_TYPE = l, de.DEFAULT_SCOPE = a, de;
+}
+var je;
+function te() {
+  if (je) return j;
+  je = 1;
+  const a = L(), l = B(), y = K(), p = se(), _ = Et();
+  let g = /* @__PURE__ */ D();
+  function u(t, I, s, b) {
+    let R;
+    if ("get" in t ? R = t.get : "lib" in t ? R = () => Promise.resolve(t.lib) : R = () => Promise.resolve(() => {
+      throw new Error(`Can not get shared '${s}'!`);
+    }), t.shareConfig?.eager && t.treeShaking?.mode) throw new Error('Can not set "eager:true" and "treeShaking" at the same time!');
+    return {
+      deps: [],
+      useIn: [],
+      from: I,
+      loading: null,
+      ...t,
+      shareConfig: {
+        requiredVersion: `^${t.version}`,
+        singleton: !1,
+        eager: !1,
+        strictVersion: !1,
+        ...t.shareConfig
+      },
+      get: R,
+      loaded: t?.loaded || "lib" in t ? !0 : void 0,
+      version: t.version ?? "0",
+      scope: Array.isArray(t.scope) ? t.scope : [t.scope ?? "default"],
+      strategy: (t.strategy ?? b) || "version-first",
+      treeShaking: t.treeShaking ? {
+        ...t.treeShaking,
+        mode: t.treeShaking.mode ?? "server-calc",
+        status: t.treeShaking.status ?? g.TreeShakingStatus.UNKNOWN,
+        useIn: []
+      } : void 0
+    };
+  }
+  function m(t, I) {
+    const s = I.shared || {}, b = I.name, R = Object.keys(s).reduce(($, H) => {
+      const P = l.arrayOptions(s[H]);
+      return $[H] = $[H] || [], P.forEach((O) => {
+        $[H].push(u(O, b, H, I.shareStrategy));
+      }), $;
+    }, {}), q = { ...t.shared };
+    return Object.keys(R).forEach(($) => {
+      q[$] ? R[$].forEach((H) => {
+        q[$].find((P) => P.version === H.version) || q[$].push(H);
+      }) : q[$] = R[$];
+    }), {
+      allShareInfos: q,
+      newShareInfos: R
+    };
+  }
+  function T(t, I) {
+    if (!t) return !1;
+    const { status: s, mode: b } = t;
+    return s === g.TreeShakingStatus.NO_USE ? !1 : s === g.TreeShakingStatus.CALCULATED ? !0 : b === "runtime-infer" ? I ? k(t, I) : !0 : !1;
+  }
+  function f(t, I) {
+    const s = (b) => {
+      if (!Number.isNaN(Number(b))) {
+        const R = b.split(".");
+        let q = b;
+        for (let $ = 0; $ < 3 - R.length; $++) q += ".0";
+        return q;
+      }
+      return b;
+    };
+    return !!_.satisfy(s(t), `<=${s(I)}`);
+  }
+  const S = (t, I) => {
+    const s = I || function(b, R) {
+      return f(b, R);
+    };
+    return Object.keys(t).reduce((b, R) => !b || s(b, R) || b === "0" ? R : b, 0);
+  }, e = (t) => !!t.loaded || typeof t.lib == "function", E = (t) => !!t.loading, k = (t, I) => {
+    if (!t || !I) return !1;
+    const { usedExports: s } = t;
+    return s ? !!I.every((b) => s.includes(b)) : !1;
+  };
+  function o(t, I, s, b) {
+    const R = t[I][s];
+    let q = "", $ = T(b);
+    const H = function(P, O) {
+      return $ ? R[P].treeShaking ? R[O].treeShaking ? !e(R[P].treeShaking) && f(P, O) : !1 : !0 : !e(R[P]) && f(P, O);
+    };
+    if ($) {
+      if (q = S(t[I][s], H), q) return {
+        version: q,
+        useTreesShaking: $
+      };
+      $ = !1;
+    }
+    return {
+      version: S(t[I][s], H),
+      useTreesShaking: $
+    };
+  }
+  const r = (t) => e(t) || E(t);
+  function i(t, I, s, b) {
+    const R = t[I][s];
+    let q = "", $ = T(b);
+    const H = function(P, O) {
+      if ($) {
+        if (!R[P].treeShaking) return !0;
+        if (!R[O].treeShaking) return !1;
+        if (r(R[O].treeShaking)) return r(R[P].treeShaking) ? !!f(P, O) : !0;
+        if (r(R[P].treeShaking)) return !1;
+      }
+      return r(R[O]) ? r(R[P]) ? !!f(P, O) : !0 : r(R[P]) ? !1 : f(P, O);
+    };
+    if ($) {
+      if (q = S(t[I][s], H), q) return {
+        version: q,
+        useTreesShaking: $
+      };
+      $ = !1;
+    }
+    return {
+      version: S(t[I][s], H),
+      useTreesShaking: $
+    };
+  }
+  function n(t) {
+    return t === "loaded-first" ? i : o;
+  }
+  function d(t, I, s, b) {
+    if (!t) return;
+    const { shareConfig: R, scope: q = p.DEFAULT_SCOPE, strategy: $, treeShaking: H } = s, P = Array.isArray(q) ? q : [q];
+    for (const O of P) if (R && t[O] && t[O][I]) {
+      const { requiredVersion: N } = R, { version: w, useTreesShaking: M } = n($)(t, O, I, H), x = () => {
+        const X = t[O][I][w];
+        if (R.singleton) {
+          if (typeof N == "string" && !_.satisfy(w, N)) {
+            const C = `Version ${w} from ${w && X.from} of shared singleton module ${I} does not satisfy the requirement of ${s.from} which needs ${N})`;
+            R.strictVersion ? a.error(C) : a.warn(C);
+          }
+          return {
+            shared: X,
+            useTreesShaking: M
+          };
+        } else {
+          if (N === !1 || N === "*") return {
+            shared: X,
+            useTreesShaking: M
+          };
+          if (_.satisfy(w, N)) return {
+            shared: X,
+            useTreesShaking: M
+          };
+          const C = T(H);
+          if (C) {
+            for (const [oe, fe] of Object.entries(t[O][I]))
+              if (T(fe.treeShaking, H?.usedExports) && _.satisfy(oe, N))
+                return {
+                  shared: fe,
+                  useTreesShaking: C
+                };
+          }
+          for (const [oe, fe] of Object.entries(t[O][I])) if (_.satisfy(oe, N)) return {
+            shared: fe,
+            useTreesShaking: !1
+          };
+        }
+      }, Y = {
+        shareScopeMap: t,
+        scope: O,
+        pkgName: I,
+        version: w,
+        GlobalFederation: y.Global.__FEDERATION__,
+        shareInfo: s,
+        resolver: x
+      };
+      return (b.emit(Y) || Y).resolver();
+    }
+  }
+  function v() {
+    return y.Global.__FEDERATION__.__SHARE__;
+  }
+  function A(t) {
+    const { pkgName: I, extraOptions: s, shareInfos: b } = t, R = (P) => {
+      if (!P) return;
+      const O = {};
+      return P.forEach((w) => {
+        O[w.version] = w;
+      }), O[S(O, function(w, M) {
+        return !e(O[w]) && f(w, M);
+      })];
+    }, q = s?.resolver ?? R, $ = (P) => P !== null && typeof P == "object" && !Array.isArray(P), H = (...P) => {
+      const O = {};
+      for (const N of P)
+        if (N)
+          for (const [w, M] of Object.entries(N)) {
+            const x = O[w];
+            $(x) && $(M) ? O[w] = H(x, M) : M !== void 0 && (O[w] = M);
+          }
+      return O;
+    };
+    return H(q(b[I]), s?.customShareInfo);
+  }
+  const c = (t, I) => {
+    t.useIn || (t.useIn = []), l.addUniqueItem(t.useIn, I);
+  };
+  function h(t, I) {
+    return I && t.treeShaking ? t.treeShaking : t;
+  }
+  return j.addUseIn = c, j.directShare = h, j.formatShareConfigs = m, j.getGlobalShareScope = v, j.getRegisteredShare = d, j.getTargetSharedOptions = A, j.shouldUseTreeShaking = T, j;
+}
+var he = {}, Xe;
+function ie() {
+  if (Xe) return he;
+  Xe = 1;
+  function a(y, p) {
+    for (const _ of y) {
+      const g = p.startsWith(_.name);
+      let u = p.replace(_.name, "");
+      if (g) {
+        if (u.startsWith("/")) {
+          const f = _.name;
+          return u = `.${u}`, {
+            pkgNameOrAlias: f,
+            expose: u,
+            remote: _
+          };
+        } else if (u === "") return {
+          pkgNameOrAlias: _.name,
+          expose: ".",
+          remote: _
+        };
+      }
+      const m = _.alias && p.startsWith(_.alias);
+      let T = _.alias && p.replace(_.alias, "");
+      if (_.alias && m) {
+        if (T && T.startsWith("/")) {
+          const f = _.alias;
+          return T = `.${T}`, {
+            pkgNameOrAlias: f,
+            expose: T,
+            remote: _
+          };
+        } else if (T === "") return {
+          pkgNameOrAlias: _.alias,
+          expose: ".",
+          remote: _
+        };
+      }
+    }
+  }
+  function l(y, p) {
+    for (const _ of y)
+      if (p === _.name || _.alias && p === _.alias) return _;
+  }
+  return he.matchRemote = l, he.matchRemoteWithNameAndExpose = a, he;
+}
+var ne = {}, Ke;
+function J() {
+  if (Ke) return ne;
+  Ke = 1;
+  const a = L(), l = K(), y = se();
+  let p = /* @__PURE__ */ D(), _ = /* @__PURE__ */ ee();
+  const g = ".then(callbacks[0]).catch(callbacks[1])";
+  async function u({ entry: r, remoteEntryExports: i }) {
+    return new Promise((n, d) => {
+      try {
+        i ? n(i) : typeof FEDERATION_ALLOW_NEW_FUNCTION < "u" ? new Function("callbacks", `import("${r}")${g}`)([n, d]) : import(
+          /* webpackIgnore: true */
+          /* @vite-ignore */
+          r
+        ).then(n).catch(d);
+      } catch (v) {
+        d(v);
+      }
+    });
+  }
+  async function m({ entry: r, remoteEntryExports: i }) {
+    return new Promise((n, d) => {
+      try {
+        i ? n(i) : typeof __system_context__ > "u" ? System.import(r).then(n).catch(d) : new Function("callbacks", `System.import("${r}")${g}`)([n, d]);
+      } catch (v) {
+        d(v);
+      }
+    });
+  }
+  function T(r, i, n) {
+    const { remoteEntryKey: d, entryExports: v } = l.getRemoteEntryExports(r, i);
+    return a.assert(v, (0, _.getShortErrorMsg)(_.RUNTIME_001, _.runtimeDescMap, {
+      remoteName: r,
+      remoteEntryUrl: n,
+      remoteEntryKey: d
+    })), v;
+  }
+  async function f({ name: r, globalName: i, entry: n, loaderHook: d, getEntryUrl: v }) {
+    const { entryExports: A } = l.getRemoteEntryExports(r, i);
+    return A || (0, p.loadScript)(v ? v(n) : n, {
+      attrs: {},
+      createScriptHook: (c, h) => {
+        const t = d.lifecycle.createScript.emit({
+          url: c,
+          attrs: h
+        });
+        if (t && (t instanceof HTMLScriptElement || "script" in t || "timeout" in t))
+          return t;
+      }
+    }).then(() => T(r, i, n)).catch((c) => {
+      throw a.assert(void 0, (0, _.getShortErrorMsg)(_.RUNTIME_008, _.runtimeDescMap, {
+        remoteName: r,
+        resourceUrl: n
+      })), c;
+    });
+  }
+  async function S({ remoteInfo: r, remoteEntryExports: i, loaderHook: n, getEntryUrl: d }) {
+    const { entry: v, entryGlobalName: A, name: c, type: h } = r;
+    switch (h) {
+      case "esm":
+      case "module":
+        return u({
+          entry: v,
+          remoteEntryExports: i
+        });
+      case "system":
+        return m({
+          entry: v,
+          remoteEntryExports: i
+        });
+      default:
+        return f({
+          entry: v,
+          globalName: A,
+          name: c,
+          loaderHook: n,
+          getEntryUrl: d
+        });
+    }
+  }
+  async function e({ remoteInfo: r, loaderHook: i }) {
+    const { entry: n, entryGlobalName: d, name: v, type: A } = r, { entryExports: c } = l.getRemoteEntryExports(v, d);
+    return c || (0, p.loadScriptNode)(n, {
+      attrs: {
+        name: v,
+        globalName: d,
+        type: A
+      },
+      loaderHook: { createScriptHook: (h, t = {}) => {
+        const I = i.lifecycle.createScript.emit({
+          url: h,
+          attrs: t
+        });
+        if (I && "url" in I)
+          return I;
+      } }
+    }).then(() => T(v, d, n)).catch((h) => {
+      throw h;
+    });
+  }
+  function E(r) {
+    const { entry: i, name: n } = r;
+    return (0, p.composeKeyWithSeparator)(n, i);
+  }
+  async function k(r) {
+    const { origin: i, remoteEntryExports: n, remoteInfo: d, getEntryUrl: v, _inErrorHandling: A = !1 } = r, c = E(d);
+    if (n) return n;
+    if (!l.globalLoading[c]) {
+      const h = i.remoteHandler.hooks.lifecycle.loadEntry, t = i.loaderHook;
+      l.globalLoading[c] = h.emit({
+        loaderHook: t,
+        remoteInfo: d,
+        remoteEntryExports: n
+      }).then((I) => I || ((typeof ENV_TARGET < "u" ? ENV_TARGET === "web" : (0, p.isBrowserEnv)()) ? S({
+        remoteInfo: d,
+        remoteEntryExports: n,
+        loaderHook: t,
+        getEntryUrl: v
+      }) : e({
+        remoteInfo: d,
+        loaderHook: t
+      }))).catch(async (I) => {
+        const s = E(d);
+        if (I instanceof Error && I.message.includes(_.RUNTIME_008) && !A) {
+          const b = (q) => k({
+            ...q,
+            _inErrorHandling: !0
+          }), R = await i.loaderHook.lifecycle.loadEntryError.emit({
+            getRemoteEntry: b,
+            origin: i,
+            remoteInfo: d,
+            remoteEntryExports: n,
+            globalLoading: l.globalLoading,
+            uniqueKey: s
+          });
+          if (R) return R;
+        }
+        throw I;
+      });
+    }
+    return l.globalLoading[c];
+  }
+  function o(r) {
+    return {
+      ...r,
+      entry: "entry" in r ? r.entry : "",
+      type: r.type || y.DEFAULT_REMOTE_TYPE,
+      entryGlobalName: r.entryGlobalName || r.name,
+      shareScope: r.shareScope || y.DEFAULT_SCOPE
+    };
+  }
+  return ne.getRemoteEntry = k, ne.getRemoteEntryUniqueKey = E, ne.getRemoteInfo = o, ne;
+}
+var ze = {}, Re = {}, Je;
+function bt() {
+  if (Je) return Re;
+  Je = 1;
+  function a() {
+    return typeof FEDERATION_BUILD_IDENTIFIER < "u" ? FEDERATION_BUILD_IDENTIFIER : "";
+  }
+  return Re.getBuilderId = a, Re;
+}
+var Ie = {}, Ye;
+function Rt() {
+  if (Ye) return Ie;
+  Ye = 1;
+  const a = K();
+  function l(y, p) {
+    const _ = a.getGlobalHostPlugins(), g = [
+      p.hooks,
+      p.remoteHandler.hooks,
+      p.sharedHandler.hooks,
+      p.snapshotHandler.hooks,
+      p.loaderHook,
+      p.bridgeHook
+    ];
+    return _.length > 0 && _.forEach((u) => {
+      y?.find((m) => m.name !== u.name) && y.push(u);
+    }), y && y.length > 0 && y.forEach((u) => {
+      g.forEach((m) => {
+        m.applyPlugin(u, p);
+      });
+    }), y;
+  }
+  return Ie.registerPlugins = l, Ie;
+}
+var Ze;
+function V() {
+  return Ze || (Ze = 1, L(), B(), bt(), ie(), Rt(), J()), ze;
+}
+var ve = {}, Q = {}, Qe;
+function ge() {
+  if (Qe) return Q;
+  Qe = 1;
+  const a = L(), l = ie(), y = J();
+  let p = /* @__PURE__ */ D();
+  function _(T) {
+    return {
+      resourceCategory: "sync",
+      share: !0,
+      depsRemote: !0,
+      prefetchInterface: !1,
+      ...T
+    };
+  }
+  function g(T, f) {
+    return f.map((S) => {
+      const e = l.matchRemote(T, S.nameOrAlias);
+      return a.assert(e, `Unable to preload ${S.nameOrAlias} as it is not included in ${!e && (0, p.safeToString)({
+        remoteInfo: e,
+        remotes: T
+      })}`), {
+        remote: e,
+        preloadConfig: _(S)
+      };
+    });
+  }
+  function u(T) {
+    return T ? T.map((f) => f === "." ? f : f.startsWith("./") ? f.replace("./", "") : f) : [];
+  }
+  function m(T, f, S, e = !0) {
+    const { cssAssets: E, jsAssetsWithoutEntry: k, entryAssets: o } = S;
+    if (f.options.inBrowser) {
+      if (o.forEach((r) => {
+        const { moduleInfo: i } = r, n = f.moduleCache.get(T.name);
+        n ? y.getRemoteEntry({
+          origin: f,
+          remoteInfo: i,
+          remoteEntryExports: n.remoteEntryExports
+        }) : y.getRemoteEntry({
+          origin: f,
+          remoteInfo: i,
+          remoteEntryExports: void 0
+        });
+      }), e) {
+        const r = {
+          rel: "preload",
+          as: "style"
+        };
+        E.forEach((i) => {
+          const { link: n, needAttach: d } = (0, p.createLink)({
+            url: i,
+            cb: () => {
+            },
+            attrs: r,
+            createLinkHook: (v, A) => {
+              const c = f.loaderHook.lifecycle.createLink.emit({
+                url: v,
+                attrs: A
+              });
+              if (c instanceof HTMLLinkElement) return c;
+            }
+          });
+          d && document.head.appendChild(n);
+        });
+      } else {
+        const r = {
+          rel: "stylesheet",
+          type: "text/css"
+        };
+        E.forEach((i) => {
+          const { link: n, needAttach: d } = (0, p.createLink)({
+            url: i,
+            cb: () => {
+            },
+            attrs: r,
+            createLinkHook: (v, A) => {
+              const c = f.loaderHook.lifecycle.createLink.emit({
+                url: v,
+                attrs: A
+              });
+              if (c instanceof HTMLLinkElement) return c;
+            },
+            needDeleteLink: !1
+          });
+          d && document.head.appendChild(n);
+        });
+      }
+      if (e) {
+        const r = {
+          rel: "preload",
+          as: "script"
+        };
+        k.forEach((i) => {
+          const { link: n, needAttach: d } = (0, p.createLink)({
+            url: i,
+            cb: () => {
+            },
+            attrs: r,
+            createLinkHook: (v, A) => {
+              const c = f.loaderHook.lifecycle.createLink.emit({
+                url: v,
+                attrs: A
+              });
+              if (c instanceof HTMLLinkElement) return c;
+            }
+          });
+          d && document.head.appendChild(n);
+        });
+      } else {
+        const r = {
+          fetchpriority: "high",
+          type: T?.type === "module" ? "module" : "text/javascript"
+        };
+        k.forEach((i) => {
+          const { script: n, needAttach: d } = (0, p.createScript)({
+            url: i,
+            cb: () => {
+            },
+            attrs: r,
+            createScriptHook: (v, A) => {
+              const c = f.loaderHook.lifecycle.createScript.emit({
+                url: v,
+                attrs: A
+              });
+              if (c instanceof HTMLScriptElement) return c;
+            },
+            needDeleteScript: !0
+          });
+          d && document.head.appendChild(n);
+        });
+      }
+    }
+  }
+  return Q.defaultPreloadArgs = _, Q.formatPreloadArgs = g, Q.normalizePreloadExposes = u, Q.preloadAssets = m, Q;
+}
+var et;
+function At() {
+  if (et) return ve;
+  et = 1;
+  const a = K(), l = te(), y = ie(), p = J();
+  V();
+  const _ = ge(), g = {
+    getRegisteredShare: l.getRegisteredShare,
+    getGlobalShareScope: l.getGlobalShareScope
+  };
+  var m = {
+    global: {
+      Global: a.Global,
+      nativeGlobal: a.nativeGlobal,
+      resetFederationGlobalInfo: a.resetFederationGlobalInfo,
+      setGlobalFederationInstance: a.setGlobalFederationInstance,
+      getGlobalFederationConstructor: a.getGlobalFederationConstructor,
+      setGlobalFederationConstructor: a.setGlobalFederationConstructor,
+      getInfoWithoutType: a.getInfoWithoutType,
+      getGlobalSnapshot: a.getGlobalSnapshot,
+      getTargetSnapshotInfoByModuleInfo: a.getTargetSnapshotInfoByModuleInfo,
+      getGlobalSnapshotInfoByModuleInfo: a.getGlobalSnapshotInfoByModuleInfo,
+      setGlobalSnapshotInfoByModuleInfo: a.setGlobalSnapshotInfoByModuleInfo,
+      addGlobalSnapshot: a.addGlobalSnapshot,
+      getRemoteEntryExports: a.getRemoteEntryExports,
+      registerGlobalPlugins: a.registerGlobalPlugins,
+      getGlobalHostPlugins: a.getGlobalHostPlugins,
+      getPreloaded: a.getPreloaded,
+      setPreloaded: a.setPreloaded
+    },
+    share: g,
+    utils: {
+      matchRemoteWithNameAndExpose: y.matchRemoteWithNameAndExpose,
+      preloadAssets: _.preloadAssets,
+      getRemoteInfo: p.getRemoteInfo
+    }
+  };
+  return ve.default = m, ve;
+}
+var ke = {}, tt;
+function Ge() {
+  if (tt) return ke;
+  tt = 1;
+  const a = L(), l = B(), y = J();
+  V();
+  let p = /* @__PURE__ */ D(), _ = /* @__PURE__ */ ee();
+  function g(m, T, f) {
+    const S = T, e = Array.isArray(m.shareScope) ? m.shareScope : [m.shareScope];
+    e.length || e.push("default"), e.forEach((k) => {
+      S[k] || (S[k] = {});
+    });
+    const E = {
+      version: m.version || "",
+      shareScopeKeys: Array.isArray(m.shareScope) ? e : m.shareScope || "default"
+    };
+    return Object.defineProperty(E, "shareScopeMap", {
+      value: S,
+      enumerable: !1
+    }), {
+      remoteEntryInitOptions: E,
+      shareScope: S[e[0]],
+      initScope: f ?? []
+    };
+  }
+  var u = class {
+    constructor({ remoteInfo: m, host: T }) {
+      this.inited = !1, this.initing = !1, this.lib = void 0, this.remoteInfo = m, this.host = T;
+    }
+    async getEntry() {
+      if (this.remoteEntryExports) return this.remoteEntryExports;
+      const m = await y.getRemoteEntry({
+        origin: this.host,
+        remoteInfo: this.remoteInfo,
+        remoteEntryExports: this.remoteEntryExports
+      });
+      return a.assert(m, `remoteEntryExports is undefined 
+ ${(0, p.safeToString)(this.remoteInfo)}`), this.remoteEntryExports = m, this.remoteEntryExports;
+    }
+    async init(m, T, f) {
+      const S = await this.getEntry();
+      if (this.inited) return S;
+      if (this.initPromise)
+        return await this.initPromise, S;
+      this.initing = !0, this.initPromise = (async () => {
+        const { remoteEntryInitOptions: e, shareScope: E, initScope: k } = g(this.remoteInfo, this.host.shareScopeMap, f), o = await this.host.hooks.lifecycle.beforeInitContainer.emit({
+          shareScope: E,
+          remoteEntryInitOptions: e,
+          initScope: k,
+          remoteInfo: this.remoteInfo,
+          origin: this.host
+        });
+        typeof S?.init > "u" && a.error((0, _.getShortErrorMsg)(_.RUNTIME_002, _.runtimeDescMap, {
+          hostName: this.host.name,
+          remoteName: this.remoteInfo.name,
+          remoteEntryUrl: this.remoteInfo.entry,
+          remoteEntryKey: this.remoteInfo.entryGlobalName
+        })), await S.init(o.shareScope, o.initScope, o.remoteEntryInitOptions), await this.host.hooks.lifecycle.initContainer.emit({
+          ...o,
+          id: m,
+          remoteSnapshot: T,
+          remoteEntryExports: S
+        }), this.inited = !0;
+      })();
+      try {
+        await this.initPromise;
+      } finally {
+        this.initing = !1, this.initPromise = void 0;
+      }
+      return S;
+    }
+    async get(m, T, f, S) {
+      const { loadFactory: e = !0 } = f || { loadFactory: !0 }, E = await this.init(m, S);
+      this.lib = E;
+      let k;
+      k = await this.host.loaderHook.lifecycle.getModuleFactory.emit({
+        remoteEntryExports: E,
+        expose: T,
+        moduleInfo: this.remoteInfo
+      }), k || (k = await E.get(T)), a.assert(k, `${l.getFMId(this.remoteInfo)} remote don't export ${T}.`);
+      const o = l.processModuleAlias(this.remoteInfo.name, T), r = this.wraperFactory(k, o);
+      return e ? await r() : r;
+    }
+    wraperFactory(m, T) {
+      function f(S, e) {
+        S && typeof S == "object" && Object.isExtensible(S) && !Object.getOwnPropertyDescriptor(S, Symbol.for("mf_module_id")) && Object.defineProperty(S, Symbol.for("mf_module_id"), {
+          value: e,
+          enumerable: !1
+        });
+      }
+      return m instanceof Promise ? async () => {
+        const S = await m();
+        return f(S, T), S;
+      } : () => {
+        const S = m();
+        return f(S, T), S;
+      };
+    }
+  };
+  return ke.Module = u, ke;
+}
+var Te = {}, Ae = {}, rt;
+function re() {
+  if (rt) return Ae;
+  rt = 1;
+  var a = class {
+    constructor(l) {
+      this.type = "", this.listeners = /* @__PURE__ */ new Set(), l && (this.type = l);
+    }
+    on(l) {
+      typeof l == "function" && this.listeners.add(l);
+    }
+    once(l) {
+      const y = this;
+      this.on(function p(..._) {
+        return y.remove(p), l.apply(null, _);
+      });
+    }
+    emit(...l) {
+      let y;
+      return this.listeners.size > 0 && this.listeners.forEach((p) => {
+        y = p(...l);
+      }), y;
+    }
+    remove(l) {
+      this.listeners.delete(l);
+    }
+    removeAll() {
+      this.listeners.clear();
+    }
+  };
+  return Ae.SyncHook = a, Ae;
+}
+var qe = {}, ot;
+function ae() {
+  if (ot) return qe;
+  ot = 1;
+  const a = re();
+  var l = class extends a.SyncHook {
+    emit(...y) {
+      let p;
+      const _ = Array.from(this.listeners);
+      if (_.length > 0) {
+        let g = 0;
+        const u = (m) => m === !1 ? !1 : g < _.length ? Promise.resolve(_[g++].apply(null, y)).then(u) : m;
+        p = u();
+      }
+      return Promise.resolve(p);
+    }
+  };
+  return qe.AsyncHook = l, qe;
+}
+var pe = {}, nt;
+function le() {
+  if (nt) return pe;
+  nt = 1;
+  const a = L(), l = B(), y = re();
+  function p(g, u) {
+    if (!l.isObject(u)) return !1;
+    if (g !== u) {
+      for (const m in g) if (!(m in u)) return !1;
+    }
+    return !0;
+  }
+  var _ = class extends y.SyncHook {
+    constructor(g) {
+      super(), this.onerror = a.error, this.type = g;
+    }
+    emit(g) {
+      l.isObject(g) || a.error(`The data for the "${this.type}" hook should be an object.`);
+      for (const u of this.listeners) try {
+        const m = u(g);
+        if (p(g, m)) g = m;
+        else {
+          this.onerror(`A plugin returned an unacceptable value for the "${this.type}" type.`);
+          break;
+        }
+      } catch (m) {
+        a.warn(m), this.onerror(m);
+      }
+      return g;
+    }
+  };
+  return pe.SyncWaterfallHook = _, pe.checkReturnData = p, pe;
+}
+var $e = {}, st;
+function ce() {
+  if (st) return $e;
+  st = 1;
+  const a = L(), l = B(), y = re(), p = le();
+  var _ = class extends y.SyncHook {
+    constructor(g) {
+      super(), this.onerror = a.error, this.type = g;
+    }
+    emit(g) {
+      l.isObject(g) || a.error(`The response data for the "${this.type}" hook must be an object.`);
+      const u = Array.from(this.listeners);
+      if (u.length > 0) {
+        let m = 0;
+        const T = (S) => (a.warn(S), this.onerror(S), g), f = (S) => {
+          if (p.checkReturnData(g, S)) {
+            if (g = S, m < u.length) try {
+              return Promise.resolve(u[m++](g)).then(f, T);
+            } catch (e) {
+              return T(e);
+            }
+          } else this.onerror(`A plugin returned an incorrect value for the "${this.type}" type.`);
+          return g;
+        };
+        return Promise.resolve(f(g));
+      }
+      return Promise.resolve(g);
+    }
+  };
+  return $e.AsyncWaterfallHook = _, $e;
+}
+var Oe = {}, it;
+function ue() {
+  if (it) return Oe;
+  it = 1;
+  const a = L(), l = B();
+  V();
+  var y = class {
+    constructor(p) {
+      this.registerPlugins = {}, this.lifecycle = p, this.lifecycleKeys = Object.keys(p);
+    }
+    applyPlugin(p, _) {
+      a.assert(l.isPlainObject(p), "Plugin configuration is invalid.");
+      const g = p.name;
+      a.assert(g, "A name must be provided by the plugin."), this.registerPlugins[g] || (this.registerPlugins[g] = p, p.apply?.(_), Object.keys(this.lifecycle).forEach((u) => {
+        const m = p[u];
+        m && this.lifecycle[u].on(m);
+      }));
+    }
+    removePlugin(p) {
+      a.assert(p, "A name is required.");
+      const _ = this.registerPlugins[p];
+      a.assert(_, `The plugin "${p}" is not registered.`), Object.keys(_).forEach((g) => {
+        g !== "name" && this.lifecycle[g].remove(_[g]);
+      });
+    }
+  };
+  return Oe.PluginSystem = y, Oe;
+}
+var at = {}, lt;
+function ye() {
+  return lt || (lt = 1, re(), ae(), le(), ce(), ue()), at;
+}
+var me = {}, ct;
+function It() {
+  if (ct) return me;
+  ct = 1;
+  const a = L(), l = B();
+  V();
+  const y = ge();
+  let p = /* @__PURE__ */ D();
+  function _(u, m) {
+    const T = l.getRemoteEntryInfoFromSnapshot(m);
+    T.url || a.error(`The attribute remoteEntry of ${u.name} must not be undefined.`);
+    let f = (0, p.getResourceUrl)(m, T.url);
+    !(0, p.isBrowserEnv)() && !f.startsWith("http") && (f = `https:${f}`), u.type = T.type, u.entryGlobalName = T.globalName, u.entry = f, u.version = m.version, u.buildVersion = m.buildVersion;
+  }
+  function g() {
+    return {
+      name: "snapshot-plugin",
+      async afterResolve(u) {
+        const { remote: m, pkgNameOrAlias: T, expose: f, origin: S, remoteInfo: e, id: E } = u;
+        if (!l.isRemoteInfoWithEntry(m) || !l.isPureRemoteEntry(m)) {
+          const { remoteSnapshot: k, globalSnapshot: o } = await S.snapshotHandler.loadRemoteSnapshotInfo({
+            moduleInfo: m,
+            id: E
+          });
+          _(e, k);
+          const r = {
+            remote: m,
+            preloadConfig: {
+              nameOrAlias: T,
+              exposes: [f],
+              resourceCategory: "sync",
+              share: !1,
+              depsRemote: !1
+            }
+          }, i = await S.remoteHandler.hooks.lifecycle.generatePreloadAssets.emit({
+            origin: S,
+            preloadOptions: r,
+            remoteInfo: e,
+            remote: m,
+            remoteSnapshot: k,
+            globalSnapshot: o
+          });
+          return i && y.preloadAssets(e, S, i, !1), {
+            ...u,
+            remoteSnapshot: k
+          };
+        }
+        return u;
+      }
+    };
+  }
+  return me.assignRemoteInfo = _, me.snapshotPlugin = g, me;
+}
+var Pe = {}, ut;
+function qt() {
+  if (ut) return Pe;
+  ut = 1;
+  const a = B(), l = K(), y = te();
+  V();
+  const p = ge(), _ = It();
+  let g = /* @__PURE__ */ D();
+  function u(e) {
+    const E = e.split(":");
+    return E.length === 1 ? {
+      name: E[0],
+      version: void 0
+    } : E.length === 2 ? {
+      name: E[0],
+      version: E[1]
+    } : {
+      name: E[1],
+      version: E[2]
+    };
+  }
+  function m(e, E, k, o, r = {}, i) {
+    const { value: n } = l.getInfoWithoutType(e, a.getFMId(E)), d = i || n;
+    if (d && !(0, g.isManifestProvider)(d) && (k(d, E, o), d.remotesInfo)) {
+      const v = Object.keys(d.remotesInfo);
+      for (const A of v) {
+        if (r[A]) continue;
+        r[A] = !0;
+        const c = u(A), h = d.remotesInfo[A];
+        m(e, {
+          name: c.name,
+          version: h.matchedVersion
+        }, k, !1, r, void 0);
+      }
+    }
+  }
+  const T = (e, E) => document.querySelector(`${e}[${e === "link" ? "href" : "src"}="${E}"]`);
+  function f(e, E, k, o, r) {
+    const i = [], n = [], d = [], v = /* @__PURE__ */ new Set(), A = /* @__PURE__ */ new Set(), { options: c } = e, { preloadConfig: h } = E, { depsRemote: t } = h;
+    if (m(o, k, (s, b, R) => {
+      let q;
+      if (R) q = h;
+      else if (Array.isArray(t)) {
+        const N = t.find((w) => w.nameOrAlias === b.name || w.nameOrAlias === b.alias);
+        if (!N) return;
+        q = p.defaultPreloadArgs(N);
+      } else if (t === !0) q = h;
+      else return;
+      const $ = (0, g.getResourceUrl)(s, a.getRemoteEntryInfoFromSnapshot(s).url);
+      $ && d.push({
+        name: b.name,
+        moduleInfo: {
+          name: b.name,
+          entry: $,
+          type: "remoteEntryType" in s ? s.remoteEntryType : "global",
+          entryGlobalName: "globalName" in s ? s.globalName : b.name,
+          shareScope: "",
+          version: "version" in s ? s.version : void 0
+        },
+        url: $
+      });
+      let H = "modules" in s ? s.modules : [];
+      const P = p.normalizePreloadExposes(q.exposes);
+      P.length && "modules" in s && (H = s?.modules?.reduce((N, w) => (P?.indexOf(w.moduleName) !== -1 && N.push(w), N), []));
+      function O(N) {
+        const w = N.map((M) => (0, g.getResourceUrl)(s, M));
+        return q.filter ? w.filter(q.filter) : w;
+      }
+      if (H) {
+        const N = H.length;
+        for (let w = 0; w < N; w++) {
+          const M = H[w], x = `${b.name}/${M.moduleName}`;
+          e.remoteHandler.hooks.lifecycle.handlePreloadModule.emit({
+            id: M.moduleName === "." ? b.name : x,
+            name: b.name,
+            remoteSnapshot: s,
+            preloadConfig: q,
+            remote: b,
+            origin: e
+          }), !l.getPreloaded(x) && (q.resourceCategory === "all" ? (i.push(...O(M.assets.css.async)), i.push(...O(M.assets.css.sync)), n.push(...O(M.assets.js.async)), n.push(...O(M.assets.js.sync))) : (q.resourceCategory = "sync") && (i.push(...O(M.assets.css.sync)), n.push(...O(M.assets.js.sync))), l.setPreloaded(x));
+        }
+      }
+    }, !0, {}, r), r.shared && r.shared.length > 0) {
+      const s = (b, R) => {
+        const { shared: q } = y.getRegisteredShare(e.shareScopeMap, R.sharedName, b, e.sharedHandler.hooks.lifecycle.resolveShare) || {};
+        q && typeof q.lib == "function" && (R.assets.js.sync.forEach(($) => {
+          v.add($);
+        }), R.assets.css.sync.forEach(($) => {
+          A.add($);
+        }));
+      };
+      r.shared.forEach((b) => {
+        const R = c.shared?.[b.sharedName];
+        if (!R) return;
+        const q = b.version ? R.find(($) => $.version === b.version) : R;
+        q && a.arrayOptions(q).forEach(($) => {
+          s($, b);
+        });
+      });
+    }
+    const I = n.filter((s) => !v.has(s) && !T("script", s));
+    return {
+      cssAssets: i.filter((s) => !A.has(s) && !T("link", s)),
+      jsAssetsWithoutEntry: I,
+      entryAssets: d.filter((s) => !T("script", s.url))
+    };
+  }
+  const S = function() {
+    return {
+      name: "generate-preload-assets-plugin",
+      async generatePreloadAssets(e) {
+        const { origin: E, preloadOptions: k, remoteInfo: o, remote: r, globalSnapshot: i, remoteSnapshot: n } = e;
+        return (0, g.isBrowserEnv)() ? a.isRemoteInfoWithEntry(r) && a.isPureRemoteEntry(r) ? {
+          cssAssets: [],
+          jsAssetsWithoutEntry: [],
+          entryAssets: [{
+            name: r.name,
+            url: r.entry,
+            moduleInfo: {
+              name: o.name,
+              entry: r.entry,
+              type: o.type || "global",
+              entryGlobalName: "",
+              shareScope: ""
+            }
+          }]
+        } : (_.assignRemoteInfo(o, n), f(E, k, o, i, n)) : {
+          cssAssets: [],
+          jsAssetsWithoutEntry: [],
+          entryAssets: []
+        };
+      }
+    };
+  };
+  return Pe.generatePreloadAssetsPlugin = S, Pe;
+}
+var _e = {}, ft;
+function vt() {
+  if (ft) return _e;
+  ft = 1;
+  const a = L(), l = B(), y = K();
+  V();
+  const p = ae(), _ = ce(), g = ue();
+  ye();
+  let u = /* @__PURE__ */ D(), m = /* @__PURE__ */ ee();
+  function T(S, e) {
+    const E = y.getGlobalSnapshotInfoByModuleInfo({
+      name: e.name,
+      version: e.options.version
+    }), k = E && "remotesInfo" in E && E.remotesInfo && y.getInfoWithoutType(E.remotesInfo, S.name).value;
+    return k && k.matchedVersion ? {
+      hostGlobalSnapshot: E,
+      globalSnapshot: y.getGlobalSnapshot(),
+      remoteSnapshot: y.getGlobalSnapshotInfoByModuleInfo({
+        name: S.name,
+        version: k.matchedVersion
+      })
+    } : {
+      hostGlobalSnapshot: void 0,
+      globalSnapshot: y.getGlobalSnapshot(),
+      remoteSnapshot: y.getGlobalSnapshotInfoByModuleInfo({
+        name: S.name,
+        version: "version" in S ? S.version : void 0
+      })
+    };
+  }
+  var f = class {
+    constructor(e) {
+      this.loadingHostSnapshot = null, this.manifestCache = /* @__PURE__ */ new Map(), this.hooks = new g.PluginSystem({
+        beforeLoadRemoteSnapshot: new p.AsyncHook("beforeLoadRemoteSnapshot"),
+        loadSnapshot: new _.AsyncWaterfallHook("loadGlobalSnapshot"),
+        loadRemoteSnapshot: new _.AsyncWaterfallHook("loadRemoteSnapshot"),
+        afterLoadSnapshot: new _.AsyncWaterfallHook("afterLoadSnapshot")
+      }), this.manifestLoading = y.Global.__FEDERATION__.__MANIFEST_LOADING__, this.HostInstance = e, this.loaderHook = e.loaderHook;
+    }
+    async loadRemoteSnapshotInfo({ moduleInfo: e, id: E, expose: k }) {
+      const { options: o } = this.HostInstance;
+      await this.hooks.lifecycle.beforeLoadRemoteSnapshot.emit({
+        options: o,
+        moduleInfo: e
+      });
+      let r = y.getGlobalSnapshotInfoByModuleInfo({
+        name: this.HostInstance.options.name,
+        version: this.HostInstance.options.version
+      });
+      r || (r = {
+        version: this.HostInstance.options.version || "",
+        remoteEntry: "",
+        remotesInfo: {}
+      }, y.addGlobalSnapshot({ [this.HostInstance.options.name]: r })), r && "remotesInfo" in r && !y.getInfoWithoutType(r.remotesInfo, e.name).value && ("version" in e || "entry" in e) && (r.remotesInfo = {
+        ...r?.remotesInfo,
+        [e.name]: { matchedVersion: "version" in e ? e.version : e.entry }
+      });
+      const { hostGlobalSnapshot: i, remoteSnapshot: n, globalSnapshot: d } = this.getGlobalRemoteInfo(e), { remoteSnapshot: v, globalSnapshot: A } = await this.hooks.lifecycle.loadSnapshot.emit({
+        options: o,
+        moduleInfo: e,
+        hostGlobalSnapshot: i,
+        remoteSnapshot: n,
+        globalSnapshot: d
+      });
+      let c, h;
+      if (v) if ((0, u.isManifestProvider)(v)) {
+        const t = (0, u.isBrowserEnv)() ? v.remoteEntry : v.ssrRemoteEntry || v.remoteEntry || "", I = await this.getManifestJson(t, e, {}), s = y.setGlobalSnapshotInfoByModuleInfo({
+          ...e,
+          entry: t
+        }, I);
+        c = I, h = s;
+      } else {
+        const { remoteSnapshot: t } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
+          options: this.HostInstance.options,
+          moduleInfo: e,
+          remoteSnapshot: v,
+          from: "global"
+        });
+        c = t, h = A;
+      }
+      else if (l.isRemoteInfoWithEntry(e)) {
+        const t = await this.getManifestJson(e.entry, e, {}), I = y.setGlobalSnapshotInfoByModuleInfo(e, t), { remoteSnapshot: s } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
+          options: this.HostInstance.options,
+          moduleInfo: e,
+          remoteSnapshot: t,
+          from: "global"
+        });
+        c = s, h = I;
+      } else a.error((0, m.getShortErrorMsg)(m.RUNTIME_007, m.runtimeDescMap, {
+        hostName: e.name,
+        hostVersion: e.version,
+        globalSnapshot: JSON.stringify(A)
+      }));
+      return await this.hooks.lifecycle.afterLoadSnapshot.emit({
+        id: E,
+        host: this.HostInstance,
+        options: o,
+        moduleInfo: e,
+        remoteSnapshot: c
+      }), {
+        remoteSnapshot: c,
+        globalSnapshot: h
+      };
+    }
+    getGlobalRemoteInfo(e) {
+      return T(e, this.HostInstance);
+    }
+    async getManifestJson(e, E, k) {
+      const o = async () => {
+        let i = this.manifestCache.get(e);
+        if (i) return i;
+        try {
+          let n = await this.loaderHook.lifecycle.fetch.emit(e, {});
+          (!n || !(n instanceof Response)) && (n = await fetch(e, {})), i = await n.json();
+        } catch (n) {
+          i = await this.HostInstance.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
+            id: e,
+            error: n,
+            from: "runtime",
+            lifecycle: "afterResolve",
+            origin: this.HostInstance
+          }), i || (delete this.manifestLoading[e], a.error((0, m.getShortErrorMsg)(m.RUNTIME_003, m.runtimeDescMap, {
+            manifestUrl: e,
+            moduleName: E.name,
+            hostName: this.HostInstance.options.name
+          }, `${n}`)));
+        }
+        return a.assert(i.metaData && i.exposes && i.shared, `${e} is not a federation manifest`), this.manifestCache.set(e, i), i;
+      }, r = async () => {
+        const i = await o(), n = (0, u.generateSnapshotFromManifest)(i, { version: e }), { remoteSnapshot: d } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
+          options: this.HostInstance.options,
+          moduleInfo: E,
+          manifestJson: i,
+          remoteSnapshot: n,
+          manifestUrl: e,
+          from: "manifest"
+        });
+        return d;
+      };
+      return this.manifestLoading[e] || (this.manifestLoading[e] = r().then((i) => i)), this.manifestLoading[e];
+    }
+  };
+  return _e.SnapshotHandler = f, _e.getGlobalRemoteInfo = T, _e;
+}
+var He = {}, dt;
+function $t() {
+  if (dt) return He;
+  dt = 1;
+  const a = L(), l = se(), y = te();
+  V();
+  const p = ae(), _ = le(), g = ce(), u = ue();
+  ye();
+  let m = /* @__PURE__ */ ee();
+  var T = class {
+    constructor(f) {
+      this.hooks = new u.PluginSystem({
+        beforeRegisterShare: new _.SyncWaterfallHook("beforeRegisterShare"),
+        afterResolve: new g.AsyncWaterfallHook("afterResolve"),
+        beforeLoadShare: new g.AsyncWaterfallHook("beforeLoadShare"),
+        loadShare: new p.AsyncHook(),
+        resolveShare: new _.SyncWaterfallHook("resolveShare"),
+        initContainerShareScopeMap: new _.SyncWaterfallHook("initContainerShareScopeMap")
+      }), this.host = f, this.shareScopeMap = {}, this.initTokens = {}, this._setGlobalShareScopeMap(f.options);
+    }
+    registerShared(f, S) {
+      const { newShareInfos: e, allShareInfos: E } = y.formatShareConfigs(f, S);
+      return Object.keys(e).forEach((k) => {
+        e[k].forEach((o) => {
+          o.scope.forEach((r) => {
+            this.hooks.lifecycle.beforeRegisterShare.emit({
+              origin: this.host,
+              pkgName: k,
+              shared: o
+            }), this.shareScopeMap[r]?.[k] || this.setShared({
+              pkgName: k,
+              lib: o.lib,
+              get: o.get,
+              loaded: o.loaded || !!o.lib,
+              shared: o,
+              from: S.name
+            });
+          });
+        });
+      }), {
+        newShareInfos: e,
+        allShareInfos: E
+      };
+    }
+    async loadShare(f, S) {
+      const { host: e } = this, E = y.getTargetSharedOptions({
+        pkgName: f,
+        extraOptions: S,
+        shareInfos: e.options.shared
+      });
+      E?.scope && await Promise.all(E.scope.map(async (i) => {
+        await Promise.all(this.initializeSharing(i, { strategy: E.strategy }));
+      }));
+      const { shareInfo: k } = await this.hooks.lifecycle.beforeLoadShare.emit({
+        pkgName: f,
+        shareInfo: E,
+        shared: e.options.shared,
+        origin: e
+      });
+      a.assert(k, `Cannot find ${f} Share in the ${e.options.name}. Please ensure that the ${f} Share parameters have been injected`);
+      const { shared: o, useTreesShaking: r } = y.getRegisteredShare(this.shareScopeMap, f, k, this.hooks.lifecycle.resolveShare) || {};
+      if (o) {
+        const i = y.directShare(o, r);
+        if (i.lib)
+          return y.addUseIn(i, e.options.name), i.lib;
+        if (i.loading && !i.loaded) {
+          const n = await i.loading;
+          return i.loaded = !0, i.lib || (i.lib = n), y.addUseIn(i, e.options.name), n;
+        } else {
+          const d = (async () => {
+            const v = await i.get();
+            return y.addUseIn(i, e.options.name), i.loaded = !0, i.lib = v, v;
+          })();
+          return this.setShared({
+            pkgName: f,
+            loaded: !1,
+            shared: o,
+            from: e.options.name,
+            lib: null,
+            loading: d,
+            treeShaking: r ? i : void 0
+          }), d;
+        }
+      } else {
+        if (S?.customShareInfo) return !1;
+        const i = y.shouldUseTreeShaking(k.treeShaking), n = y.directShare(k, i), v = (async () => {
+          const A = await n.get();
+          n.lib = A, n.loaded = !0, y.addUseIn(n, e.options.name);
+          const { shared: c, useTreesShaking: h } = y.getRegisteredShare(this.shareScopeMap, f, k, this.hooks.lifecycle.resolveShare) || {};
+          if (c) {
+            const t = y.directShare(c, h);
+            t.lib = A, t.loaded = !0, c.from = k.from;
+          }
+          return A;
+        })();
+        return this.setShared({
+          pkgName: f,
+          loaded: !1,
+          shared: k,
+          from: e.options.name,
+          lib: null,
+          loading: v,
+          treeShaking: i ? n : void 0
+        }), v;
+      }
+    }
+    /**
+    * This function initializes the sharing sequence (executed only once per share scope).
+    * It accepts one argument, the name of the share scope.
+    * If the share scope does not exist, it creates one.
+    */
+    initializeSharing(f = l.DEFAULT_SCOPE, S) {
+      const { host: e } = this, E = S?.from, k = S?.strategy;
+      let o = S?.initScope;
+      const r = [];
+      if (E !== "build") {
+        const { initTokens: c } = this;
+        o || (o = []);
+        let h = c[f];
+        if (h || (h = c[f] = { from: this.host.name }), o.indexOf(h) >= 0) return r;
+        o.push(h);
+      }
+      const i = this.shareScopeMap, n = e.options.name;
+      i[f] || (i[f] = {});
+      const d = i[f], v = (c, h) => {
+        const { version: t, eager: I } = h;
+        d[c] = d[c] || {};
+        const s = d[c], b = s[t] && y.directShare(s[t]), R = !!(b && ("eager" in b && b.eager || "shareConfig" in b && b.shareConfig?.eager));
+        (!b || b.strategy !== "loaded-first" && !b.loaded && (!I != !R ? I : n > s[t].from)) && (s[t] = h);
+      }, A = async (c) => {
+        const { module: h } = await e.remoteHandler.getRemoteModuleAndOptions({ id: c });
+        let t;
+        try {
+          t = await h.getEntry();
+        } catch (I) {
+          t = await e.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
+            id: c,
+            error: I,
+            from: "runtime",
+            lifecycle: "beforeLoadShare",
+            origin: e
+          });
+        } finally {
+          t?.init && !h.initing && (h.remoteEntryExports = t, await h.init(void 0, void 0, o));
+        }
+      };
+      return Object.keys(e.options.shared).forEach((c) => {
+        e.options.shared[c].forEach((h) => {
+          h.scope.includes(f) && v(c, h);
+        });
+      }), (e.options.shareStrategy === "version-first" || k === "version-first") && e.options.remotes.forEach((c) => {
+        c.shareScope === f && r.push(A(c.name));
+      }), r;
+    }
+    loadShareSync(f, S) {
+      const { host: e } = this, E = y.getTargetSharedOptions({
+        pkgName: f,
+        extraOptions: S,
+        shareInfos: e.options.shared
+      });
+      E?.scope && E.scope.forEach((r) => {
+        this.initializeSharing(r, { strategy: E.strategy });
+      });
+      const { shared: k, useTreesShaking: o } = y.getRegisteredShare(this.shareScopeMap, f, E, this.hooks.lifecycle.resolveShare) || {};
+      if (k) {
+        if (typeof k.lib == "function")
+          return y.addUseIn(k, e.options.name), k.loaded || (k.loaded = !0, k.from === e.options.name && (E.loaded = !0)), k.lib;
+        if (typeof k.get == "function") {
+          const r = k.get();
+          if (!(r instanceof Promise))
+            return y.addUseIn(k, e.options.name), this.setShared({
+              pkgName: f,
+              loaded: !0,
+              from: e.options.name,
+              lib: r,
+              shared: k
+            }), r;
+        }
+      }
+      if (E.lib)
+        return E.loaded || (E.loaded = !0), E.lib;
+      if (E.get) {
+        const r = E.get();
+        if (r instanceof Promise) {
+          const i = S?.from === "build" ? m.RUNTIME_005 : m.RUNTIME_006;
+          throw new Error((0, m.getShortErrorMsg)(i, m.runtimeDescMap, {
+            hostName: e.options.name,
+            sharedPkgName: f
+          }));
+        }
+        return E.lib = r, this.setShared({
+          pkgName: f,
+          loaded: !0,
+          from: e.options.name,
+          lib: E.lib,
+          shared: E
+        }), E.lib;
+      }
+      throw new Error((0, m.getShortErrorMsg)(m.RUNTIME_006, m.runtimeDescMap, {
+        hostName: e.options.name,
+        sharedPkgName: f
+      }));
+    }
+    initShareScopeMap(f, S, e = {}) {
+      const { host: E } = this;
+      this.shareScopeMap[f] = S, this.hooks.lifecycle.initContainerShareScopeMap.emit({
+        shareScope: S,
+        options: E.options,
+        origin: E,
+        scopeName: f,
+        hostShareScopeMap: e.hostShareScopeMap
+      });
+    }
+    setShared({ pkgName: f, shared: S, from: e, lib: E, loading: k, loaded: o, get: r, treeShaking: i }) {
+      const { version: n, scope: d = "default", ...v } = S, A = Array.isArray(d) ? d : [d], c = (h) => {
+        const t = (s, b, R) => {
+          R && !s[b] && (s[b] = R);
+        }, I = i ? h.treeShaking : h;
+        t(I, "loaded", o), t(I, "loading", k), t(I, "get", r);
+      };
+      A.forEach((h) => {
+        this.shareScopeMap[h] || (this.shareScopeMap[h] = {}), this.shareScopeMap[h][f] || (this.shareScopeMap[h][f] = {}), this.shareScopeMap[h][f][n] || (this.shareScopeMap[h][f][n] = {
+          version: n,
+          scope: [h],
+          ...v,
+          lib: E
+        });
+        const t = this.shareScopeMap[h][f][n];
+        c(t), e && t.from !== e && (t.from = e);
+      });
+    }
+    _setGlobalShareScopeMap(f) {
+      const S = y.getGlobalShareScope(), e = f.id || f.name;
+      e && !S[e] && (S[e] = this.shareScopeMap);
+    }
+  };
+  return He.SharedHandler = T, He;
+}
+var we = {}, ht;
+function Ot() {
+  if (ht) return we;
+  ht = 1;
+  const a = L(), l = K(), y = se(), p = te(), _ = ie(), g = J();
+  V();
+  const u = ge(), m = Ge(), T = re(), f = ae(), S = le(), e = ce(), E = ue();
+  ye();
+  const k = vt();
+  let o = /* @__PURE__ */ D(), r = /* @__PURE__ */ ee();
+  var i = class {
+    constructor(n) {
+      this.hooks = new E.PluginSystem({
+        beforeRegisterRemote: new S.SyncWaterfallHook("beforeRegisterRemote"),
+        registerRemote: new S.SyncWaterfallHook("registerRemote"),
+        beforeRequest: new e.AsyncWaterfallHook("beforeRequest"),
+        onLoad: new f.AsyncHook("onLoad"),
+        handlePreloadModule: new T.SyncHook("handlePreloadModule"),
+        errorLoadRemote: new f.AsyncHook("errorLoadRemote"),
+        beforePreloadRemote: new f.AsyncHook("beforePreloadRemote"),
+        generatePreloadAssets: new f.AsyncHook("generatePreloadAssets"),
+        afterPreloadRemote: new f.AsyncHook(),
+        loadEntry: new f.AsyncHook()
+      }), this.host = n, this.idToRemoteMap = {};
+    }
+    formatAndRegisterRemote(n, d) {
+      return (d.remotes || []).reduce((v, A) => (this.registerRemote(A, v, { force: !1 }), v), n.remotes);
+    }
+    setIdToRemoteMap(n, d) {
+      const { remote: v, expose: A } = d, { name: c, alias: h } = v;
+      if (this.idToRemoteMap[n] = {
+        name: v.name,
+        expose: A
+      }, h && n.startsWith(c)) {
+        const t = n.replace(c, h);
+        this.idToRemoteMap[t] = {
+          name: v.name,
+          expose: A
+        };
+        return;
+      }
+      if (h && n.startsWith(h)) {
+        const t = n.replace(h, c);
+        this.idToRemoteMap[t] = {
+          name: v.name,
+          expose: A
+        };
+      }
+    }
+    async loadRemote(n, d) {
+      const { host: v } = this;
+      try {
+        const { loadFactory: A = !0 } = d || { loadFactory: !0 }, { module: c, moduleOptions: h, remoteMatchInfo: t } = await this.getRemoteModuleAndOptions({ id: n }), { pkgNameOrAlias: I, remote: s, expose: b, id: R, remoteSnapshot: q } = t, $ = await c.get(R, b, d, q), H = await this.hooks.lifecycle.onLoad.emit({
+          id: R,
+          pkgNameOrAlias: I,
+          expose: b,
+          exposeModule: A ? $ : void 0,
+          exposeModuleFactory: A ? void 0 : $,
+          remote: s,
+          options: h,
+          moduleInstance: c,
+          origin: v
+        });
+        return this.setIdToRemoteMap(n, t), typeof H == "function" ? H : $;
+      } catch (A) {
+        const { from: c = "runtime" } = d || { from: "runtime" }, h = await this.hooks.lifecycle.errorLoadRemote.emit({
+          id: n,
+          error: A,
+          from: c,
+          lifecycle: "onLoad",
+          origin: v
+        });
+        if (!h) throw A;
+        return h;
+      }
+    }
+    async preloadRemote(n) {
+      const { host: d } = this;
+      await this.hooks.lifecycle.beforePreloadRemote.emit({
+        preloadOps: n,
+        options: d.options,
+        origin: d
+      });
+      const v = u.formatPreloadArgs(d.options.remotes, n);
+      await Promise.all(v.map(async (A) => {
+        const { remote: c } = A, h = g.getRemoteInfo(c), { globalSnapshot: t, remoteSnapshot: I } = await d.snapshotHandler.loadRemoteSnapshotInfo({ moduleInfo: c }), s = await this.hooks.lifecycle.generatePreloadAssets.emit({
+          origin: d,
+          preloadOptions: A,
+          remote: c,
+          remoteInfo: h,
+          globalSnapshot: t,
+          remoteSnapshot: I
+        });
+        s && u.preloadAssets(h, d, s);
+      }));
+    }
+    registerRemotes(n, d) {
+      const { host: v } = this;
+      n.forEach((A) => {
+        this.registerRemote(A, v.options.remotes, { force: d?.force });
+      });
+    }
+    async getRemoteModuleAndOptions(n) {
+      const { host: d } = this, { id: v } = n;
+      let A;
+      try {
+        A = await this.hooks.lifecycle.beforeRequest.emit({
+          id: v,
+          options: d.options,
+          origin: d
+        });
+      } catch (H) {
+        if (A = await this.hooks.lifecycle.errorLoadRemote.emit({
+          id: v,
+          options: d.options,
+          origin: d,
+          from: "runtime",
+          error: H,
+          lifecycle: "beforeRequest"
+        }), !A) throw H;
+      }
+      const { id: c } = A, h = _.matchRemoteWithNameAndExpose(d.options.remotes, c);
+      a.assert(h, (0, r.getShortErrorMsg)(r.RUNTIME_004, r.runtimeDescMap, {
+        hostName: d.options.name,
+        requestId: c
+      }));
+      const { remote: t } = h, I = g.getRemoteInfo(t), s = await d.sharedHandler.hooks.lifecycle.afterResolve.emit({
+        id: c,
+        ...h,
+        options: d.options,
+        origin: d,
+        remoteInfo: I
+      }), { remote: b, expose: R } = s;
+      a.assert(b && R, `The 'beforeRequest' hook was executed, but it failed to return the correct 'remote' and 'expose' values while loading ${c}.`);
+      let q = d.moduleCache.get(b.name);
+      const $ = {
+        host: d,
+        remoteInfo: I
+      };
+      return q || (q = new m.Module($), d.moduleCache.set(b.name, q)), {
+        module: q,
+        moduleOptions: $,
+        remoteMatchInfo: s
+      };
+    }
+    registerRemote(n, d, v) {
+      const { host: A } = this, c = () => {
+        if (n.alias) {
+          const t = d.find((I) => n.alias && (I.name.startsWith(n.alias) || I.alias?.startsWith(n.alias)));
+          a.assert(!t, `The alias ${n.alias} of remote ${n.name} is not allowed to be the prefix of ${t && t.name} name or alias`);
+        }
+        "entry" in n && (0, o.isBrowserEnv)() && !n.entry.startsWith("http") && (n.entry = new URL(n.entry, window.location.origin).href), n.shareScope || (n.shareScope = y.DEFAULT_SCOPE), n.type || (n.type = y.DEFAULT_REMOTE_TYPE);
+      };
+      this.hooks.lifecycle.beforeRegisterRemote.emit({
+        remote: n,
+        origin: A
+      });
+      const h = d.find((t) => t.name === n.name);
+      if (!h)
+        c(), d.push(n), this.hooks.lifecycle.registerRemote.emit({
+          remote: n,
+          origin: A
+        });
+      else {
+        const t = [`The remote "${n.name}" is already registered.`, "Please note that overriding it may cause unexpected errors."];
+        v?.force && (this.removeRemote(h), c(), d.push(n), this.hooks.lifecycle.registerRemote.emit({
+          remote: n,
+          origin: A
+        }), (0, o.warn)(t.join(" ")));
+      }
+    }
+    removeRemote(n) {
+      try {
+        const { host: d } = this, { name: v } = n, A = d.options.remotes.findIndex((h) => h.name === v);
+        A !== -1 && d.options.remotes.splice(A, 1);
+        const c = d.moduleCache.get(n.name);
+        if (c) {
+          const h = c.remoteInfo, t = h.entryGlobalName;
+          l.CurrentGlobal[t] && (Object.getOwnPropertyDescriptor(l.CurrentGlobal, t)?.configurable ? delete l.CurrentGlobal[t] : l.CurrentGlobal[t] = void 0);
+          const I = g.getRemoteEntryUniqueKey(c.remoteInfo);
+          l.globalLoading[I] && delete l.globalLoading[I], d.snapshotHandler.manifestCache.delete(h.entry);
+          let s = h.buildVersion ? (0, o.composeKeyWithSeparator)(h.name, h.buildVersion) : h.name;
+          const b = l.CurrentGlobal.__FEDERATION__.__INSTANCES__.findIndex((q) => h.buildVersion ? q.options.id === s : q.name === s);
+          if (b !== -1) {
+            const q = l.CurrentGlobal.__FEDERATION__.__INSTANCES__[b];
+            s = q.options.id || s;
+            const $ = p.getGlobalShareScope();
+            let H = !0;
+            const P = [];
+            Object.keys($).forEach((O) => {
+              const N = $[O];
+              N && Object.keys(N).forEach((w) => {
+                const M = N[w];
+                M && Object.keys(M).forEach((x) => {
+                  const Y = M[x];
+                  Y && Object.keys(Y).forEach((X) => {
+                    const C = Y[X];
+                    C && typeof C == "object" && C.from === h.name && (C.loaded || C.loading ? (C.useIn = C.useIn.filter((oe) => oe !== h.name), C.useIn.length ? H = !1 : P.push([
+                      O,
+                      w,
+                      x,
+                      X
+                    ])) : P.push([
+                      O,
+                      w,
+                      x,
+                      X
+                    ]));
+                  });
+                });
+              });
+            }), H && (q.shareScopeMap = {}, delete $[s]), P.forEach(([O, N, w, M]) => {
+              delete $[O]?.[N]?.[w]?.[M];
+            }), l.CurrentGlobal.__FEDERATION__.__INSTANCES__.splice(b, 1);
+          }
+          const { hostGlobalSnapshot: R } = k.getGlobalRemoteInfo(n, d);
+          if (R) {
+            const q = R && "remotesInfo" in R && R.remotesInfo && l.getInfoWithoutType(R.remotesInfo, n.name).key;
+            q && (delete R.remotesInfo[q], l.Global.__FEDERATION__.__MANIFEST_LOADING__[q] && delete l.Global.__FEDERATION__.__MANIFEST_LOADING__[q]);
+          }
+          d.moduleCache.delete(n.name);
+        }
+      } catch (d) {
+        a.logger.log("removeRemote fail: ", d);
+      }
+    }
+  };
+  return we.RemoteHandler = i, we;
+}
+var pt;
+function Pt() {
+  if (pt) return Te;
+  pt = 1;
+  const a = L(), l = se(), y = te(), p = bt(), _ = Rt(), g = J();
+  V();
+  const u = Ge(), m = re(), T = ae(), f = le(), S = ce(), e = ue();
+  ye();
+  const E = It(), k = qt(), o = vt(), r = $t(), i = Ot();
+  let n = /* @__PURE__ */ D(), d = /* @__PURE__ */ ee();
+  const v = typeof FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN == "boolean" ? !FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN : !0;
+  var A = class {
+    constructor(c) {
+      this.hooks = new e.PluginSystem({
+        beforeInit: new f.SyncWaterfallHook("beforeInit"),
+        init: new m.SyncHook(),
+        beforeInitContainer: new S.AsyncWaterfallHook("beforeInitContainer"),
+        initContainer: new S.AsyncWaterfallHook("initContainer")
+      }), this.version = "2.1.0", this.moduleCache = /* @__PURE__ */ new Map(), this.loaderHook = new e.PluginSystem({
+        getModuleInfo: new m.SyncHook(),
+        createScript: new m.SyncHook(),
+        createLink: new m.SyncHook(),
+        fetch: new T.AsyncHook(),
+        loadEntryError: new T.AsyncHook(),
+        getModuleFactory: new T.AsyncHook()
+      }), this.bridgeHook = new e.PluginSystem({
+        beforeBridgeRender: new m.SyncHook(),
+        afterBridgeRender: new m.SyncHook(),
+        beforeBridgeDestroy: new m.SyncHook(),
+        afterBridgeDestroy: new m.SyncHook()
+      });
+      const h = v ? [E.snapshotPlugin(), k.generatePreloadAssetsPlugin()] : [], t = {
+        id: p.getBuilderId(),
+        name: c.name,
+        plugins: h,
+        remotes: [],
+        shared: {},
+        inBrowser: (0, n.isBrowserEnv)()
+      };
+      this.name = c.name, this.options = t, this.snapshotHandler = new o.SnapshotHandler(this), this.sharedHandler = new r.SharedHandler(this), this.remoteHandler = new i.RemoteHandler(this), this.shareScopeMap = this.sharedHandler.shareScopeMap, this.registerPlugins([...t.plugins, ...c.plugins || []]), this.options = this.formatOptions(t, c);
+    }
+    initOptions(c) {
+      c.name && c.name !== this.options.name && a.error((0, d.getShortErrorMsg)(d.RUNTIME_010, d.runtimeDescMap)), this.registerPlugins(c.plugins);
+      const h = this.formatOptions(this.options, c);
+      return this.options = h, h;
+    }
+    async loadShare(c, h) {
+      return this.sharedHandler.loadShare(c, h);
+    }
+    loadShareSync(c, h) {
+      return this.sharedHandler.loadShareSync(c, h);
+    }
+    initializeSharing(c = l.DEFAULT_SCOPE, h) {
+      return this.sharedHandler.initializeSharing(c, h);
+    }
+    initRawContainer(c, h, t) {
+      const I = g.getRemoteInfo({
+        name: c,
+        entry: h
+      }), s = new u.Module({
+        host: this,
+        remoteInfo: I
+      });
+      return s.remoteEntryExports = t, this.moduleCache.set(c, s), s;
+    }
+    async loadRemote(c, h) {
+      return this.remoteHandler.loadRemote(c, h);
+    }
+    async preloadRemote(c) {
+      return this.remoteHandler.preloadRemote(c);
+    }
+    initShareScopeMap(c, h, t = {}) {
+      this.sharedHandler.initShareScopeMap(c, h, t);
+    }
+    formatOptions(c, h) {
+      const { allShareInfos: t } = y.formatShareConfigs(c, h), { userOptions: I, options: s } = this.hooks.lifecycle.beforeInit.emit({
+        origin: this,
+        userOptions: h,
+        options: c,
+        shareInfo: t
+      }), b = this.remoteHandler.formatAndRegisterRemote(s, I), { allShareInfos: R } = this.sharedHandler.registerShared(s, I), q = [...s.plugins];
+      I.plugins && I.plugins.forEach((H) => {
+        q.includes(H) || q.push(H);
+      });
+      const $ = {
+        ...c,
+        ...h,
+        plugins: q,
+        remotes: b,
+        shared: R
+      };
+      return this.hooks.lifecycle.init.emit({
+        origin: this,
+        options: $
+      }), $;
+    }
+    registerPlugins(c) {
+      const h = _.registerPlugins(c, this);
+      this.options.plugins = this.options.plugins.reduce((t, I) => (I && t && !t.find((s) => s.name === I.name) && t.push(I), t), h || []);
+    }
+    registerRemotes(c, h) {
+      return this.remoteHandler.registerRemotes(c, h);
+    }
+    registerShared(c) {
+      this.sharedHandler.registerShared(this.options, {
+        ...this.options,
+        shared: c
+      });
+    }
+  };
+  return Te.ModuleFederation = A, Te;
+}
+var Ne = {}, Me = {}, mt;
+function Ht() {
+  if (mt) return Me;
+  mt = 1;
+  var a = Object.defineProperty, l = (y, p) => {
+    let _ = {};
+    for (var g in y)
+      a(_, g, {
+        get: y[g],
+        enumerable: !0
+      });
+    return p || a(_, Symbol.toStringTag, { value: "Module" }), _;
+  };
+  return Me.__exportAll = l, Me;
+}
+var _t;
+function wt() {
+  return _t || (_t = 1, (function(a) {
+    var y = /* @__PURE__ */ Ht().__exportAll({});
+    Object.defineProperty(a, "type_exports", {
+      enumerable: !0,
+      get: function() {
+        return y;
+      }
+    });
+  })(Ne)), Ne;
+}
+var gt;
+function Lt() {
+  return gt || (gt = 1, (function(a) {
+    Object.defineProperty(a, Symbol.toStringTag, { value: "Module" });
+    const l = L(), y = B(), p = K(), _ = Et(), g = te(), u = ie(), m = J();
+    V();
+    const T = At(), f = Ge(), S = Pt(), e = wt();
+    let E = /* @__PURE__ */ D();
+    const k = T.default;
+    a.CurrentGlobal = p.CurrentGlobal, a.Global = p.Global, a.Module = f.Module, a.ModuleFederation = S.ModuleFederation, a.addGlobalSnapshot = p.addGlobalSnapshot, a.assert = l.assert, a.getGlobalFederationConstructor = p.getGlobalFederationConstructor, a.getGlobalSnapshot = p.getGlobalSnapshot, a.getInfoWithoutType = p.getInfoWithoutType, a.getRegisteredShare = g.getRegisteredShare, a.getRemoteEntry = m.getRemoteEntry, a.getRemoteInfo = m.getRemoteInfo, a.helpers = k, a.isStaticResourcesEqual = y.isStaticResourcesEqual, Object.defineProperty(a, "loadScript", {
+      enumerable: !0,
+      get: function() {
+        return E.loadScript;
+      }
+    }), Object.defineProperty(a, "loadScriptNode", {
+      enumerable: !0,
+      get: function() {
+        return E.loadScriptNode;
+      }
+    }), a.matchRemoteWithNameAndExpose = u.matchRemoteWithNameAndExpose, a.registerGlobalPlugins = p.registerGlobalPlugins, a.resetFederationGlobalInfo = p.resetFederationGlobalInfo, a.safeWrapper = y.safeWrapper, a.satisfy = _.satisfy, a.setGlobalFederationConstructor = p.setGlobalFederationConstructor, a.setGlobalFederationInstance = p.setGlobalFederationInstance, Object.defineProperty(a, "types", {
+      enumerable: !0,
+      get: function() {
+        return e.type_exports;
+      }
+    });
+  })(Se)), Se;
+}
+export {
+  Lt as r
+};