npm - @meethive/vite - Versions diffs - 0.0.1 - Mend

@meethive/vite 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (72) hide show

package/dist/index.d.ts +4 -0
package/dist/index.d.ts.map +1 -0
package/dist/index.js +2118 -0
package/dist/index.mjs +2096 -0
package/dist/src/federation/src/dev/expose-development.d.ts +5 -0
package/dist/src/federation/src/dev/expose-development.d.ts.map +1 -0
package/dist/src/federation/src/dev/remote-development.d.ts +5 -0
package/dist/src/federation/src/dev/remote-development.d.ts.map +1 -0
package/dist/src/federation/src/dev/shared-development.d.ts +5 -0
package/dist/src/federation/src/dev/shared-development.d.ts.map +1 -0
package/dist/src/federation/src/index.d.ts +7 -0
package/dist/src/federation/src/index.d.ts.map +1 -0
package/dist/src/federation/src/prod/expose-production.d.ts +5 -0
package/dist/src/federation/src/prod/expose-production.d.ts.map +1 -0
package/dist/src/federation/src/prod/remote-production.d.ts +7 -0
package/dist/src/federation/src/prod/remote-production.d.ts.map +1 -0
package/dist/src/federation/src/prod/shared-production.d.ts +5 -0
package/dist/src/federation/src/prod/shared-production.d.ts.map +1 -0
package/dist/src/federation/src/public.d.ts +40 -0
package/dist/src/federation/src/public.d.ts.map +1 -0
package/dist/src/federation/src/runtime/dynamic-remote.d.ts +79 -0
package/dist/src/federation/src/runtime/dynamic-remote.d.ts.map +1 -0
package/dist/src/federation/src/utils/html.d.ts +12 -0
package/dist/src/federation/src/utils/html.d.ts.map +1 -0
package/dist/src/federation/src/utils/index.d.ts +29 -0
package/dist/src/federation/src/utils/index.d.ts.map +1 -0
package/dist/src/federation/src/utils/semver/compare.d.ts +10 -0
package/dist/src/federation/src/utils/semver/compare.d.ts.map +1 -0
package/dist/src/federation/src/utils/semver/constants.d.ts +11 -0
package/dist/src/federation/src/utils/semver/constants.d.ts.map +1 -0
package/dist/src/federation/src/utils/semver/parser.d.ts +10 -0
package/dist/src/federation/src/utils/semver/parser.d.ts.map +1 -0
package/dist/src/federation/src/utils/semver/satisfy.d.ts +2 -0
package/dist/src/federation/src/utils/semver/satisfy.d.ts.map +1 -0
package/dist/src/federation/src/utils/semver/utils.d.ts +12 -0
package/dist/src/federation/src/utils/semver/utils.d.ts.map +1 -0
package/dist/src/monaco-editor/index.d.ts +35 -0
package/dist/src/monaco-editor/index.d.ts.map +1 -0
package/dist/src/monaco-editor/languageWork.d.ts +10 -0
package/dist/src/monaco-editor/languageWork.d.ts.map +1 -0
package/dist/src/monaco-editor/workerMiddleware.d.ts +9 -0
package/dist/src/monaco-editor/workerMiddleware.d.ts.map +1 -0
package/dist/src/sharp/index.d.ts +12 -0
package/dist/src/sharp/index.d.ts.map +1 -0
package/index.ts +3 -0
package/package.json +48 -0
package/src/federation/src/dev/expose-development.ts +29 -0
package/src/federation/src/dev/remote-development.ts +435 -0
package/src/federation/src/dev/shared-development.ts +29 -0
package/src/federation/src/index.ts +242 -0
package/src/federation/src/prod/expose-production.ts +333 -0
package/src/federation/src/prod/federation_fn_import.js +75 -0
package/src/federation/src/prod/remote-production.ts +658 -0
package/src/federation/src/prod/shared-production.ts +268 -0
package/src/federation/src/public.ts +54 -0
package/src/federation/src/runtime/dynamic-remote.ts +247 -0
package/src/federation/src/utils/html.ts +165 -0
package/src/federation/src/utils/index.ts +255 -0
package/src/federation/src/utils/semver/compare.ts +131 -0
package/src/federation/src/utils/semver/constants.ts +46 -0
package/src/federation/src/utils/semver/parser.ts +253 -0
package/src/federation/src/utils/semver/satisfy.ts +151 -0
package/src/federation/src/utils/semver/utils.ts +93 -0
package/src/federation/types/dynamic-remote.d.ts +105 -0
package/src/federation/types/index.d.ts +344 -0
package/src/federation/types/pluginHooks.d.ts +4 -0
package/src/federation/types/virtual-modules.d.ts +48 -0
package/src/federation/types/viteDevServer.d.ts +22 -0
package/src/monaco-editor/index.ts +205 -0
package/src/monaco-editor/languageWork.ts +36 -0
package/src/monaco-editor/workerMiddleware.ts +78 -0
package/src/sharp/index.ts +93 -0

package/dist/index.mjs ADDED Viewed

@@ -0,0 +1,2096 @@
+import virtual from "@rollup/plugin-virtual";
+import path, { posix, resolve, basename, join, extname, parse, relative, dirname, isAbsolute } from "path";
+import { walk } from "estree-walker";
+import MagicString from "magic-string";
+import path$1 from "node:path";
+import { readFileSync, statSync, readdirSync, existsSync, rmSync } from "fs";
+import "crypto";
+import { buildSync } from "esbuild";
+const EXPOSES_MAP = /* @__PURE__ */ new Map();
+const EXPOSES_KEY_MAP = /* @__PURE__ */ new Map();
+const SHARED = "shared";
+const DYNAMIC_LOADING_CSS = "dynamicLoadingCss";
+const DYNAMIC_LOADING_CSS_PREFIX = "__v__css__";
+const DEFAULT_ENTRY_FILENAME = "remoteEntry.js";
+const builderInfo = {
+  builder: "rollup",
+  assetsDir: "",
+  isHost: false,
+  isRemote: false,
+  isShared: false
+};
+const parsedOptions = {
+  prodExpose: [],
+  prodRemote: [],
+  prodShared: [],
+  devShared: [],
+  devExpose: [],
+  devRemote: []
+};
+const devRemotes = [];
+const prodRemotes = [];
+const viteConfigResolved = {
+  config: void 0
+};
+const unaryTags = /* @__PURE__ */ new Set(["link", "meta", "base"]);
+function serializeTag({ tag, attrs, children }, indent = "") {
+  if (unaryTags.has(tag)) {
+    return `<${tag}${serializeAttrs(attrs)}>`;
+  } else {
+    return `<${tag}${serializeAttrs(attrs)}>${serializeTags(
+      children,
+      incrementIndent(indent)
+    )}</${tag}>`;
+  }
+}
+function serializeTags(tags, indent = "") {
+  if (typeof tags === "string") {
+    return tags;
+  } else if (tags && tags.length) {
+    return tags.map((tag) => `${indent}${serializeTag(tag, indent)}
+`).join("");
+  }
+  return "";
+}
+function serializeAttrs(attrs) {
+  let res = "";
+  for (const key in attrs) {
+    if (typeof attrs[key] === "boolean") {
+      res += attrs[key] ? ` ${key}` : ``;
+    } else {
+      res += ` ${key}="${escapeHtml(attrs[key])}"`;
+    }
+  }
+  return res;
+}
+function incrementIndent(indent = "") {
+  return `${indent}${indent[0] === "	" ? "	" : "  "}`;
+}
+const matchHtmlRegExp = /["'&<>]/;
+function escapeHtml(string) {
+  const str = "" + string;
+  const match = matchHtmlRegExp.exec(str);
+  if (!match) {
+    return str;
+  }
+  let escape;
+  let html = "";
+  let index = 0;
+  let lastIndex = 0;
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        escape = "&quot;";
+        break;
+      case 38:
+        escape = "&amp;";
+        break;
+      case 39:
+        escape = "&#39;";
+        break;
+      case 60:
+        escape = "&lt;";
+        break;
+      case 62:
+        escape = "&gt;";
+        break;
+      default:
+        continue;
+    }
+    if (lastIndex !== index) {
+      html += str.substring(lastIndex, index);
+    }
+    lastIndex = index + 1;
+    html += escape;
+  }
+  return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+}
+const headInjectRE = /([ \t]*)<\/head>/i;
+const headPrependInjectRE = /([ \t]*)<head[^>]*>/i;
+const htmlPrependInjectRE = /([ \t]*)<html[^>]*>/i;
+const bodyPrependInjectRE = /([ \t]*)<body[^>]*>/i;
+const doctypePrependInjectRE = /<!doctype html>/i;
+const toPreloadTag = (href) => ({
+  tag: "link",
+  attrs: {
+    rel: "modulepreload",
+    crossorigin: true,
+    href
+  }
+});
+function injectToHead(html, tags, prepend = false) {
+  if (tags.length === 0) return html;
+  if (prepend) {
+    if (headPrependInjectRE.test(html)) {
+      return html.replace(
+        headPrependInjectRE,
+        (match, p1) => `${match}
+${serializeTags(tags, incrementIndent(p1))}`
+      );
+    }
+  } else {
+    if (headInjectRE.test(html)) {
+      return html.replace(
+        headInjectRE,
+        (match, p1) => `${serializeTags(tags, incrementIndent(p1))}${match}`
+      );
+    }
+    if (bodyPrependInjectRE.test(html)) {
+      return html.replace(
+        bodyPrependInjectRE,
+        (match, p1) => `${serializeTags(tags, p1)}
+${match}`
+      );
+    }
+  }
+  return prependInjectFallback(html, tags);
+}
+function prependInjectFallback(html, tags) {
+  if (htmlPrependInjectRE.test(html)) {
+    return html.replace(htmlPrependInjectRE, `$&
+${serializeTags(tags)}`);
+  }
+  if (doctypePrependInjectRE.test(html)) {
+    return html.replace(doctypePrependInjectRE, `$&
+${serializeTags(tags)}`);
+  }
+  return serializeTags(tags) + html;
+}
+function parseSharedOptions(options) {
+  return parseOptions(
+    options.shared || {},
+    (value, key) => ({
+      import: true,
+      shareScope: "default",
+      packagePath: key,
+      // Whether the path is set manually
+      manuallyPackagePathSetting: false,
+      generate: true,
+      modulePreload: false
+    }),
+    (value, key) => {
+      value.import = value.import ?? true;
+      value.shareScope = value.shareScope || "default";
+      value.packagePath = value.packagePath || key;
+      value.manuallyPackagePathSetting = value.packagePath !== key;
+      value.generate = value.generate ?? true;
+      value.modulePreload = value.modulePreload ?? false;
+      return value;
+    }
+  );
+}
+function parseExposeOptions(options) {
+  return parseOptions(
+    options.exposes,
+    (item) => {
+      return {
+        import: item,
+        name: void 0,
+        dontAppendStylesToHead: false
+      };
+    },
+    (item) => ({
+      import: item.import,
+      name: item.name || void 0,
+      dontAppendStylesToHead: item.dontAppendStylesToHead || false
+    })
+  );
+}
+function parseRemoteOptions(options) {
+  return parseOptions(
+    options.remotes ? options.remotes : {},
+    (item) => ({
+      external: Array.isArray(item) ? item : [item],
+      shareScope: options.shareScope || "default",
+      format: "esm",
+      from: "vite",
+      externalType: "url"
+    }),
+    (item) => ({
+      external: Array.isArray(item.external) ? item.external : [item.external],
+      shareScope: item.shareScope || options.shareScope || "default",
+      format: item.format || "esm",
+      from: item.from ?? "vite",
+      externalType: item.externalType || "url"
+    })
+  );
+}
+function parseOptions(options, normalizeSimple, normalizeOptions) {
+  if (!options) {
+    return [];
+  }
+  const list = [];
+  const array = (items) => {
+    for (const item of items) {
+      if (typeof item === "string") {
+        list.push([item, normalizeSimple(item, item)]);
+      } else if (item && typeof item === "object") {
+        object(item);
+      } else {
+        throw new Error("Unexpected options format");
+      }
+    }
+  };
+  const object = (obj) => {
+    for (const [key, value] of Object.entries(obj)) {
+      if (typeof value === "string" || Array.isArray(value)) {
+        list.push([key, normalizeSimple(value, key)]);
+      } else {
+        list.push([key, normalizeOptions(value, key)]);
+      }
+    }
+  };
+  if (Array.isArray(options)) {
+    array(options);
+  } else if (typeof options === "object") {
+    object(options);
+  } else {
+    throw new Error("Unexpected options format");
+  }
+  return list;
+}
+const letterReg = new RegExp("[0-9a-zA-Z]+");
+function removeNonRegLetter(str, reg = letterReg) {
+  let needUpperCase = false;
+  let ret = "";
+  for (const c of str) {
+    if (reg.test(c)) {
+      ret += needUpperCase ? c.toUpperCase() : c;
+      needUpperCase = false;
+    } else {
+      needUpperCase = true;
+    }
+  }
+  return ret;
+}
+function getModuleMarker(value, type) {
+  return type ? `__rf_${type}__${value}` : `__rf_placeholder__${value}`;
+}
+function normalizePath(id) {
+  return posix.normalize(id.replace(/\\/g, "/"));
+}
+function createRemotesMap(remotes) {
+  const createUrl = (remote) => {
+    const external = remote.config.external[0];
+    const externalType = remote.config.externalType;
+    if (externalType === "promise") {
+      return `()=>${external}`;
+    } else {
+      return `'${external}'`;
+    }
+  };
+  return `const remotesMap = {
+${remotes.map(
+    (remote) => `'${remote.id}':{url:${createUrl(remote)},format:'${remote.config.format}',from:'${remote.config.from}'}`
+  ).join(",\n  ")}
+};`;
+}
+function getFileExtname(url) {
+  const fileNameAndParamArr = normalizePath(url).split("/");
+  const fileNameAndParam = fileNameAndParamArr[fileNameAndParamArr.length - 1];
+  const fileName = fileNameAndParam.split("?")[0];
+  return path.extname(fileName);
+}
+const REMOTE_FROM_PARAMETER = "remoteFrom";
+const NAME_CHAR_REG = new RegExp("[0-9a-zA-Z@_-]+");
+function joinUrlSegments(a, b) {
+  if (!a || !b) {
+    return a || b || "";
+  }
+  if (a[a.length - 1] === "/") {
+    a = a.substring(0, a.length - 1);
+  }
+  if (b[0] !== "/") {
+    b = "/" + b;
+  }
+  return a + b;
+}
+function toOutputFilePathWithoutRuntime(filename, type, hostId, hostType, config, toRelative) {
+  const { renderBuiltUrl } = config.experimental;
+  let relative2 = config.base === "" || config.base === "./";
+  if (renderBuiltUrl) {
+    const result = renderBuiltUrl(filename, {
+      hostId,
+      hostType,
+      type,
+      ssr: !!config.build.ssr
+    });
+    if (typeof result === "object") {
+      if (result.runtime) {
+        throw new Error(
+          `{ runtime: "${result.runtime}" } is not supported for assets in ${hostType} files: ${filename}`
+        );
+      }
+      if (typeof result.relative === "boolean") {
+        relative2 = result.relative;
+      }
+    } else if (result) {
+      return result;
+    }
+  }
+  if (relative2 && !config.build.ssr) {
+    return toRelative(filename, hostId);
+  } else {
+    return joinUrlSegments(config.base, filename);
+  }
+}
+function prodRemotePlugin(options) {
+  parsedOptions.prodRemote = parseRemoteOptions(options);
+  for (const item of parsedOptions.prodRemote) {
+    prodRemotes.push({
+      id: item[0],
+      regexp: new RegExp(`^${item[0]}/.+?`),
+      config: item[1]
+    });
+  }
+  const shareScope = options.shareScope || "default";
+  let resolvedConfig;
+  return {
+    name: "originjs:remote-production",
+    virtualFile: options.remotes || options.enableDynamicRemotes ? {
+      // language=JS
+      __federation__: `
+                ${createRemotesMap(prodRemotes)}
+                const currentImports = {}
+                const loadJS = async (url, fn) => {
+                    const resolvedUrl = typeof url === 'function' ? await url() : url;
+                    const script = document.createElement('script')
+                    script.type = 'text/javascript';
+                    script.onload = fn;
+                    script.src = resolvedUrl;
+                    document.getElementsByTagName('head')[0].appendChild(script);
+                }
+                function get(name, ${REMOTE_FROM_PARAMETER}) {
+                    return __federation_import(name).then(module => () => {
+                        if (${REMOTE_FROM_PARAMETER} === 'webpack') {
+                            return Object.prototype.toString.call(module).indexOf('Module') > -1 && module.default ? module.default : module
+                        }
+                        return module
+                    })
+                }
+                function merge(obj1, obj2) {
+                  const mergedObj = Object.assign(obj1, obj2);
+                  for (const key of Object.keys(mergedObj)) {
+                    if (typeof mergedObj[key] === 'object' && typeof obj2[key] === 'object') {
+                      mergedObj[key] = merge(mergedObj[key], obj2[key]);
+                    }
+                  }
+                  return mergedObj;
+                }
+                const wrapShareModule = ${REMOTE_FROM_PARAMETER} => {
+                  return merge({
+                    ${getModuleMarker("shareScope")}
+                  }, (globalThis.__federation_shared__ || {})['${shareScope}'] || {});
+                }
+                async function __federation_import(name) {
+                    currentImports[name] ??= import(name)
+                    return currentImports[name]
+                }
+                const initMap = Object.create(null);
+                async function __federation_method_ensure(remoteId) {
+                    const remote = remotesMap[remoteId];
+                    if (!remote.inited) {
+                        if ('var' === remote.format) {
+                            // loading js with script tag
+                            return new Promise(resolve => {
+                                const callback = () => {
+                                    if (!remote.inited) {
+                                        remote.lib = window[remoteId];
+                                        remote.lib.init(wrapShareModule(remote.from))
+                                        remote.inited = true;
+                                    }
+                                    resolve(remote.lib);
+                                }
+                                return loadJS(remote.url, callback);
+                            });
+                        } else if (['esm', 'systemjs'].includes(remote.format)) {
+                            // loading js with import(...)
+                            return new Promise((resolve, reject) => {
+                                const getUrl = typeof remote.url === 'function' ? remote.url : () => Promise.resolve(remote.url);
+                                getUrl().then(url => {
+                                    import(/* @vite-ignore */ url).then(lib => {
+                                        if (!remote.inited) {
+                                            const shareScope = wrapShareModule(remote.from);
+                                            lib.init(shareScope);
+                                            remote.lib = lib;
+                                            remote.lib.init(shareScope);
+                                            remote.inited = true;
+                                        }
+                                        resolve(remote.lib);
+                                    }).catch(reject)
+                                })
+                            })
+                        }
+                    } else {
+                        return remote.lib;
+                    }
+                }
+                function __federation_method_unwrapDefault(module) {
+                    return (module?.__esModule || module?.[Symbol.toStringTag] === 'Module') ? module.default : module
+                }
+                function __federation_method_wrapDefault(module, need) {
+                    if (!module?.default && need) {
+                        let obj = Object.create(null);
+                        obj.default = module;
+                        obj.__esModule = true;
+                        return obj;
+                    }
+                    return module;
+                }
+                function __federation_method_getRemote(remoteName, componentName) {
+                    return __federation_method_ensure(remoteName).then((remote) => remote.get(componentName).then(factory => factory()));
+                }
+                function __federation_method_setRemote(remoteName, remoteConfig) {
+                  remotesMap[remoteName] = remoteConfig;
+                }
+                async function __federation_method_add_origin_setRemote(remoteName, remoteUrl, options) {
+                  const _options = options || {}
+                  const _item = {
+                    external: Array.isArray(_options.external) ? _options.external : [_options.external],
+                    shareScope: _options.shareScope || 'default',
+                    format: _options.format || 'esm',
+                    from: _options.from ?? 'vite',
+                    externalType: _options.externalType || 'url'
+                  }
+                  __federation_method_setRemote(remoteName, {
+                    url: remoteUrl,
+                    format: _item.format,
+                    from: _item.from
+                  })
+                }
+                export {
+                    __federation_method_ensure,
+                    __federation_method_getRemote,
+                    __federation_method_setRemote,
+                    __federation_method_add_origin_setRemote,
+                    __federation_method_unwrapDefault,
+                    __federation_method_wrapDefault
+                }
+            `
+    } : { __federation__: "" },
+    configResolved(config) {
+      resolvedConfig = config;
+    },
+    async transform(code, id) {
+      if (builderInfo.isShared) {
+        for (const sharedInfo of parsedOptions.prodShared) {
+          if (!sharedInfo[1].emitFile) {
+            sharedInfo[1].emitFile = this.emitFile({
+              type: "chunk",
+              id: sharedInfo[1].id ?? sharedInfo[1].packagePath,
+              preserveSignature: "strict",
+              name: `__federation_shared_${sharedInfo[0]}`
+            });
+          }
+        }
+        if (id === "\0virtual:__federation_fn_import") {
+          const moduleMapCode = parsedOptions.prodShared.filter((shareInfo) => shareInfo[1].generate).map(
+            (sharedInfo) => `'${sharedInfo[0]}':{get:()=>()=>__federation_import(import.meta.ROLLUP_FILE_URL_${sharedInfo[1].emitFile}),import:${sharedInfo[1].import}${sharedInfo[1].requiredVersion ? `,requiredVersion:'${sharedInfo[1].requiredVersion}'` : ""}}`
+          ).join(",");
+          return code.replace(
+            getModuleMarker("moduleMap", "var"),
+            `{${moduleMapCode}}`
+          );
+        }
+      }
+      if (builderInfo.isRemote) {
+        for (const expose of parsedOptions.prodExpose) {
+          if (!expose[1].emitFile) {
+            expose[1].emitFile = this.emitFile({
+              type: "chunk",
+              id: expose[1].id ?? expose[1].import,
+              name: EXPOSES_KEY_MAP.get(expose[0]),
+              preserveSignature: "allow-extension"
+            });
+          }
+        }
+      }
+      if (builderInfo.isHost) {
+        if (id === "\0virtual:__federation__") {
+          const res = [];
+          parsedOptions.prodShared.forEach((arr) => {
+            const obj = arr[1];
+            let str = "";
+            if (typeof obj === "object") {
+              const fileUrl = `import.meta.ROLLUP_FILE_URL_${obj.emitFile}`;
+              str += `get:()=>get(${fileUrl}, ${REMOTE_FROM_PARAMETER}), loaded:1`;
+              res.push(`'${arr[0]}':{'${obj.version}':{${str}}}`);
+            }
+          });
+          return code.replace(getModuleMarker("shareScope"), res.join(","));
+        }
+      } else {
+        if (id === "\0virtual:__federation__") {
+          return code.replace(getModuleMarker("shareScope"), "");
+        }
+      }
+      if (builderInfo.isHost || builderInfo.isShared) {
+        let ast = null;
+        try {
+          ast = this.parse(code);
+        } catch (err) {
+          console.error(err);
+        }
+        if (!ast) {
+          return null;
+        }
+        const magicString = new MagicString(code);
+        const hasStaticImported = /* @__PURE__ */ new Map();
+        let requiresRuntime = false;
+        let hasImportShared = false;
+        let modify = false;
+        let manualRequired = null;
+        walk(ast, {
+          enter(node) {
+            if (node.type === "ImportDeclaration") {
+              const moduleName = node.source.value;
+              if (parsedOptions.prodShared.some(
+                (sharedInfo) => sharedInfo[0] === moduleName
+              )) {
+                const namedImportDeclaration = [];
+                let defaultImportDeclaration = null;
+                if (!node.specifiers?.length) {
+                  magicString.remove(node.start, node.end);
+                  modify = true;
+                } else {
+                  node.specifiers.forEach((specify) => {
+                    if (specify.imported?.name) {
+                      namedImportDeclaration.push(
+                        `${specify.imported.name === specify.local.name ? specify.imported.name : `${specify.imported.name}:${specify.local.name}`}`
+                      );
+                    } else {
+                      defaultImportDeclaration = specify.local.name;
+                    }
+                  });
+                  hasImportShared = true;
+                  if (defaultImportDeclaration && namedImportDeclaration.length) {
+                    const imports = namedImportDeclaration.join(",");
+                    const line = `const ${defaultImportDeclaration} = await importShared('${moduleName}');
+const {${imports}} = ${defaultImportDeclaration};
+`;
+                    magicString.overwrite(node.start, node.end, line);
+                  } else if (defaultImportDeclaration) {
+                    magicString.overwrite(
+                      node.start,
+                      node.end,
+                      `const ${defaultImportDeclaration} = await importShared('${moduleName}');
+`
+                    );
+                  } else if (namedImportDeclaration.length) {
+                    magicString.overwrite(
+                      node.start,
+                      node.end,
+                      `const {${namedImportDeclaration.join(
+                        ","
+                      )}} = await importShared('${moduleName}');
+`
+                    );
+                  }
+                }
+              }
+            }
+            if (node.type === "ImportDeclaration" && node.source?.value === "virtual:__federation__") {
+              manualRequired = node;
+            }
+            if ((node.type === "ImportExpression" || node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration") && node.source?.value?.indexOf("/") > -1) {
+              const moduleId = node.source.value;
+              const remote = prodRemotes.find((r) => r.regexp.test(moduleId));
+              const needWrap = remote?.config.from === "vite";
+              if (remote) {
+                requiresRuntime = true;
+                const modName = `.${moduleId.slice(remote.id.length)}`;
+                switch (node.type) {
+                  case "ImportExpression": {
+                    magicString.overwrite(
+                      node.start,
+                      node.end,
+                      `__federation_method_getRemote(${JSON.stringify(
+                        remote.id
+                      )} , ${JSON.stringify(
+                        modName
+                      )}).then(module=>__federation_method_wrapDefault(module, ${needWrap}))`
+                    );
+                    break;
+                  }
+                  case "ImportDeclaration": {
+                    if (node.specifiers?.length) {
+                      const afterImportName = `__federation_var_${moduleId.replace(
+                        /[@/\\.-]/g,
+                        ""
+                      )}`;
+                      if (!hasStaticImported.has(moduleId)) {
+                        hasStaticImported.set(moduleId, afterImportName);
+                        magicString.overwrite(
+                          node.start,
+                          node.end,
+                          `const ${afterImportName} = await __federation_method_getRemote(${JSON.stringify(
+                            remote.id
+                          )} , ${JSON.stringify(modName)});`
+                        );
+                      }
+                      let deconstructStr = "";
+                      node.specifiers.forEach((spec) => {
+                        if (spec.type === "ImportDefaultSpecifier") {
+                          magicString.appendRight(
+                            node.end,
+                            `
+ let ${spec.local.name} = __federation_method_unwrapDefault(${afterImportName}) `
+                          );
+                        } else if (spec.type === "ImportSpecifier") {
+                          const importedName = spec.imported.name;
+                          const localName = spec.local.name;
+                          deconstructStr += `${importedName === localName ? localName : `${importedName} : ${localName}`},`;
+                        } else if (spec.type === "ImportNamespaceSpecifier") {
+                          magicString.appendRight(
+                            node.end,
+                            `let {${spec.local.name}} = ${afterImportName}`
+                          );
+                        }
+                      });
+                      if (deconstructStr.length > 0) {
+                        magicString.appendRight(
+                          node.end,
+                          `
+ let {${deconstructStr.slice(
+                            0,
+                            -1
+                          )}} = ${afterImportName}`
+                        );
+                      }
+                    }
+                    break;
+                  }
+                  case "ExportNamedDeclaration": {
+                    const afterImportName = `__federation_var_${moduleId.replace(
+                      /[@/\\.-]/g,
+                      ""
+                    )}`;
+                    if (!hasStaticImported.has(moduleId)) {
+                      hasStaticImported.set(moduleId, afterImportName);
+                      magicString.overwrite(
+                        node.start,
+                        node.end,
+                        `const ${afterImportName} = await __federation_method_getRemote(${JSON.stringify(
+                          remote.id
+                        )} , ${JSON.stringify(modName)});`
+                      );
+                    }
+                    if (node.specifiers.length > 0) {
+                      const specifiers = node.specifiers;
+                      let exportContent = "";
+                      let deconstructContent = "";
+                      specifiers.forEach((spec) => {
+                        const localName = spec.local.name;
+                        const exportName = spec.exported.name;
+                        const variableName = `${afterImportName}_${localName}`;
+                        deconstructContent = deconstructContent.concat(
+                          `${localName}:${variableName},`
+                        );
+                        exportContent = exportContent.concat(
+                          `${variableName} as ${exportName},`
+                        );
+                      });
+                      magicString.append(
+                        `
+ const {${deconstructContent.slice(
+                          0,
+                          deconstructContent.length - 1
+                        )}} = ${afterImportName};
+`
+                      );
+                      magicString.append(
+                        `
+ export {${exportContent.slice(
+                          0,
+                          exportContent.length - 1
+                        )}}; `
+                      );
+                    }
+                    break;
+                  }
+                }
+              }
+            }
+          }
+        });
+        if (requiresRuntime) {
+          let requiresCode = `import {__federation_method_ensure, __federation_method_getRemote , __federation_method_wrapDefault , __federation_method_unwrapDefault, __federation_method_add_origin_setRemote} from '__federation__';
+`;
+          if (manualRequired) {
+            requiresCode = `import {__federation_method_setRemote, __federation_method_ensure, __federation_method_getRemote , __federation_method_wrapDefault , __federation_method_unwrapDefault, __federation_method_add_origin_setRemote} from '__federation__';
+`;
+            magicString.overwrite(manualRequired.start, manualRequired.end, ``);
+          }
+          magicString.prepend(requiresCode);
+        }
+        if (hasImportShared) {
+          magicString.prepend(
+            `import {importShared} from '\0virtual:__federation_fn_import';
+`
+          );
+        }
+        if (requiresRuntime || hasImportShared || modify) {
+          return {
+            code: magicString.toString(),
+            map: magicString.generateMap({ hires: true })
+          };
+        }
+      }
+    },
+    generateBundle(options2, bundle) {
+      const preloadSharedReg = parsedOptions.prodShared.filter((shareInfo) => shareInfo[1].modulePreload).map(
+        (item) => new RegExp(`__federation_shared_${item[0]}-.{8}.js`, "g")
+      );
+      const getImportedChunks = (chunk, satisfy, seen = /* @__PURE__ */ new Set()) => {
+        const chunks = [];
+        chunk.imports.forEach((file) => {
+          const importee = bundle[file];
+          if (importee) {
+            if (importee.type === "chunk" && !seen.has(file)) {
+              if (satisfy(importee)) {
+                seen.add(file);
+                chunks.push(...getImportedChunks(importee, satisfy, seen));
+                chunks.push(importee);
+              }
+            }
+          }
+        });
+        return chunks;
+      };
+      const sharedFiles = [];
+      const entryChunk = {};
+      for (const fileName in bundle) {
+        const file = bundle[fileName];
+        if (file.type === "asset") {
+          if (fileName.endsWith(".html")) {
+            entryChunk[fileName] = file;
+          }
+        } else {
+          if (preloadSharedReg.some((item) => item.test(fileName))) {
+            sharedFiles.push(fileName);
+          }
+        }
+      }
+      if (!sharedFiles.length) return;
+      Object.keys(entryChunk).forEach((fileName) => {
+        let html = entryChunk[fileName].source;
+        const htmlPath = entryChunk[fileName].fileName;
+        const basePath = resolvedConfig.base === "./" || resolvedConfig.base === "" ? path$1.posix.join(
+          path$1.posix.relative(entryChunk[fileName].fileName, "").slice(0, -2),
+          "./"
+        ) : resolvedConfig.base;
+        const toOutputFilePath = (filename) => toOutputFilePathWithoutRuntime(
+          filename,
+          "asset",
+          htmlPath,
+          "html",
+          resolvedConfig,
+          (filename2) => basePath + filename2
+        );
+        const importFiles = sharedFiles.filter((item) => {
+          return !html.includes(toOutputFilePath(item));
+        }).flatMap((item) => {
+          const filepath = item;
+          const importFiles2 = getImportedChunks(
+            bundle[item],
+            (chunk) => !html.includes(toOutputFilePath(chunk.fileName))
+          ).map((item2) => item2.fileName);
+          return [filepath, ...importFiles2].map(
+            (item2) => toOutputFilePath(item2)
+          );
+        });
+        html = injectToHead(
+          html,
+          [...new Set(importFiles)].map((item) => toPreloadTag(item))
+        );
+        entryChunk[fileName].source = html;
+      });
+    }
+  };
+}
+const federation_fn_import = "import { satisfy } from '__federation_fn_satisfy'\r\n\r\nconst currentImports = {}\r\n\r\n// eslint-disable-next-line no-undef\r\nconst moduleMap = __rf_var__moduleMap\r\nconst moduleCache = Object.create(null)\r\nasync function importShared(name, shareScope = 'default') {\r\n  return moduleCache[name]\r\n    ? new Promise((r) => r(moduleCache[name]))\r\n    : (await getSharedFromRuntime(name, shareScope)) || getSharedFromLocal(name)\r\n}\r\n// eslint-disable-next-line\r\nasync function __federation_import(name) {\r\n  currentImports[name] ??= import(name)\r\n  return currentImports[name]\r\n}\r\nasync function getSharedFromRuntime(name, shareScope) {\r\n  let module = null\r\n  if (globalThis?.__federation_shared__?.[shareScope]?.[name]) {\r\n    const versionObj = globalThis.__federation_shared__[shareScope][name]\r\n    const requiredVersion = moduleMap[name]?.requiredVersion\r\n    const hasRequiredVersion = !!requiredVersion\r\n    if (hasRequiredVersion) {\r\n      const versionKey = Object.keys(versionObj).find((version) =>\r\n        satisfy(version, requiredVersion)\r\n      )\r\n      if (versionKey) {\r\n        const versionValue = versionObj[versionKey]\r\n        module = await (await versionValue.get())()\r\n      } else {\r\n        console.log(\r\n          `provider support ${name}(${versionKey}) is not satisfied requiredVersion(\\${moduleMap[name].requiredVersion})`\r\n        )\r\n      }\r\n    } else {\r\n      const versionKey = Object.keys(versionObj)[0]\r\n      const versionValue = versionObj[versionKey]\r\n      module = await (await versionValue.get())()\r\n    }\r\n  }\r\n  if (module) {\r\n    return flattenModule(module, name)\r\n  }\r\n}\r\nasync function getSharedFromLocal(name) {\r\n  if (moduleMap[name]?.import) {\r\n    let module = await (await moduleMap[name].get())()\r\n    return flattenModule(module, name)\r\n  } else {\r\n    console.error(\r\n      `consumer config import=false,so cant use callback shared module`\r\n    )\r\n  }\r\n}\r\nfunction flattenModule(module, name) {\r\n  // use a shared module which export default a function will getting error 'TypeError: xxx is not a function'\r\n  if (typeof module.default === 'function') {\r\n    Object.keys(module).forEach((key) => {\r\n      if (key !== 'default') {\r\n        module.default[key] = module[key]\r\n      }\r\n    })\r\n    moduleCache[name] = module.default\r\n    return module.default\r\n  }\r\n  if (module.default) module = Object.assign({}, module.default, module)\r\n  moduleCache[name] = module\r\n  return module\r\n}\r\nexport {\r\n  importShared,\r\n  getSharedFromRuntime as importSharedRuntime,\r\n  getSharedFromLocal as importSharedLocal\r\n}\r\n";
+const sharedFilePathReg = /__federation_shared_(.+)-.{8}\.js$/;
+function prodSharedPlugin(options) {
+  parsedOptions.prodShared = parseSharedOptions(options);
+  const shareName2Prop = /* @__PURE__ */ new Map();
+  parsedOptions.prodShared.forEach(
+    (value) => shareName2Prop.set(removeNonRegLetter(value[0], NAME_CHAR_REG), value[1])
+  );
+  let isHost;
+  let isRemote;
+  const id2Prop = /* @__PURE__ */ new Map();
+  function negotiateManualChunksCompatibility(inputOptions) {
+    if (!inputOptions.output) return;
+    const outputs = Array.isArray(inputOptions.output) ? inputOptions.output : [inputOptions.output];
+    outputs.forEach((output) => {
+      if (!output.manualChunks) return;
+      const sharedModuleNames = [...shareName2Prop.keys()];
+      const conflictModules = /* @__PURE__ */ new Set();
+      if (typeof output.manualChunks === "object") {
+        Object.values(output.manualChunks).flat().forEach((mod) => {
+          if (sharedModuleNames.some((shared) => mod.includes(shared) || mod === shared)) {
+            conflictModules.add(mod);
+          }
+        });
+      }
+      if (conflictModules.size > 0) {
+        console.info(
+          `[Federation] 检测到模块 [${Array.from(conflictModules).join(", ")}] 同时配置在 shared 和 manualChunks 中，启用协商共存模式`
+        );
+        adaptSharedToManualChunks(conflictModules);
+      }
+    });
+  }
+  function adaptSharedToManualChunks(conflictModules) {
+    parsedOptions.prodShared.forEach((sharedItem, index) => {
+      const [moduleName, config] = sharedItem;
+      if (conflictModules.has(moduleName)) {
+        config.manualChunkCompat = true;
+        config.chunkLoading = "defer";
+        console.info(
+          `[Federation] 模块 "${moduleName}" 设置为兼容模式：manualChunks 负责分块，federation 负责运行时共享`
+        );
+      }
+    });
+  }
+  return {
+    name: "originjs:shared-production",
+    virtualFile: {
+      __federation_fn_import: federation_fn_import
+    },
+    options(inputOptions) {
+      isRemote = !!parsedOptions.prodExpose.length;
+      isHost = options.isHost;
+      if (shareName2Prop.size) {
+        inputOptions.external = inputOptions.external?.filter((item) => {
+          if (item instanceof RegExp)
+            return ![...shareName2Prop.keys()].some((key) => item.test(key));
+          return !shareName2Prop.has(removeNonRegLetter(item, NAME_CHAR_REG));
+        });
+      }
+      negotiateManualChunksCompatibility(inputOptions);
+      return inputOptions;
+    },
+    async buildStart() {
+      if (parsedOptions.prodShared.length && isRemote) {
+        this.emitFile({
+          name: "__federation_fn_import",
+          type: "chunk",
+          id: "__federation_fn_import",
+          preserveSignature: "strict"
+        });
+      }
+      const collectDirFn = (filePath, collect) => {
+        const files = readdirSync(filePath);
+        files.forEach((name) => {
+          const tempPath = join(filePath, name);
+          const isDir = statSync(tempPath).isDirectory();
+          if (isDir) {
+            collect.push(tempPath);
+            collectDirFn(tempPath, collect);
+          }
+        });
+      };
+      const monoRepos = [];
+      const dirPaths = [];
+      const currentDir = resolve();
+      for (const arr of parsedOptions.prodShared) {
+        if (isHost && !arr[1].version && !arr[1].manuallyPackagePathSetting) {
+          const packageJsonPath = (await this.resolve(`${arr[1].packagePath}/package.json`))?.id;
+          if (packageJsonPath) {
+            const packageJson = JSON.parse(
+              readFileSync(packageJsonPath, { encoding: "utf-8" })
+            );
+            arr[1].version = packageJson.version;
+          } else {
+            arr[1].removed = true;
+            const dir = join(currentDir, "node_modules", arr[0]);
+            const dirStat = statSync(dir);
+            if (dirStat.isDirectory()) {
+              collectDirFn(dir, dirPaths);
+            } else {
+              this.error(`cant resolve "${arr[1].packagePath}"`);
+            }
+            if (dirPaths.length > 0) {
+              monoRepos.push({ arr: dirPaths, root: arr });
+            }
+          }
+          if (!arr[1].removed && !arr[1].version) {
+            this.error(
+              `No description file or no version in description file (usually package.json) of ${arr[0]}. Add version to description file, or manually specify version in shared config.`
+            );
+          }
+        }
+      }
+      parsedOptions.prodShared = parsedOptions.prodShared.filter(
+        (item) => !item[1].removed
+      );
+      if (monoRepos.length > 0) {
+        for (const monoRepo of monoRepos) {
+          for (const id of monoRepo.arr) {
+            try {
+              const idResolve = await this.resolve(id);
+              if (idResolve?.id) {
+                parsedOptions.prodShared.push([
+                  `${monoRepo.root[0]}/${basename(id)}`,
+                  {
+                    id: idResolve?.id,
+                    import: monoRepo.root[1].import,
+                    shareScope: monoRepo.root[1].shareScope,
+                    root: monoRepo.root
+                  }
+                ]);
+              }
+            } catch (e) {
+            }
+          }
+        }
+      }
+      if (parsedOptions.prodShared.length && isRemote) {
+        for (const prod of parsedOptions.prodShared) {
+          id2Prop.set(prod[1].id, prod[1]);
+        }
+      }
+    },
+    outputOptions: function(outputOption) {
+      outputOption.hoistTransitiveImports = false;
+      const manualChunkFunc = (id) => {
+        const find = parsedOptions.prodShared.find(
+          (arr) => arr[1].dependencies?.has(id)
+        );
+        return find ? find[0] : void 0;
+      };
+      if (typeof outputOption.manualChunks === "function") {
+        outputOption.manualChunks = new Proxy(outputOption.manualChunks, {
+          apply(target, thisArg, argArray) {
+            const result = manualChunkFunc(argArray[0]);
+            return result ? result : target(argArray[0], argArray[1]);
+          }
+        });
+      }
+      if (outputOption.manualChunks === void 0) {
+        outputOption.manualChunks = manualChunkFunc;
+      }
+      return outputOption;
+    },
+    generateBundle(options2, bundle) {
+      if (!isRemote) {
+        return;
+      }
+      const needRemoveShared = /* @__PURE__ */ new Set();
+      for (const key in bundle) {
+        const chunk = bundle[key];
+        if (chunk.type === "chunk") {
+          if (!isHost) {
+            const regRst = sharedFilePathReg.exec(chunk.fileName);
+            if (regRst && shareName2Prop.get(removeNonRegLetter(regRst[1], NAME_CHAR_REG))?.generate === false) {
+              needRemoveShared.add(key);
+            }
+          }
+        }
+      }
+      if (needRemoveShared.size !== 0) {
+        for (const key of needRemoveShared) {
+          delete bundle[key];
+        }
+      }
+    }
+  };
+}
+function prodExposePlugin(options) {
+  let moduleMap = "";
+  const hasOptions = parsedOptions.prodExpose.some((expose) => {
+    return expose[0] === parseExposeOptions(options)[0]?.[0];
+  });
+  if (!hasOptions) {
+    parsedOptions.prodExpose = Array.prototype.concat(
+      parsedOptions.prodExpose,
+      parseExposeOptions(options)
+    );
+  }
+  for (const item of parseExposeOptions(options)) {
+    getModuleMarker(`\${${item[0]}}`, SHARED);
+    const exposeFilepath = normalizePath(resolve(item[1].import));
+    EXPOSES_MAP.set(item[0], exposeFilepath);
+    EXPOSES_KEY_MAP.set(
+      item[0],
+      `__federation_expose_${removeNonRegLetter(item[0], NAME_CHAR_REG)}`
+    );
+    moduleMap += `
+"${item[0]}":()=>{
+      ${DYNAMIC_LOADING_CSS}('${DYNAMIC_LOADING_CSS_PREFIX}${exposeFilepath}', ${item[1].dontAppendStylesToHead}, '${item[0]}')
+      return __federation_import('\${__federation_expose_${item[0]}}').then(module =>Object.keys(module).every(item => exportSet.has(item)) ? () => module.default : () => module)},`;
+  }
+  return {
+    name: "originjs:expose-production",
+    virtualFile: {
+      // code generated for remote
+      // language=JS
+      [`__remoteEntryHelper__${options.filename}`]: `
+      const currentImports = {}
+      const exportSet = new Set(['Module', '__esModule', 'default', '_export_sfc']);
+      let moduleMap = {${moduleMap}}
+      const seen = {}
+      export const ${DYNAMIC_LOADING_CSS} = (cssFilePaths, dontAppendStylesToHead, exposeItemName) => {
+        const metaUrl = import.meta.url;
+        if (typeof metaUrl === 'undefined') {
+          console.warn('The remote style takes effect only when the build.target option in the vite.config.ts file is higher than that of "es2020".');
+          return;
+        }
+        const curUrl = metaUrl.substring(0, metaUrl.lastIndexOf('${options.filename}'));
+        const base = __VITE_BASE_PLACEHOLDER__;
+        const assetsDir = __VITE_ASSETS_DIR_PLACEHOLDER__;
+        cssFilePaths.forEach(cssPath => {
+         let href = '';
+         const baseUrl = base || curUrl;
+         if (baseUrl) {
+           const trimmer = {
+             trailing: (path) => (path.endsWith('/') ? path.slice(0, -1) : path),
+             leading: (path) => (path.startsWith('/') ? path.slice(1) : path)
+           }
+           const isAbsoluteUrl = (url) => url.startsWith('http') || url.startsWith('//');
+           const cleanBaseUrl = trimmer.trailing(baseUrl).replace('.', '');
+           const cleanAssetsDir = trimmer.leading(assetsDir);
+           const cleanCssPath = trimmer.leading(cssPath);
+           const cleanCurUrl = trimmer.trailing(curUrl);
+           if (isAbsoluteUrl(baseUrl)) {
+             href = [cleanBaseUrl, cleanAssetsDir, cleanCssPath].filter(Boolean).join('/');
+           } else {
+            // 当remoteEntry.js和CSS都在assets目录下时，使用相对路径
+            const remoteEntryInAssets = cleanCurUrl.endsWith('/assets/') || cleanCurUrl.endsWith('/assets');
+            if (remoteEntryInAssets) {
+              // 都在assets目录下，直接使用CSS文件名
+              href = [cleanCurUrl, cleanCssPath].filter(Boolean).join('/');
+            } else if (cleanCurUrl.includes(cleanBaseUrl)) {
+              href = [cleanCurUrl, cleanAssetsDir, cleanCssPath].filter(Boolean).join('/');
+            } else {
+              href = [cleanCurUrl + cleanBaseUrl, cleanAssetsDir, cleanCssPath].filter(Boolean).join('/');
+            }
+           }
+         } else {
+           href = cssPath;
+         }
+          if (dontAppendStylesToHead) {
+            const key = 'css__${options.name}__' + exposeItemName;
+            window[key] = window[key] || [];
+            window[key].push(href);
+            return;
+          }
+          if (href in seen) return;
+          seen[href] = true;
+          const element = document.createElement('link');
+          element.rel = 'stylesheet';
+          element.href = href;
+          document.head.appendChild(element);
+        });
+      };
+      async function __federation_import(name) {
+        currentImports[name] ??= import(name)
+        return currentImports[name]
+      };
+      export const get =(module) => {
+        if(!moduleMap[module]) throw new Error('Can not find remote module ' + module)
+        return moduleMap[module]();
+      };
+      export const init =(shareScope) => {
+        globalThis.__federation_shared__= globalThis.__federation_shared__|| {};
+        Object.entries(shareScope).forEach(([key, value]) => {
+          for (const [versionKey, versionValue] of Object.entries(value)) {
+            const scope = versionValue.scope || 'default'
+            globalThis.__federation_shared__[scope] = globalThis.__federation_shared__[scope] || {};
+            const shared= globalThis.__federation_shared__[scope];
+            (shared[key] = shared[key]||{})[versionKey] = versionValue;
+          }
+        });
+      }`
+    },
+    configResolved(config) {
+      if (config) {
+        viteConfigResolved.config = config;
+      }
+    },
+    buildStart() {
+      if (parsedOptions.prodExpose.length > 0) {
+        const assetsDir = builderInfo.assetsDir;
+        this.emitFile({
+          fileName: assetsDir ? `${assetsDir}/${options.filename}` : options.filename,
+          type: "chunk",
+          id: `__remoteEntryHelper__${options.filename}`,
+          preserveSignature: "strict"
+        });
+      }
+    },
+    generateBundle(_options, bundle) {
+      let remoteEntryChunk;
+      for (const file in bundle) {
+        const chunk = bundle[file];
+        if (chunk?.facadeModuleId === `\0virtual:__remoteEntryHelper__${options.filename}`) {
+          remoteEntryChunk = chunk;
+          break;
+        }
+      }
+      if (remoteEntryChunk) {
+        remoteEntryChunk.code = remoteEntryChunk.code.replace(
+          "__VITE_BASE_PLACEHOLDER__",
+          `'${viteConfigResolved.config?.base || ""}'`
+        ).replace(
+          "__VITE_ASSETS_DIR_PLACEHOLDER__",
+          `'${builderInfo.assetsDir || ""}'`
+        );
+        const filepathMap = /* @__PURE__ */ new Map();
+        const getFilename = (name) => parse(parse(name).name).name;
+        const cssBundlesMap = Object.keys(bundle).filter((name) => extname(name) === ".css").reduce((res, name) => {
+          const filename = getFilename(name);
+          res.set(filename, bundle[name]);
+          return res;
+        }, /* @__PURE__ */ new Map());
+        remoteEntryChunk.code = remoteEntryChunk.code.replace(
+          new RegExp(`(["'])${DYNAMIC_LOADING_CSS_PREFIX}.*?\\1`, "g"),
+          (str) => {
+            if (viteConfigResolved.config && !viteConfigResolved.config.build.cssCodeSplit) {
+              if (cssBundlesMap.size) {
+                return `[${[...cssBundlesMap.values()].map(
+                  (cssBundle) => JSON.stringify(basename(cssBundle.fileName))
+                ).join(",")}]`;
+              } else {
+                return "[]";
+              }
+            }
+            const filepath = str.slice(
+              (`'` + DYNAMIC_LOADING_CSS_PREFIX).length,
+              -1
+            );
+            if (!filepath || !filepath.length) return str;
+            let fileBundle = filepathMap.get(filepath);
+            if (!fileBundle) {
+              fileBundle = Object.values(bundle).find(
+                (b) => "facadeModuleId" in b && b.facadeModuleId === filepath
+              );
+              if (fileBundle) filepathMap.set(filepath, fileBundle);
+              else return str;
+            }
+            const depCssFiles = /* @__PURE__ */ new Set();
+            const addDepCss = (bundleName) => {
+              const theBundle = bundle[bundleName];
+              if (theBundle && theBundle.viteMetadata) {
+                for (const cssFileName of theBundle.viteMetadata.importedCss.values()) {
+                  const cssBundle = cssBundlesMap.get(getFilename(cssFileName));
+                  if (cssBundle) {
+                    depCssFiles.add(cssBundle.fileName);
+                  }
+                }
+              }
+              if (theBundle && theBundle.imports && theBundle.imports.length) {
+                theBundle.imports.forEach((name) => addDepCss(name));
+              }
+            };
+            [fileBundle.fileName, ...fileBundle.imports].forEach(addDepCss);
+            return `[${[...depCssFiles].map((d) => JSON.stringify(basename(d))).join(",")}]`;
+          }
+        );
+        for (const expose of parseExposeOptions(options)) {
+          const module = Object.keys(bundle).find((module2) => {
+            const chunk = bundle[module2];
+            return chunk.name === EXPOSES_KEY_MAP.get(expose[0]);
+          });
+          if (module) {
+            const chunk = bundle[module];
+            const fileRelativePath = relative(
+              dirname(remoteEntryChunk.fileName),
+              chunk.fileName
+            );
+            const slashPath = fileRelativePath.replace(/\\/g, "/");
+            remoteEntryChunk.code = remoteEntryChunk.code.replace(
+              `\${__federation_expose_${expose[0]}}`,
+              viteConfigResolved.config?.base?.replace(/\/+$/, "") ? [
+                viteConfigResolved.config.base.replace(/\/+$/, ""),
+                slashPath
+              ].filter(Boolean).join("/") : `./${slashPath}`
+            );
+          }
+        }
+        let ast = null;
+        try {
+          ast = this.parse(remoteEntryChunk.code);
+        } catch (err) {
+          console.error(err);
+        }
+        if (!ast) {
+          return;
+        }
+        const magicString = new MagicString(remoteEntryChunk.code);
+        walk(ast, {
+          enter(node) {
+            if (node && node.type === "CallExpression" && typeof node.arguments[0]?.value === "string" && node.arguments[0]?.value.indexOf(
+              `${DYNAMIC_LOADING_CSS_PREFIX}`
+            ) > -1) {
+              magicString.remove(node.start, node.end + 1);
+            }
+          }
+        });
+        remoteEntryChunk.code = magicString.toString();
+      }
+    }
+  };
+}
+function devSharedPlugin(options) {
+  parsedOptions.devShared = parseSharedOptions(options);
+  return {
+    name: "originjs:shared-development"
+  };
+}
+function devRemotePlugin(options) {
+  parsedOptions.devRemote = parseRemoteOptions(options);
+  for (const item of parsedOptions.devRemote) {
+    devRemotes.push({
+      id: item[0],
+      regexp: new RegExp(`^${item[0]}/.+?`),
+      config: item[1]
+    });
+  }
+  const needHandleFileType = [
+    ".js",
+    ".ts",
+    ".jsx",
+    ".tsx",
+    ".mjs",
+    ".cjs",
+    ".vue",
+    ".svelte"
+  ];
+  options.transformFileTypes = (options.transformFileTypes ?? []).concat(needHandleFileType).map((item) => item.toLowerCase());
+  const transformFileTypeSet = new Set(options.transformFileTypes);
+  let viteDevServer;
+  return {
+    name: "originjs:remote-development",
+    virtualFile: options.remotes || options.enableDynamicRemotes ? {
+      __federation__: `
+${createRemotesMap(devRemotes)}
+const loadJS = async (url, fn) => {
+  const resolvedUrl = typeof url === 'function' ? await url() : url;
+  const script = document.createElement('script')
+  script.type = 'text/javascript';
+  script.onload = fn;
+  script.src = resolvedUrl;
+  document.getElementsByTagName('head')[0].appendChild(script);
+}
+function get(name, ${REMOTE_FROM_PARAMETER}){
+  return import(/* @vite-ignore */ name).then(module => ()=> {
+    if (${REMOTE_FROM_PARAMETER} === 'webpack') {
+      return Object.prototype.toString.call(module).indexOf('Module') > -1 && module.default ? module.default : module
+    }
+    return module
+  })
+}
+const wrapShareScope = ${REMOTE_FROM_PARAMETER} => {
+  return {
+    ${getModuleMarker("shareScope")}
+  }
+}
+const initMap = Object.create(null);
+async function __federation_method_ensure(remoteId) {
+  const remote = remotesMap[remoteId];
+  if (!remote.inited) {
+    if ('var' === remote.format) {
+      // loading js with script tag
+      return new Promise(resolve => {
+        const callback = () => {
+          if (!remote.inited) {
+            remote.lib = window[remoteId];
+            remote.lib.init(wrapShareScope(remote.from))
+            remote.inited = true;
+          }
+          resolve(remote.lib);
+        }
+        return loadJS(remote.url, callback);
+      });
+    } else if (['esm', 'systemjs'].includes(remote.format)) {
+      // loading js with import(...)
+      return new Promise((resolve, reject) => {
+        const getUrl = typeof remote.url === 'function' ? remote.url : () => Promise.resolve(remote.url);
+        getUrl().then(url => {
+          import(/* @vite-ignore */ url).then(lib => {
+            if (!remote.inited) {
+              const shareScope = wrapShareScope(remote.from)
+              lib.init(shareScope);
+              remote.lib = lib;
+              remote.lib.init(shareScope);
+              remote.inited = true;
+            }
+            resolve(remote.lib);
+          }).catch(reject)
+        })
+      })
+    }
+  } else {
+    return remote.lib;
+  }
+}
+function __federation_method_unwrapDefault(module) {
+  return (module?.__esModule || module?.[Symbol.toStringTag] === 'Module')?module.default:module
+}
+function __federation_method_wrapDefault(module ,need){
+  if (!module?.default && need) {
+    let obj = Object.create(null);
+    obj.default = module;
+    obj.__esModule = true;
+    return obj;
+  }
+  return module;
+}
+function __federation_method_getRemote(remoteName,  componentName){
+  return __federation_method_ensure(remoteName).then((remote) => remote.get(componentName).then(factory => factory()));
+}
+function __federation_method_setRemote(remoteName, remoteConfig) {
+  remotesMap[remoteName] = remoteConfig;
+}
+async function __federation_method_add_origin_setRemote(remoteName, remoteUrl, options) {
+  const _options = options || {}
+                    const _item = {
+                        external: Array.isArray(_options.external) ? _options.external : [_options.external],
+                        shareScope: _options.shareScope || 'default',
+                        format: _options.format || 'esm',
+                        from: _options.from ?? 'vite',
+                        externalType: _options.externalType || 'url'
+                    }
+                    __federation_method_setRemote(remoteName, {
+                        url: remoteUrl,
+                        format: _item.format,
+                        from: _item.from
+                    })
+}
+export {__federation_method_ensure, __federation_method_getRemote , __federation_method_setRemote , __federation_method_unwrapDefault , __federation_method_wrapDefault, __federation_method_add_origin_setRemote}
+;`
+    } : { __federation__: "" },
+    config(config) {
+      if (parsedOptions.devRemote.length) {
+        const excludeRemotes = [];
+        parsedOptions.devRemote.forEach((item) => excludeRemotes.push(item[0]));
+        let optimizeDeps = config.optimizeDeps;
+        if (!optimizeDeps) {
+          optimizeDeps = config.optimizeDeps = {};
+        }
+        if (!optimizeDeps.exclude) {
+          optimizeDeps.exclude = [];
+        }
+        optimizeDeps.exclude = optimizeDeps.exclude.concat(excludeRemotes);
+      }
+    },
+    configureServer(server) {
+      viteDevServer = server;
+    },
+    async transform(code, id) {
+      if (builderInfo.isHost && !builderInfo.isRemote) {
+        for (const arr of parsedOptions.devShared) {
+          if (!arr[1].version && !arr[1].manuallyPackagePathSetting) {
+            const packageJsonPath = (await this.resolve(`${arr[0]}/package.json`))?.id;
+            if (!packageJsonPath) {
+              this.error(
+                `No description file or no version in description file (usually package.json) of ${arr[0]}(${packageJsonPath}). Add version to description file, or manually specify version in shared config.`
+              );
+            } else {
+              const json = JSON.parse(
+                readFileSync(packageJsonPath, { encoding: "utf-8" })
+              );
+              arr[1].version = json.version;
+            }
+          }
+        }
+      }
+      if (id === "\0virtual:__federation__") {
+        const scopeCode = await devSharedScopeCode.call(
+          this,
+          parsedOptions.devShared
+        );
+        return code.replace(getModuleMarker("shareScope"), scopeCode.join(","));
+      }
+      const fileExtname = getFileExtname(id);
+      if (!transformFileTypeSet.has((fileExtname ?? "").toLowerCase())) {
+        return;
+      }
+      let ast = null;
+      try {
+        ast = this.parse(code);
+      } catch (err) {
+        console.error(err);
+      }
+      if (!ast) {
+        return null;
+      }
+      const magicString = new MagicString(code);
+      const hasStaticImported = /* @__PURE__ */ new Map();
+      let requiresRuntime = false;
+      let manualRequired = null;
+      walk(ast, {
+        enter(node) {
+          if (node.type === "ImportDeclaration" && node.source?.value === "virtual:__federation__") {
+            manualRequired = node;
+          }
+          if ((node.type === "ImportExpression" || node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration") && node.source?.value?.indexOf("/") > -1) {
+            const moduleId = node.source.value;
+            const remote = devRemotes.find((r) => r.regexp.test(moduleId));
+            const needWrap = remote?.config.from === "vite";
+            if (remote) {
+              requiresRuntime = true;
+              const modName = `.${moduleId.slice(remote.id.length)}`;
+              switch (node.type) {
+                case "ImportExpression": {
+                  magicString.overwrite(
+                    node.start,
+                    node.end,
+                    `__federation_method_getRemote(${JSON.stringify(
+                      remote.id
+                    )} , ${JSON.stringify(
+                      modName
+                    )}).then(module=>__federation_method_wrapDefault(module, ${needWrap}))`
+                  );
+                  break;
+                }
+                case "ImportDeclaration": {
+                  if (node.specifiers?.length) {
+                    const afterImportName = `__federation_var_${moduleId.replace(
+                      /[@/\\.-]/g,
+                      ""
+                    )}`;
+                    if (!hasStaticImported.has(moduleId)) {
+                      magicString.overwrite(
+                        node.start,
+                        node.end,
+                        `const ${afterImportName} = await __federation_method_getRemote(${JSON.stringify(
+                          remote.id
+                        )} , ${JSON.stringify(modName)});`
+                      );
+                      hasStaticImported.set(moduleId, afterImportName);
+                    }
+                    let deconstructStr = "";
+                    node.specifiers.forEach((spec) => {
+                      if (spec.type === "ImportDefaultSpecifier") {
+                        magicString.appendRight(
+                          node.end,
+                          `
+ let ${spec.local.name} = __federation_method_unwrapDefault(${afterImportName}) `
+                        );
+                      } else if (spec.type === "ImportSpecifier") {
+                        const importedName = spec.imported.name;
+                        const localName = spec.local.name;
+                        deconstructStr += `${importedName === localName ? localName : `${importedName} : ${localName}`},`;
+                      } else if (spec.type === "ImportNamespaceSpecifier") {
+                        magicString.appendRight(
+                          node.end,
+                          `let {${spec.local.name}} = ${afterImportName}`
+                        );
+                      }
+                    });
+                    if (deconstructStr.length > 0) {
+                      magicString.appendRight(
+                        node.end,
+                        `
+ let {${deconstructStr.slice(
+                          0,
+                          -1
+                        )}} = ${afterImportName}`
+                      );
+                    }
+                  }
+                  break;
+                }
+                case "ExportNamedDeclaration": {
+                  const afterImportName = `__federation_var_${moduleId.replace(
+                    /[@/\\.-]/g,
+                    ""
+                  )}`;
+                  if (!hasStaticImported.has(moduleId)) {
+                    hasStaticImported.set(moduleId, afterImportName);
+                    magicString.overwrite(
+                      node.start,
+                      node.end,
+                      `const ${afterImportName} = await __federation_method_getRemote(${JSON.stringify(
+                        remote.id
+                      )} , ${JSON.stringify(modName)});`
+                    );
+                  }
+                  if (node.specifiers.length > 0) {
+                    const specifiers = node.specifiers;
+                    let exportContent = "";
+                    let deconstructContent = "";
+                    specifiers.forEach((spec) => {
+                      const localName = spec.local.name;
+                      const exportName = spec.exported.name;
+                      const variableName = `${afterImportName}_${localName}`;
+                      deconstructContent = deconstructContent.concat(
+                        `${localName}:${variableName},`
+                      );
+                      exportContent = exportContent.concat(
+                        `${variableName} as ${exportName},`
+                      );
+                    });
+                    magicString.append(
+                      `
+ const {${deconstructContent.slice(
+                        0,
+                        deconstructContent.length - 1
+                      )}} = ${afterImportName};
+`
+                    );
+                    magicString.append(
+                      `
+ export {${exportContent.slice(
+                        0,
+                        exportContent.length - 1
+                      )}}; `
+                    );
+                  }
+                  break;
+                }
+              }
+            }
+          }
+        }
+      });
+      if (requiresRuntime) {
+        let requiresCode = `import {__federation_method_ensure, __federation_method_getRemote , __federation_method_wrapDefault , __federation_method_unwrapDefault, __federation_method_add_origin_setRemote} from '__federation__';
+`;
+        if (manualRequired) {
+          requiresCode = `import {__federation_method_setRemote, __federation_method_ensure, __federation_method_getRemote , __federation_method_wrapDefault , __federation_method_unwrapDefault, __federation_method_add_origin_setRemote} from '__federation__';
+`;
+          magicString.overwrite(manualRequired.start, manualRequired.end, ``);
+        }
+        magicString.prepend(requiresCode);
+      }
+      return magicString.toString();
+    }
+  };
+  async function devSharedScopeCode(shared) {
+    const res = [];
+    if (shared.length) {
+      const serverConfiguration = viteDevServer.config.server;
+      const base = viteDevServer.config.base;
+      const cwdPath = normalizePath(process.cwd());
+      for (const item of shared) {
+        const moduleInfo = await this.resolve(item[1].packagePath, void 0, {
+          skipSelf: true
+        });
+        if (!moduleInfo) continue;
+        const moduleFilePath = normalizePath(moduleInfo.id);
+        const idx = moduleFilePath.indexOf(cwdPath);
+        const relativePath = idx === 0 ? posix.join(base, moduleFilePath.slice(cwdPath.length)) : null;
+        const sharedName = item[0];
+        const obj = item[1];
+        let str = "";
+        if (typeof obj === "object") {
+          const origin = serverConfiguration.origin;
+          const pathname = relativePath ?? `/@fs/${moduleInfo.id}`;
+          const url = origin ? `'${origin}${pathname}'` : `window.location.origin+'${pathname}'`;
+          str += `get:()=> get(${url}, ${REMOTE_FROM_PARAMETER})`;
+          res.push(`'${sharedName}':{'${obj.version}':{${str}}}`);
+        }
+      }
+    }
+    return res;
+  }
+}
+function devExposePlugin(options) {
+  parsedOptions.devExpose = parseExposeOptions(options);
+  return {
+    name: "originjs:expose-development"
+  };
+}
+function isVueAvailable() {
+  try {
+    return typeof ref !== "undefined" && typeof onMounted !== "undefined";
+  } catch {
+    return false;
+  }
+}
+let ref, onMounted, readonly;
+if (isVueAvailable()) {
+  try {
+    import("vue").then((vue) => {
+      ref = vue.ref;
+      onMounted = vue.onMounted;
+      readonly = vue.readonly;
+    }).catch(() => {
+      console.warn("Vue not available for dynamic import");
+    });
+  } catch {
+  }
+}
+const normalizeAssetsDir = (config) => {
+  const configured = config?.build?.assetsDir ?? "assets";
+  if (!configured) return "";
+  if (!isAbsolute(configured)) return configured;
+  const root = config?.root ? resolve(config.root) : process.cwd();
+  const resolvedOutDir = config?.build?.outDir ? isAbsolute(config.build.outDir) ? config.build.outDir : resolve(root, config.build.outDir) : resolve(root, "dist");
+  const normalized = relative(resolvedOutDir, configured).replace(/\\/g, "/");
+  return normalized.startsWith("..") ? "" : normalized || "assets";
+};
+function federation(options) {
+  options.filename = options.filename ? options.filename : DEFAULT_ENTRY_FILENAME;
+  let pluginList = [];
+  let virtualMod;
+  let registerCount = 0;
+  function registerPlugins(mode, command) {
+    if (mode === "production" || command === "build") {
+      pluginList = [
+        prodSharedPlugin(options),
+        prodExposePlugin(options),
+        prodRemotePlugin(options)
+      ];
+    } else if (mode === "development" || command === "serve") {
+      pluginList = [
+        devSharedPlugin(options),
+        devExposePlugin(options),
+        devRemotePlugin(options)
+      ];
+    } else {
+      pluginList = [];
+    }
+    builderInfo.isHost = options.isHost || !!(parsedOptions.prodRemote.length || parsedOptions.devRemote.length);
+    builderInfo.isRemote = !!(parsedOptions.prodExpose.length || parsedOptions.devExpose.length);
+    builderInfo.isShared = !!(parsedOptions.prodShared.length || parsedOptions.devShared.length);
+    let virtualFiles = {};
+    pluginList.forEach((plugin) => {
+      if (plugin.virtualFile) {
+        virtualFiles = Object.assign(virtualFiles, plugin.virtualFile);
+      }
+    });
+    virtualMod = virtual(virtualFiles);
+  }
+  return {
+    name: "originjs:federation",
+    // for scenario vite.config.js build.cssCodeSplit: false
+    // vite:css-post plugin will summarize all the styles in the style.xxxxxx.css file
+    // so, this plugin need run after vite:css-post in post plugin list
+    enforce: "post",
+    // apply:'build',
+    options(_options) {
+      if (!registerCount++) {
+        registerPlugins(options.mode = options.mode ?? "production", "");
+      }
+      if (typeof _options.input === "string") {
+        _options.input = { index: _options.input };
+      }
+      _options.external = _options.external || [];
+      if (!Array.isArray(_options.external)) {
+        _options.external = [_options.external];
+      }
+      for (const pluginHook of pluginList) {
+        pluginHook.options?.call(this, _options);
+      }
+      return _options;
+    },
+    config(config, env) {
+      options.mode = options.mode ?? env.mode;
+      registerPlugins(options.mode, env.command);
+      registerCount++;
+      for (const pluginHook of pluginList) {
+        pluginHook.config?.call(this, config, env);
+      }
+      builderInfo.builder = "vite";
+      builderInfo.assetsDir = normalizeAssetsDir(config) ?? "assets";
+    },
+    configureServer(server) {
+      for (const pluginHook of pluginList) {
+        pluginHook.configureServer?.call(this, server);
+      }
+    },
+    configResolved(config) {
+      for (const pluginHook of pluginList) {
+        pluginHook.configResolved?.call(this, config);
+      }
+    },
+    buildStart(inputOptions) {
+      for (const pluginHook of pluginList) {
+        pluginHook.buildStart?.call(this, inputOptions);
+      }
+    },
+    async resolveId(...args) {
+      const v = virtualMod.resolveId.call(this, ...args);
+      if (v) {
+        return v;
+      }
+      if (args[0] === "\0virtual:__federation_fn_import") {
+        return {
+          id: "\0virtual:__federation_fn_import",
+          moduleSideEffects: true
+        };
+      }
+      if (args[0] === "__federation_fn_satisfy") {
+        const federationId = (await this.resolve("@meethive/vite"))?.id;
+        if (federationId) {
+          return await this.resolve(`${dirname(federationId)}/satisfy.mjs`);
+        }
+        return null;
+      }
+      if (args[0] === "virtual:__federation__") {
+        return {
+          id: "\0virtual:__federation__",
+          moduleSideEffects: true
+        };
+      }
+      return null;
+    },
+    load(...args) {
+      const v = virtualMod.load.call(this, ...args);
+      if (v) {
+        return v;
+      }
+      return null;
+    },
+    transform(code, id) {
+      for (const pluginHook of pluginList) {
+        const result = pluginHook.transform?.call(this, code, id);
+        if (result) {
+          return result;
+        }
+      }
+      return code;
+    },
+    moduleParsed(moduleInfo) {
+      for (const pluginHook of pluginList) {
+        pluginHook.moduleParsed?.call(this, moduleInfo);
+      }
+    },
+    outputOptions(outputOptions) {
+      for (const pluginHook of pluginList) {
+        pluginHook.outputOptions?.call(this, outputOptions);
+      }
+      return outputOptions;
+    },
+    renderChunk(code, chunkInfo, _options) {
+      for (const pluginHook of pluginList) {
+        const result = pluginHook.renderChunk?.call(
+          this,
+          code,
+          chunkInfo,
+          _options
+        );
+        if (result) {
+          return result;
+        }
+      }
+      return null;
+    },
+    generateBundle: function(_options, bundle, isWrite) {
+      for (const pluginHook of pluginList) {
+        pluginHook.generateBundle?.call(this, _options, bundle, isWrite);
+      }
+    }
+  };
+}
+const languageWorkAttr = [
+  {
+    label: "editorWorkerService",
+    entry: "monaco-editor/esm/vs/editor/editor.worker"
+  },
+  {
+    label: "css",
+    entry: "monaco-editor/esm/vs/language/css/css.worker"
+  },
+  {
+    label: "html",
+    entry: "monaco-editor/esm/vs/language/html/html.worker"
+  },
+  {
+    label: "json",
+    entry: "monaco-editor/esm/vs/language/json/json.worker"
+  },
+  {
+    label: "typescript",
+    entry: "monaco-editor/esm/vs/language/typescript/ts.worker"
+  }
+];
+const languageWorksByLabel = {};
+languageWorkAttr.forEach(
+  (languageWork) => languageWorksByLabel[languageWork.label] = languageWork
+);
+function getFilenameByEntry(entry) {
+  entry = basename(entry, "js");
+  return entry + ".bundle.js";
+}
+const cacheDir = "node_modules/.monaco/";
+function getWorkPath(works, options, config) {
+  const workerPaths = {};
+  for (const work of works) {
+    if (isCDN(options.publicPath)) {
+      workerPaths[work.label] = options.publicPath + "/" + getFilenameByEntry(work.entry);
+    } else {
+      workerPaths[work.label] = config.base + options.publicPath + "/" + getFilenameByEntry(work.entry);
+    }
+  }
+  if (workerPaths["typescript"]) {
+    workerPaths["javascript"] = workerPaths["typescript"];
+  }
+  if (workerPaths["css"]) {
+    workerPaths["less"] = workerPaths["css"];
+    workerPaths["scss"] = workerPaths["css"];
+  }
+  if (workerPaths["html"]) {
+    workerPaths["handlebars"] = workerPaths["html"];
+    workerPaths["razor"] = workerPaths["html"];
+  }
+  return workerPaths;
+}
+function workerMiddleware(middlewares, config, options) {
+  const works = getWorks(options);
+  if (existsSync(cacheDir)) {
+    rmSync(cacheDir, { recursive: true, force: true });
+  }
+  for (const work of works) {
+    middlewares.use(
+      config.base + options.publicPath + "/" + getFilenameByEntry(work.entry),
+      function(req, res, next) {
+        if (!existsSync(cacheDir + getFilenameByEntry(work.entry))) {
+          buildSync({
+            entryPoints: [resolveMonacoPath(work.entry)],
+            bundle: true,
+            outfile: cacheDir + getFilenameByEntry(work.entry)
+          });
+        }
+        const contentBuffer = readFileSync(cacheDir + getFilenameByEntry(work.entry));
+        res.setHeader("Content-Type", "text/javascript");
+        res.end(contentBuffer);
+      }
+    );
+  }
+}
+function resolveMonacoPath(filePath) {
+  try {
+    return resolve(join(process.cwd(), "node_modules", filePath));
+  } catch (err) {
+    return resolve(filePath);
+  }
+}
+function getWorks(options) {
+  let works = options.languageWorkers.map(
+    (work) => languageWorksByLabel[work]
+  );
+  works.push(...options.customWorkers);
+  return works;
+}
+const getFS = async () => {
+  if (typeof process !== "undefined" && process.versions?.node) {
+    const fs = await import("fs");
+    return {
+      existsSync: fs.existsSync,
+      mkdirSync: fs.mkdirSync,
+      readFileSync: fs.readFileSync,
+      writeFileSync: fs.writeFileSync
+    };
+  }
+  return null;
+};
+function monacoEditorPlugin(options) {
+  const languageWorkers = options.languageWorkers || Object.keys(languageWorksByLabel);
+  const publicPath = options.publicPath || "monacoeditorwork";
+  const globalAPI = options.globalAPI || false;
+  const customWorkers = options.customWorkers || [];
+  const forceBuildCDN = options.forceBuildCDN || false;
+  options = {
+    ...options,
+    languageWorkers,
+    publicPath,
+    globalAPI,
+    customWorkers,
+    forceBuildCDN
+  };
+  let resolvedConfig;
+  return {
+    name: "vite-plugin-monaco-editor",
+    configResolved(getResolvedConfig) {
+      resolvedConfig = getResolvedConfig;
+    },
+    configureServer(server) {
+      if (isCDN(publicPath)) {
+        return;
+      }
+      workerMiddleware(server.middlewares, resolvedConfig, options);
+    },
+    transformIndexHtml(html) {
+      const works = getWorks(options);
+      const workerPaths = getWorkPath(works, options, resolvedConfig);
+      const globals = {
+        MonacoEnvironment: `(function (paths) {
+          return {
+            globalAPI: ${globalAPI},
+            getWorkerUrl : function (moduleId, label) {
+              var result =  paths[label];
+              var _location = window.__MICRO_APP_ENVIRONMENT__ ? window.rawWindow.location : window.location;
+              var currentUrl = String(_location);
+              var currentOrigin = currentUrl.substr(0, currentUrl.length - _location.hash.length - _location.search.length - _location.pathname.length);
+              if (window.__MICRO_APP_ENVIRONMENT__) {
+                result =  currentOrigin + result.replace('./', '/')
+              }
+              if (/^((http:)|(https:)|(file:)|(\\/\\/))/.test(result)) {
+                if (result.substring(0, currentOrigin.length) !== currentOrigin) {
+                  var js = '/*' + label + '*/importScripts("' + result + '");';
+                  var blob = new Blob([js], { type: 'application/javascript' });
+                  return URL.createObjectURL(blob);
+                }
+              }
+              console.log('result',result);
+              return result;
+            }
+          };
+        })(${JSON.stringify(workerPaths, null, 2)})`
+      };
+      const descriptor = [
+        {
+          tag: "script",
+          children: Object.keys(globals).map((key) => `self[${JSON.stringify(key)}] = ${globals[key]};`).join("\n"),
+          injectTo: "head-prepend"
+        }
+      ];
+      return descriptor;
+    },
+    async writeBundle() {
+      if (isCDN(publicPath) && !forceBuildCDN) {
+        return;
+      }
+      const fs = await getFS();
+      if (!fs) {
+        this.warn("File system operations not available in this environment");
+        return;
+      }
+      const works = getWorks(options);
+      const distPath = options.customDistPath ? options.customDistPath(
+        resolvedConfig.root,
+        resolvedConfig.build.outDir,
+        resolvedConfig.base
+      ) : join(
+        resolvedConfig.root,
+        resolvedConfig.build.outDir,
+        resolvedConfig.base,
+        options.publicPath
+      );
+      if (!fs.existsSync(distPath)) {
+        fs.mkdirSync(distPath, {
+          recursive: true
+        });
+      }
+      for (const work of works) {
+        if (!fs.existsSync(cacheDir + getFilenameByEntry(work.entry))) {
+          buildSync({
+            entryPoints: [resolveMonacoPath(work.entry)],
+            bundle: true,
+            outfile: cacheDir + getFilenameByEntry(work.entry)
+          });
+        }
+        const contentBuffer = fs.readFileSync(cacheDir + getFilenameByEntry(work.entry));
+        const workDistPath = resolve(distPath, getFilenameByEntry(work.entry));
+        fs.writeFileSync(workDistPath, contentBuffer);
+      }
+    }
+  };
+}
+function isCDN(publicPath) {
+  if (/^((http:)|(https:)|(file:)|(\/\/))/.test(publicPath)) {
+    return true;
+  }
+  return false;
+}
+function matches(filename, patterns) {
+  if (!patterns || patterns.length === 0) return true;
+  return patterns.some(
+    (p) => typeof p === "string" ? filename.includes(p) : p.test(filename)
+  );
+}
+function sharpOptimize(options = {}) {
+  const {
+    include,
+    exclude,
+    jpegQuality = 75,
+    pngQuality = 75,
+    webpQuality = 75,
+    avifQuality = 50
+  } = options;
+  let _sharp = null;
+  const getSharp = async () => {
+    if (!_sharp) {
+      const sharpModule = await import("sharp");
+      _sharp = sharpModule.default ?? sharpModule;
+    }
+    return _sharp;
+  };
+  const imageExts = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".avif"]);
+  return {
+    name: "jetlinks-sharp-optimize",
+    apply: "build",
+    enforce: "post",
+    async generateBundle(_opts, bundle) {
+      for (const [fileName, asset] of Object.entries(bundle)) {
+        if (asset.type !== "asset") continue;
+        const ext = path$1.extname(fileName).toLowerCase();
+        if (!imageExts.has(ext)) continue;
+        if (exclude && matches(fileName, exclude)) continue;
+        if (include && !matches(fileName, include)) continue;
+        try {
+          const sourceBuffer = Buffer.isBuffer(asset.source) ? asset.source : Buffer.from(String(asset.source));
+          const sharp = await getSharp();
+          let instance = sharp(sourceBuffer);
+          switch (ext) {
+            case ".jpg":
+            case ".jpeg":
+              instance = instance.jpeg({ quality: jpegQuality, mozjpeg: true });
+              break;
+            case ".png":
+              instance = instance.png({ quality: pngQuality, compressionLevel: 9 });
+              break;
+            case ".webp":
+              instance = instance.webp({ quality: webpQuality });
+              break;
+            case ".avif":
+              instance = instance.avif({ quality: avifQuality });
+              break;
+            default:
+              break;
+          }
+          const optimized = await instance.toBuffer();
+          asset.source = optimized;
+        } catch (err) {
+          this.warn(`sharp optimize failed for ${fileName}: ${String(err)}`);
+        }
+      }
+    }
+  };
+}
+export {
+  federation,
+  monacoEditorPlugin,
+  sharpOptimize
+};