@meethive/vite 0.0.3 → 0.0.4

package/dist/index.mjs

@@ -1,26 +1,1250 @@
-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 "./dynamic-remote.mjs";
-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 = {
+// node_modules/.pnpm/@rollup+plugin-virtual@3.0.2_rollup@4.48.1/node_modules/@rollup/plugin-virtual/dist/es/index.js
+import * as path from "path";
+var PREFIX = `\0virtual:`;
+function virtual(modules) {
+  const resolvedIds = /* @__PURE__ */ new Map();
+  Object.keys(modules).forEach((id) => {
+    resolvedIds.set(path.resolve(id), modules[id]);
+  });
+  return {
+    name: "virtual",
+    resolveId(id, importer) {
+      if (id in modules)
+        return PREFIX + id;
+      if (importer) {
+        const importerNoPrefix = importer.startsWith(PREFIX) ? importer.slice(PREFIX.length) : importer;
+        const resolved = path.resolve(path.dirname(importerNoPrefix), id);
+        if (resolvedIds.has(resolved))
+          return PREFIX + resolved;
+      }
+      return null;
+    },
+    load(id) {
+      if (id.startsWith(PREFIX)) {
+        const idNoPrefix = id.slice(PREFIX.length);
+        return idNoPrefix in modules ? modules[idNoPrefix] : resolvedIds.get(idNoPrefix);
+      }
+      return null;
+    }
+  };
+}
+
+// src/federation/src/index.ts
+import { dirname as dirname3, isAbsolute, relative as relative2, resolve as resolve4 } from "path";
+
+// node_modules/.pnpm/estree-walker@3.0.2/node_modules/estree-walker/src/walker.js
+var WalkerBase = class {
+  constructor() {
+    this.should_skip = false;
+    this.should_remove = false;
+    this.replacement = null;
+    this.context = {
+      skip: () => this.should_skip = true,
+      remove: () => this.should_remove = true,
+      replace: (node) => this.replacement = node
+    };
+  }
+  /**
+   *
+   * @param {any} parent
+   * @param {string} prop
+   * @param {number} index
+   * @param {BaseNode} node
+   */
+  replace(parent, prop, index, node) {
+    if (parent) {
+      if (index !== null) {
+        parent[prop][index] = node;
+      } else {
+        parent[prop] = node;
+      }
+    }
+  }
+  /**
+   *
+   * @param {any} parent
+   * @param {string} prop
+   * @param {number} index
+   */
+  remove(parent, prop, index) {
+    if (parent) {
+      if (index !== null) {
+        parent[prop].splice(index, 1);
+      } else {
+        delete parent[prop];
+      }
+    }
+  }
+};
+
+// node_modules/.pnpm/estree-walker@3.0.2/node_modules/estree-walker/src/sync.js
+var SyncWalker = class extends WalkerBase {
+  /**
+   *
+   * @param {SyncHandler} enter
+   * @param {SyncHandler} leave
+   */
+  constructor(enter, leave) {
+    super();
+    this.enter = enter;
+    this.leave = leave;
+  }
+  /**
+   *
+   * @param {BaseNode} node
+   * @param {BaseNode} parent
+   * @param {string} [prop]
+   * @param {number} [index]
+   * @returns {BaseNode}
+   */
+  visit(node, parent, prop, index) {
+    if (node) {
+      if (this.enter) {
+        const _should_skip = this.should_skip;
+        const _should_remove = this.should_remove;
+        const _replacement = this.replacement;
+        this.should_skip = false;
+        this.should_remove = false;
+        this.replacement = null;
+        this.enter.call(this.context, node, parent, prop, index);
+        if (this.replacement) {
+          node = this.replacement;
+          this.replace(parent, prop, index, node);
+        }
+        if (this.should_remove) {
+          this.remove(parent, prop, index);
+        }
+        const skipped = this.should_skip;
+        const removed = this.should_remove;
+        this.should_skip = _should_skip;
+        this.should_remove = _should_remove;
+        this.replacement = _replacement;
+        if (skipped) return node;
+        if (removed) return null;
+      }
+      for (const key in node) {
+        const value = node[key];
+        if (typeof value !== "object") {
+          continue;
+        } else if (Array.isArray(value)) {
+          for (let i = 0; i < value.length; i += 1) {
+            if (value[i] !== null && typeof value[i].type === "string") {
+              if (!this.visit(value[i], node, key, i)) {
+                i--;
+              }
+            }
+          }
+        } else if (value !== null && typeof value.type === "string") {
+          this.visit(value, node, key, null);
+        }
+      }
+      if (this.leave) {
+        const _replacement = this.replacement;
+        const _should_remove = this.should_remove;
+        this.replacement = null;
+        this.should_remove = false;
+        this.leave.call(this.context, node, parent, prop, index);
+        if (this.replacement) {
+          node = this.replacement;
+          this.replace(parent, prop, index, node);
+        }
+        if (this.should_remove) {
+          this.remove(parent, prop, index);
+        }
+        const removed = this.should_remove;
+        this.replacement = _replacement;
+        this.should_remove = _should_remove;
+        if (removed) return null;
+      }
+    }
+    return node;
+  }
+};
+
+// node_modules/.pnpm/estree-walker@3.0.2/node_modules/estree-walker/src/index.js
+function walk(ast, { enter, leave }) {
+  const instance = new SyncWalker(enter, leave);
+  return instance.visit(ast, null);
+}
+
+// node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+function encodeInteger(builder, num, relative3) {
+  let delta = num - relative3;
+  delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+  do {
+    let clamped = delta & 31;
+    delta >>>= 5;
+    if (delta > 0) clamped |= 32;
+    builder.write(intToChar[clamped]);
+  } while (delta > 0);
+  return num;
+}
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
+  decode(buf) {
+    const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+    return out.toString();
+  }
+} : {
+  decode(buf) {
+    let out = "";
+    for (let i = 0; i < buf.length; i++) {
+      out += String.fromCharCode(buf[i]);
+    }
+    return out;
+  }
+};
+var StringWriter = class {
+  constructor() {
+    this.pos = 0;
+    this.out = "";
+    this.buffer = new Uint8Array(bufLength);
+  }
+  write(v) {
+    const { buffer } = this;
+    buffer[this.pos++] = v;
+    if (this.pos === bufLength) {
+      this.out += td.decode(buffer);
+      this.pos = 0;
+    }
+  }
+  flush() {
+    const { buffer, out, pos } = this;
+    return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+  }
+};
+function encode(decoded) {
+  const writer = new StringWriter();
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  for (let i = 0; i < decoded.length; i++) {
+    const line = decoded[i];
+    if (i > 0) writer.write(semicolon);
+    if (line.length === 0) continue;
+    let genColumn = 0;
+    for (let j = 0; j < line.length; j++) {
+      const segment = line[j];
+      if (j > 0) writer.write(comma);
+      genColumn = encodeInteger(writer, segment[0], genColumn);
+      if (segment.length === 1) continue;
+      sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+      sourceLine = encodeInteger(writer, segment[2], sourceLine);
+      sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+      if (segment.length === 4) continue;
+      namesIndex = encodeInteger(writer, segment[4], namesIndex);
+    }
+  }
+  return writer.flush();
+}
+
+// node_modules/.pnpm/magic-string@0.30.17/node_modules/magic-string/dist/magic-string.es.mjs
+var BitSet = class _BitSet {
+  constructor(arg) {
+    this.bits = arg instanceof _BitSet ? arg.bits.slice() : [];
+  }
+  add(n2) {
+    this.bits[n2 >> 5] |= 1 << (n2 & 31);
+  }
+  has(n2) {
+    return !!(this.bits[n2 >> 5] & 1 << (n2 & 31));
+  }
+};
+var Chunk = class _Chunk {
+  constructor(start, end, content) {
+    this.start = start;
+    this.end = end;
+    this.original = content;
+    this.intro = "";
+    this.outro = "";
+    this.content = content;
+    this.storeName = false;
+    this.edited = false;
+    {
+      this.previous = null;
+      this.next = null;
+    }
+  }
+  appendLeft(content) {
+    this.outro += content;
+  }
+  appendRight(content) {
+    this.intro = this.intro + content;
+  }
+  clone() {
+    const chunk = new _Chunk(this.start, this.end, this.original);
+    chunk.intro = this.intro;
+    chunk.outro = this.outro;
+    chunk.content = this.content;
+    chunk.storeName = this.storeName;
+    chunk.edited = this.edited;
+    return chunk;
+  }
+  contains(index) {
+    return this.start < index && index < this.end;
+  }
+  eachNext(fn) {
+    let chunk = this;
+    while (chunk) {
+      fn(chunk);
+      chunk = chunk.next;
+    }
+  }
+  eachPrevious(fn) {
+    let chunk = this;
+    while (chunk) {
+      fn(chunk);
+      chunk = chunk.previous;
+    }
+  }
+  edit(content, storeName, contentOnly) {
+    this.content = content;
+    if (!contentOnly) {
+      this.intro = "";
+      this.outro = "";
+    }
+    this.storeName = storeName;
+    this.edited = true;
+    return this;
+  }
+  prependLeft(content) {
+    this.outro = content + this.outro;
+  }
+  prependRight(content) {
+    this.intro = content + this.intro;
+  }
+  reset() {
+    this.intro = "";
+    this.outro = "";
+    if (this.edited) {
+      this.content = this.original;
+      this.storeName = false;
+      this.edited = false;
+    }
+  }
+  split(index) {
+    const sliceIndex = index - this.start;
+    const originalBefore = this.original.slice(0, sliceIndex);
+    const originalAfter = this.original.slice(sliceIndex);
+    this.original = originalBefore;
+    const newChunk = new _Chunk(index, this.end, originalAfter);
+    newChunk.outro = this.outro;
+    this.outro = "";
+    this.end = index;
+    if (this.edited) {
+      newChunk.edit("", false);
+      this.content = "";
+    } else {
+      this.content = originalBefore;
+    }
+    newChunk.next = this.next;
+    if (newChunk.next) newChunk.next.previous = newChunk;
+    newChunk.previous = this;
+    this.next = newChunk;
+    return newChunk;
+  }
+  toString() {
+    return this.intro + this.content + this.outro;
+  }
+  trimEnd(rx) {
+    this.outro = this.outro.replace(rx, "");
+    if (this.outro.length) return true;
+    const trimmed = this.content.replace(rx, "");
+    if (trimmed.length) {
+      if (trimmed !== this.content) {
+        this.split(this.start + trimmed.length).edit("", void 0, true);
+        if (this.edited) {
+          this.edit(trimmed, this.storeName, true);
+        }
+      }
+      return true;
+    } else {
+      this.edit("", void 0, true);
+      this.intro = this.intro.replace(rx, "");
+      if (this.intro.length) return true;
+    }
+  }
+  trimStart(rx) {
+    this.intro = this.intro.replace(rx, "");
+    if (this.intro.length) return true;
+    const trimmed = this.content.replace(rx, "");
+    if (trimmed.length) {
+      if (trimmed !== this.content) {
+        const newChunk = this.split(this.end - trimmed.length);
+        if (this.edited) {
+          newChunk.edit(trimmed, this.storeName, true);
+        }
+        this.edit("", void 0, true);
+      }
+      return true;
+    } else {
+      this.edit("", void 0, true);
+      this.outro = this.outro.replace(rx, "");
+      if (this.outro.length) return true;
+    }
+  }
+};
+function getBtoa() {
+  if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") {
+    return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+  } else if (typeof Buffer === "function") {
+    return (str) => Buffer.from(str, "utf-8").toString("base64");
+  } else {
+    return () => {
+      throw new Error("Unsupported environment: `window.btoa` or `Buffer` should be supported.");
+    };
+  }
+}
+var btoa = /* @__PURE__ */ getBtoa();
+var SourceMap = class {
+  constructor(properties) {
+    this.version = 3;
+    this.file = properties.file;
+    this.sources = properties.sources;
+    this.sourcesContent = properties.sourcesContent;
+    this.names = properties.names;
+    this.mappings = encode(properties.mappings);
+    if (typeof properties.x_google_ignoreList !== "undefined") {
+      this.x_google_ignoreList = properties.x_google_ignoreList;
+    }
+    if (typeof properties.debugId !== "undefined") {
+      this.debugId = properties.debugId;
+    }
+  }
+  toString() {
+    return JSON.stringify(this);
+  }
+  toUrl() {
+    return "data:application/json;charset=utf-8;base64," + btoa(this.toString());
+  }
+};
+function guessIndent(code) {
+  const lines = code.split("\n");
+  const tabbed = lines.filter((line) => /^\t+/.test(line));
+  const spaced = lines.filter((line) => /^ {2,}/.test(line));
+  if (tabbed.length === 0 && spaced.length === 0) {
+    return null;
+  }
+  if (tabbed.length >= spaced.length) {
+    return "	";
+  }
+  const min = spaced.reduce((previous, current) => {
+    const numSpaces = /^ +/.exec(current)[0].length;
+    return Math.min(numSpaces, previous);
+  }, Infinity);
+  return new Array(min + 1).join(" ");
+}
+function getRelativePath(from, to) {
+  const fromParts = from.split(/[/\\]/);
+  const toParts = to.split(/[/\\]/);
+  fromParts.pop();
+  while (fromParts[0] === toParts[0]) {
+    fromParts.shift();
+    toParts.shift();
+  }
+  if (fromParts.length) {
+    let i = fromParts.length;
+    while (i--) fromParts[i] = "..";
+  }
+  return fromParts.concat(toParts).join("/");
+}
+var toString = Object.prototype.toString;
+function isObject(thing) {
+  return toString.call(thing) === "[object Object]";
+}
+function getLocator(source) {
+  const originalLines = source.split("\n");
+  const lineOffsets = [];
+  for (let i = 0, pos = 0; i < originalLines.length; i++) {
+    lineOffsets.push(pos);
+    pos += originalLines[i].length + 1;
+  }
+  return function locate(index) {
+    let i = 0;
+    let j = lineOffsets.length;
+    while (i < j) {
+      const m = i + j >> 1;
+      if (index < lineOffsets[m]) {
+        j = m;
+      } else {
+        i = m + 1;
+      }
+    }
+    const line = i - 1;
+    const column = index - lineOffsets[line];
+    return { line, column };
+  };
+}
+var wordRegex = /\w/;
+var Mappings = class {
+  constructor(hires) {
+    this.hires = hires;
+    this.generatedCodeLine = 0;
+    this.generatedCodeColumn = 0;
+    this.raw = [];
+    this.rawSegments = this.raw[this.generatedCodeLine] = [];
+    this.pending = null;
+  }
+  addEdit(sourceIndex, content, loc, nameIndex) {
+    if (content.length) {
+      const contentLengthMinusOne = content.length - 1;
+      let contentLineEnd = content.indexOf("\n", 0);
+      let previousContentLineEnd = -1;
+      while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+        const segment2 = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+        if (nameIndex >= 0) {
+          segment2.push(nameIndex);
+        }
+        this.rawSegments.push(segment2);
+        this.generatedCodeLine += 1;
+        this.raw[this.generatedCodeLine] = this.rawSegments = [];
+        this.generatedCodeColumn = 0;
+        previousContentLineEnd = contentLineEnd;
+        contentLineEnd = content.indexOf("\n", contentLineEnd + 1);
+      }
+      const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+      if (nameIndex >= 0) {
+        segment.push(nameIndex);
+      }
+      this.rawSegments.push(segment);
+      this.advance(content.slice(previousContentLineEnd + 1));
+    } else if (this.pending) {
+      this.rawSegments.push(this.pending);
+      this.advance(content);
+    }
+    this.pending = null;
+  }
+  addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+    let originalCharIndex = chunk.start;
+    let first = true;
+    let charInHiresBoundary = false;
+    while (originalCharIndex < chunk.end) {
+      if (original[originalCharIndex] === "\n") {
+        loc.line += 1;
+        loc.column = 0;
+        this.generatedCodeLine += 1;
+        this.raw[this.generatedCodeLine] = this.rawSegments = [];
+        this.generatedCodeColumn = 0;
+        first = true;
+        charInHiresBoundary = false;
+      } else {
+        if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+          const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+          if (this.hires === "boundary") {
+            if (wordRegex.test(original[originalCharIndex])) {
+              if (!charInHiresBoundary) {
+                this.rawSegments.push(segment);
+                charInHiresBoundary = true;
+              }
+            } else {
+              this.rawSegments.push(segment);
+              charInHiresBoundary = false;
+            }
+          } else {
+            this.rawSegments.push(segment);
+          }
+        }
+        loc.column += 1;
+        this.generatedCodeColumn += 1;
+        first = false;
+      }
+      originalCharIndex += 1;
+    }
+    this.pending = null;
+  }
+  advance(str) {
+    if (!str) return;
+    const lines = str.split("\n");
+    if (lines.length > 1) {
+      for (let i = 0; i < lines.length - 1; i++) {
+        this.generatedCodeLine++;
+        this.raw[this.generatedCodeLine] = this.rawSegments = [];
+      }
+      this.generatedCodeColumn = 0;
+    }
+    this.generatedCodeColumn += lines[lines.length - 1].length;
+  }
+};
+var n = "\n";
+var warned = {
+  insertLeft: false,
+  insertRight: false,
+  storeName: false
+};
+var MagicString = class _MagicString {
+  constructor(string, options = {}) {
+    const chunk = new Chunk(0, string.length, string);
+    Object.defineProperties(this, {
+      original: { writable: true, value: string },
+      outro: { writable: true, value: "" },
+      intro: { writable: true, value: "" },
+      firstChunk: { writable: true, value: chunk },
+      lastChunk: { writable: true, value: chunk },
+      lastSearchedChunk: { writable: true, value: chunk },
+      byStart: { writable: true, value: {} },
+      byEnd: { writable: true, value: {} },
+      filename: { writable: true, value: options.filename },
+      indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
+      sourcemapLocations: { writable: true, value: new BitSet() },
+      storedNames: { writable: true, value: {} },
+      indentStr: { writable: true, value: void 0 },
+      ignoreList: { writable: true, value: options.ignoreList },
+      offset: { writable: true, value: options.offset || 0 }
+    });
+    this.byStart[0] = chunk;
+    this.byEnd[string.length] = chunk;
+  }
+  addSourcemapLocation(char) {
+    this.sourcemapLocations.add(char);
+  }
+  append(content) {
+    if (typeof content !== "string") throw new TypeError("outro content must be a string");
+    this.outro += content;
+    return this;
+  }
+  appendLeft(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byEnd[index];
+    if (chunk) {
+      chunk.appendLeft(content);
+    } else {
+      this.intro += content;
+    }
+    return this;
+  }
+  appendRight(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byStart[index];
+    if (chunk) {
+      chunk.appendRight(content);
+    } else {
+      this.outro += content;
+    }
+    return this;
+  }
+  clone() {
+    const cloned = new _MagicString(this.original, { filename: this.filename, offset: this.offset });
+    let originalChunk = this.firstChunk;
+    let clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
+    while (originalChunk) {
+      cloned.byStart[clonedChunk.start] = clonedChunk;
+      cloned.byEnd[clonedChunk.end] = clonedChunk;
+      const nextOriginalChunk = originalChunk.next;
+      const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+      if (nextClonedChunk) {
+        clonedChunk.next = nextClonedChunk;
+        nextClonedChunk.previous = clonedChunk;
+        clonedChunk = nextClonedChunk;
+      }
+      originalChunk = nextOriginalChunk;
+    }
+    cloned.lastChunk = clonedChunk;
+    if (this.indentExclusionRanges) {
+      cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+    }
+    cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+    cloned.intro = this.intro;
+    cloned.outro = this.outro;
+    return cloned;
+  }
+  generateDecodedMap(options) {
+    options = options || {};
+    const sourceIndex = 0;
+    const names = Object.keys(this.storedNames);
+    const mappings = new Mappings(options.hires);
+    const locate = getLocator(this.original);
+    if (this.intro) {
+      mappings.advance(this.intro);
+    }
+    this.firstChunk.eachNext((chunk) => {
+      const loc = locate(chunk.start);
+      if (chunk.intro.length) mappings.advance(chunk.intro);
+      if (chunk.edited) {
+        mappings.addEdit(
+          sourceIndex,
+          chunk.content,
+          loc,
+          chunk.storeName ? names.indexOf(chunk.original) : -1
+        );
+      } else {
+        mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+      }
+      if (chunk.outro.length) mappings.advance(chunk.outro);
+    });
+    return {
+      file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
+      sources: [
+        options.source ? getRelativePath(options.file || "", options.source) : options.file || ""
+      ],
+      sourcesContent: options.includeContent ? [this.original] : void 0,
+      names,
+      mappings: mappings.raw,
+      x_google_ignoreList: this.ignoreList ? [sourceIndex] : void 0
+    };
+  }
+  generateMap(options) {
+    return new SourceMap(this.generateDecodedMap(options));
+  }
+  _ensureindentStr() {
+    if (this.indentStr === void 0) {
+      this.indentStr = guessIndent(this.original);
+    }
+  }
+  _getRawIndentString() {
+    this._ensureindentStr();
+    return this.indentStr;
+  }
+  getIndentString() {
+    this._ensureindentStr();
+    return this.indentStr === null ? "	" : this.indentStr;
+  }
+  indent(indentStr, options) {
+    const pattern = /^[^\r\n]/gm;
+    if (isObject(indentStr)) {
+      options = indentStr;
+      indentStr = void 0;
+    }
+    if (indentStr === void 0) {
+      this._ensureindentStr();
+      indentStr = this.indentStr || "	";
+    }
+    if (indentStr === "") return this;
+    options = options || {};
+    const isExcluded = {};
+    if (options.exclude) {
+      const exclusions = typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude;
+      exclusions.forEach((exclusion) => {
+        for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
+          isExcluded[i] = true;
+        }
+      });
+    }
+    let shouldIndentNextCharacter = options.indentStart !== false;
+    const replacer = (match) => {
+      if (shouldIndentNextCharacter) return `${indentStr}${match}`;
+      shouldIndentNextCharacter = true;
+      return match;
+    };
+    this.intro = this.intro.replace(pattern, replacer);
+    let charIndex = 0;
+    let chunk = this.firstChunk;
+    while (chunk) {
+      const end = chunk.end;
+      if (chunk.edited) {
+        if (!isExcluded[charIndex]) {
+          chunk.content = chunk.content.replace(pattern, replacer);
+          if (chunk.content.length) {
+            shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === "\n";
+          }
+        }
+      } else {
+        charIndex = chunk.start;
+        while (charIndex < end) {
+          if (!isExcluded[charIndex]) {
+            const char = this.original[charIndex];
+            if (char === "\n") {
+              shouldIndentNextCharacter = true;
+            } else if (char !== "\r" && shouldIndentNextCharacter) {
+              shouldIndentNextCharacter = false;
+              if (charIndex === chunk.start) {
+                chunk.prependRight(indentStr);
+              } else {
+                this._splitChunk(chunk, charIndex);
+                chunk = chunk.next;
+                chunk.prependRight(indentStr);
+              }
+            }
+          }
+          charIndex += 1;
+        }
+      }
+      charIndex = chunk.end;
+      chunk = chunk.next;
+    }
+    this.outro = this.outro.replace(pattern, replacer);
+    return this;
+  }
+  insert() {
+    throw new Error(
+      "magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)"
+    );
+  }
+  insertLeft(index, content) {
+    if (!warned.insertLeft) {
+      console.warn(
+        "magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead"
+      );
+      warned.insertLeft = true;
+    }
+    return this.appendLeft(index, content);
+  }
+  insertRight(index, content) {
+    if (!warned.insertRight) {
+      console.warn(
+        "magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead"
+      );
+      warned.insertRight = true;
+    }
+    return this.prependRight(index, content);
+  }
+  move(start, end, index) {
+    start = start + this.offset;
+    end = end + this.offset;
+    index = index + this.offset;
+    if (index >= start && index <= end) throw new Error("Cannot move a selection inside itself");
+    this._split(start);
+    this._split(end);
+    this._split(index);
+    const first = this.byStart[start];
+    const last = this.byEnd[end];
+    const oldLeft = first.previous;
+    const oldRight = last.next;
+    const newRight = this.byStart[index];
+    if (!newRight && last === this.lastChunk) return this;
+    const newLeft = newRight ? newRight.previous : this.lastChunk;
+    if (oldLeft) oldLeft.next = oldRight;
+    if (oldRight) oldRight.previous = oldLeft;
+    if (newLeft) newLeft.next = first;
+    if (newRight) newRight.previous = last;
+    if (!first.previous) this.firstChunk = last.next;
+    if (!last.next) {
+      this.lastChunk = first.previous;
+      this.lastChunk.next = null;
+    }
+    first.previous = newLeft;
+    last.next = newRight || null;
+    if (!newLeft) this.firstChunk = first;
+    if (!newRight) this.lastChunk = last;
+    return this;
+  }
+  overwrite(start, end, content, options) {
+    options = options || {};
+    return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
+  }
+  update(start, end, content, options) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (typeof content !== "string") throw new TypeError("replacement content must be a string");
+    if (this.original.length !== 0) {
+      while (start < 0) start += this.original.length;
+      while (end < 0) end += this.original.length;
+    }
+    if (end > this.original.length) throw new Error("end is out of bounds");
+    if (start === end)
+      throw new Error(
+        "Cannot overwrite a zero-length range \u2013 use appendLeft or prependRight instead"
+      );
+    this._split(start);
+    this._split(end);
+    if (options === true) {
+      if (!warned.storeName) {
+        console.warn(
+          "The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string"
+        );
+        warned.storeName = true;
+      }
+      options = { storeName: true };
+    }
+    const storeName = options !== void 0 ? options.storeName : false;
+    const overwrite = options !== void 0 ? options.overwrite : false;
+    if (storeName) {
+      const original = this.original.slice(start, end);
+      Object.defineProperty(this.storedNames, original, {
+        writable: true,
+        value: true,
+        enumerable: true
+      });
+    }
+    const first = this.byStart[start];
+    const last = this.byEnd[end];
+    if (first) {
+      let chunk = first;
+      while (chunk !== last) {
+        if (chunk.next !== this.byStart[chunk.end]) {
+          throw new Error("Cannot overwrite across a split point");
+        }
+        chunk = chunk.next;
+        chunk.edit("", false);
+      }
+      first.edit(content, storeName, !overwrite);
+    } else {
+      const newChunk = new Chunk(start, end, "").edit(content, storeName);
+      last.next = newChunk;
+      newChunk.previous = last;
+    }
+    return this;
+  }
+  prepend(content) {
+    if (typeof content !== "string") throw new TypeError("outro content must be a string");
+    this.intro = content + this.intro;
+    return this;
+  }
+  prependLeft(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byEnd[index];
+    if (chunk) {
+      chunk.prependLeft(content);
+    } else {
+      this.intro = content + this.intro;
+    }
+    return this;
+  }
+  prependRight(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byStart[index];
+    if (chunk) {
+      chunk.prependRight(content);
+    } else {
+      this.outro = content + this.outro;
+    }
+    return this;
+  }
+  remove(start, end) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (this.original.length !== 0) {
+      while (start < 0) start += this.original.length;
+      while (end < 0) end += this.original.length;
+    }
+    if (start === end) return this;
+    if (start < 0 || end > this.original.length) throw new Error("Character is out of bounds");
+    if (start > end) throw new Error("end must be greater than start");
+    this._split(start);
+    this._split(end);
+    let chunk = this.byStart[start];
+    while (chunk) {
+      chunk.intro = "";
+      chunk.outro = "";
+      chunk.edit("");
+      chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+    }
+    return this;
+  }
+  reset(start, end) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (this.original.length !== 0) {
+      while (start < 0) start += this.original.length;
+      while (end < 0) end += this.original.length;
+    }
+    if (start === end) return this;
+    if (start < 0 || end > this.original.length) throw new Error("Character is out of bounds");
+    if (start > end) throw new Error("end must be greater than start");
+    this._split(start);
+    this._split(end);
+    let chunk = this.byStart[start];
+    while (chunk) {
+      chunk.reset();
+      chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+    }
+    return this;
+  }
+  lastChar() {
+    if (this.outro.length) return this.outro[this.outro.length - 1];
+    let chunk = this.lastChunk;
+    do {
+      if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+      if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+      if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+    } while (chunk = chunk.previous);
+    if (this.intro.length) return this.intro[this.intro.length - 1];
+    return "";
+  }
+  lastLine() {
+    let lineIndex = this.outro.lastIndexOf(n);
+    if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+    let lineStr = this.outro;
+    let chunk = this.lastChunk;
+    do {
+      if (chunk.outro.length > 0) {
+        lineIndex = chunk.outro.lastIndexOf(n);
+        if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+        lineStr = chunk.outro + lineStr;
+      }
+      if (chunk.content.length > 0) {
+        lineIndex = chunk.content.lastIndexOf(n);
+        if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+        lineStr = chunk.content + lineStr;
+      }
+      if (chunk.intro.length > 0) {
+        lineIndex = chunk.intro.lastIndexOf(n);
+        if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+        lineStr = chunk.intro + lineStr;
+      }
+    } while (chunk = chunk.previous);
+    lineIndex = this.intro.lastIndexOf(n);
+    if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+    return this.intro + lineStr;
+  }
+  slice(start = 0, end = this.original.length - this.offset) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (this.original.length !== 0) {
+      while (start < 0) start += this.original.length;
+      while (end < 0) end += this.original.length;
+    }
+    let result = "";
+    let chunk = this.firstChunk;
+    while (chunk && (chunk.start > start || chunk.end <= start)) {
+      if (chunk.start < end && chunk.end >= end) {
+        return result;
+      }
+      chunk = chunk.next;
+    }
+    if (chunk && chunk.edited && chunk.start !== start)
+      throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+    const startChunk = chunk;
+    while (chunk) {
+      if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
+        result += chunk.intro;
+      }
+      const containsEnd = chunk.start < end && chunk.end >= end;
+      if (containsEnd && chunk.edited && chunk.end !== end)
+        throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
+      const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+      const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+      result += chunk.content.slice(sliceStart, sliceEnd);
+      if (chunk.outro && (!containsEnd || chunk.end === end)) {
+        result += chunk.outro;
+      }
+      if (containsEnd) {
+        break;
+      }
+      chunk = chunk.next;
+    }
+    return result;
+  }
+  // TODO deprecate this? not really very useful
+  snip(start, end) {
+    const clone = this.clone();
+    clone.remove(0, start);
+    clone.remove(end, clone.original.length);
+    return clone;
+  }
+  _split(index) {
+    if (this.byStart[index] || this.byEnd[index]) return;
+    let chunk = this.lastSearchedChunk;
+    const searchForward = index > chunk.end;
+    while (chunk) {
+      if (chunk.contains(index)) return this._splitChunk(chunk, index);
+      chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+    }
+  }
+  _splitChunk(chunk, index) {
+    if (chunk.edited && chunk.content.length) {
+      const loc = getLocator(this.original)(index);
+      throw new Error(
+        `Cannot split a chunk that has already been edited (${loc.line}:${loc.column} \u2013 "${chunk.original}")`
+      );
+    }
+    const newChunk = chunk.split(index);
+    this.byEnd[index] = chunk;
+    this.byStart[index] = newChunk;
+    this.byEnd[newChunk.end] = newChunk;
+    if (chunk === this.lastChunk) this.lastChunk = newChunk;
+    this.lastSearchedChunk = chunk;
+    return true;
+  }
+  toString() {
+    let str = this.intro;
+    let chunk = this.firstChunk;
+    while (chunk) {
+      str += chunk.toString();
+      chunk = chunk.next;
+    }
+    return str + this.outro;
+  }
+  isEmpty() {
+    let chunk = this.firstChunk;
+    do {
+      if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim())
+        return false;
+    } while (chunk = chunk.next);
+    return true;
+  }
+  length() {
+    let chunk = this.firstChunk;
+    let length = 0;
+    do {
+      length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+    } while (chunk = chunk.next);
+    return length;
+  }
+  trimLines() {
+    return this.trim("[\\r\\n]");
+  }
+  trim(charType) {
+    return this.trimStart(charType).trimEnd(charType);
+  }
+  trimEndAborted(charType) {
+    const rx = new RegExp((charType || "\\s") + "+$");
+    this.outro = this.outro.replace(rx, "");
+    if (this.outro.length) return true;
+    let chunk = this.lastChunk;
+    do {
+      const end = chunk.end;
+      const aborted = chunk.trimEnd(rx);
+      if (chunk.end !== end) {
+        if (this.lastChunk === chunk) {
+          this.lastChunk = chunk.next;
+        }
+        this.byEnd[chunk.end] = chunk;
+        this.byStart[chunk.next.start] = chunk.next;
+        this.byEnd[chunk.next.end] = chunk.next;
+      }
+      if (aborted) return true;
+      chunk = chunk.previous;
+    } while (chunk);
+    return false;
+  }
+  trimEnd(charType) {
+    this.trimEndAborted(charType);
+    return this;
+  }
+  trimStartAborted(charType) {
+    const rx = new RegExp("^" + (charType || "\\s") + "+");
+    this.intro = this.intro.replace(rx, "");
+    if (this.intro.length) return true;
+    let chunk = this.firstChunk;
+    do {
+      const end = chunk.end;
+      const aborted = chunk.trimStart(rx);
+      if (chunk.end !== end) {
+        if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+        this.byEnd[chunk.end] = chunk;
+        this.byStart[chunk.next.start] = chunk.next;
+        this.byEnd[chunk.next.end] = chunk.next;
+      }
+      if (aborted) return true;
+      chunk = chunk.next;
+    } while (chunk);
+    return false;
+  }
+  trimStart(charType) {
+    this.trimStartAborted(charType);
+    return this;
+  }
+  hasChanged() {
+    return this.original !== this.toString();
+  }
+  _replaceRegexp(searchValue, replacement) {
+    function getReplacement(match, str) {
+      if (typeof replacement === "string") {
+        return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
+          if (i === "$") return "$";
+          if (i === "&") return match[0];
+          const num = +i;
+          if (num < match.length) return match[+i];
+          return `$${i}`;
+        });
+      } else {
+        return replacement(...match, match.index, str, match.groups);
+      }
+    }
+    function matchAll(re, str) {
+      let match;
+      const matches2 = [];
+      while (match = re.exec(str)) {
+        matches2.push(match);
+      }
+      return matches2;
+    }
+    if (searchValue.global) {
+      const matches2 = matchAll(searchValue, this.original);
+      matches2.forEach((match) => {
+        if (match.index != null) {
+          const replacement2 = getReplacement(match, this.original);
+          if (replacement2 !== match[0]) {
+            this.overwrite(match.index, match.index + match[0].length, replacement2);
+          }
+        }
+      });
+    } else {
+      const match = this.original.match(searchValue);
+      if (match && match.index != null) {
+        const replacement2 = getReplacement(match, this.original);
+        if (replacement2 !== match[0]) {
+          this.overwrite(match.index, match.index + match[0].length, replacement2);
+        }
+      }
+    }
+    return this;
+  }
+  _replaceString(string, replacement) {
+    const { original } = this;
+    const index = original.indexOf(string);
+    if (index !== -1) {
+      this.overwrite(index, index + string.length, replacement);
+    }
+    return this;
+  }
+  replace(searchValue, replacement) {
+    if (typeof searchValue === "string") {
+      return this._replaceString(searchValue, replacement);
+    }
+    return this._replaceRegexp(searchValue, replacement);
+  }
+  _replaceAllString(string, replacement) {
+    const { original } = this;
+    const stringLength = string.length;
+    for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
+      const previous = original.slice(index, index + stringLength);
+      if (previous !== replacement) this.overwrite(index, index + stringLength, replacement);
+    }
+    return this;
+  }
+  replaceAll(searchValue, replacement) {
+    if (typeof searchValue === "string") {
+      return this._replaceAllString(searchValue, replacement);
+    }
+    if (!searchValue.global) {
+      throw new TypeError(
+        "MagicString.prototype.replaceAll called with a non-global RegExp argument"
+      );
+    }
+    return this._replaceRegexp(searchValue, replacement);
+  }
+};
+
+// src/federation/src/prod/remote-production.ts
+import path3 from "path";
+
+// src/federation/src/public.ts
+var EXPOSES_MAP = /* @__PURE__ */ new Map();
+var EXPOSES_KEY_MAP = /* @__PURE__ */ new Map();
+var SHARED = "shared";
+var DYNAMIC_LOADING_CSS = "dynamicLoadingCss";
+var DYNAMIC_LOADING_CSS_PREFIX = "__v__css__";
+var DEFAULT_ENTRY_FILENAME = "remoteEntry.js";
+var EXTERNALS = [];
+var builderInfo = {
   builder: "rollup",
+  version: "",
   assetsDir: "",
   isHost: false,
   isRemote: false,
   isShared: false
 };
-const parsedOptions = {
+var parsedOptions = {
   prodExpose: [],
   prodRemote: [],
   prodShared: [],
@@ -28,12 +1252,17 @@ const parsedOptions = {
   devExpose: [],
   devRemote: []
 };
-const devRemotes = [];
-const prodRemotes = [];
-const viteConfigResolved = {
+var devRemotes = [];
+var prodRemotes = [];
+var viteConfigResolved = {
   config: void 0
 };
-const unaryTags = /* @__PURE__ */ new Set(["link", "meta", "base"]);
+
+// src/federation/src/utils/index.ts
+import path2, { parse, posix } from "path";
+
+// src/federation/src/utils/html.ts
+var unaryTags = /* @__PURE__ */ new Set(["link", "meta", "base"]);
 function serializeTag({ tag, attrs, children }, indent = "") {
   if (unaryTags.has(tag)) {
     return `<${tag}${serializeAttrs(attrs)}>`;
@@ -67,7 +1296,7 @@ function serializeAttrs(attrs) {
 function incrementIndent(indent = "") {
   return `${indent}${indent[0] === "	" ? "	" : "  "}`;
 }
-const matchHtmlRegExp = /["'&<>]/;
+var matchHtmlRegExp = /["'&<>]/;
 function escapeHtml(string) {
   const str = "" + string;
   const match = matchHtmlRegExp.exec(str);
@@ -106,12 +1335,12 @@ function escapeHtml(string) {
   }
   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) => ({
+var headInjectRE = /([ \t]*)<\/head>/i;
+var headPrependInjectRE = /([ \t]*)<head[^>]*>/i;
+var htmlPrependInjectRE = /([ \t]*)<html[^>]*>/i;
+var bodyPrependInjectRE = /([ \t]*)<body[^>]*>/i;
+var doctypePrependInjectRE = /<!doctype html>/i;
+var toPreloadTag = (href) => ({
   tag: "link",
   attrs: {
     rel: "modulepreload",
@@ -157,6 +1386,8 @@ ${serializeTags(tags)}`);
   }
   return serializeTags(tags) + html;
 }
+
+// src/federation/src/utils/index.ts
 function parseSharedOptions(options) {
   return parseOptions(
     options.shared || {},
@@ -250,7 +1481,7 @@ function parseOptions(options, normalizeSimple, normalizeOptions) {
   }
   return list;
 }
-const letterReg = new RegExp("[0-9a-zA-Z]+");
+var letterReg = new RegExp("[0-9a-zA-Z]+");
 function removeNonRegLetter(str, reg = letterReg) {
   let needUpperCase = false;
   let ret = "";
@@ -290,10 +1521,12 @@ function getFileExtname(url) {
   const fileNameAndParamArr = normalizePath(url).split("/");
   const fileNameAndParam = fileNameAndParamArr[fileNameAndParamArr.length - 1];
   const fileName = fileNameAndParam.split("?")[0];
-  return path.extname(fileName);
+  return path2.extname(fileName);
 }
-const REMOTE_FROM_PARAMETER = "remoteFrom";
-const NAME_CHAR_REG = new RegExp("[0-9a-zA-Z@_-]+");
+var REMOTE_FROM_PARAMETER = "remoteFrom";
+var NAME_CHAR_REG = new RegExp("[0-9a-zA-Z@_-]+");
+
+// src/federation/src/prod/remote-production.ts
 function joinUrlSegments(a, b) {
   if (!a || !b) {
     return a || b || "";
@@ -308,7 +1541,7 @@ function joinUrlSegments(a, b) {
 }
 function toOutputFilePathWithoutRuntime(filename, type, hostId, hostType, config, toRelative) {
   const { renderBuiltUrl } = config.experimental;
-  let relative2 = config.base === "" || config.base === "./";
+  let relative3 = config.base === "" || config.base === "./";
   if (renderBuiltUrl) {
     const result = renderBuiltUrl(filename, {
       hostId,
@@ -323,13 +1556,13 @@ function toOutputFilePathWithoutRuntime(filename, type, hostId, hostType, config
         );
       }
       if (typeof result.relative === "boolean") {
-        relative2 = result.relative;
+        relative3 = result.relative;
       }
     } else if (result) {
       return result;
     }
   }
-  if (relative2 && !config.build.ssr) {
+  if (relative3 && !config.build.ssr) {
     return toRelative(filename, hostId);
   } else {
     return joinUrlSegments(config.base, filename);
@@ -556,6 +1789,7 @@ function prodRemotePlugin(options) {
         let manualRequired = null;
         walk(ast, {
           enter(node) {
+            var _a, _b, _c, _d, _e;
             if (node.type === "ImportDeclaration") {
               const moduleName = node.source.value;
               if (parsedOptions.prodShared.some(
@@ -563,12 +1797,13 @@ function prodRemotePlugin(options) {
               )) {
                 const namedImportDeclaration = [];
                 let defaultImportDeclaration = null;
-                if (!node.specifiers?.length) {
+                if (!((_a = node.specifiers) == null ? void 0 : _a.length)) {
                   magicString.remove(node.start, node.end);
                   modify = true;
                 } else {
                   node.specifiers.forEach((specify) => {
-                    if (specify.imported?.name) {
+                    var _a2;
+                    if ((_a2 = specify.imported) == null ? void 0 : _a2.name) {
                       namedImportDeclaration.push(
                         `${specify.imported.name === specify.local.name ? specify.imported.name : `${specify.imported.name}:${specify.local.name}`}`
                       );
@@ -603,13 +1838,13 @@ const {${imports}} = ${defaultImportDeclaration};
                 }
               }
             }
-            if (node.type === "ImportDeclaration" && node.source?.value === "virtual:__federation__") {
+            if (node.type === "ImportDeclaration" && ((_b = node.source) == null ? void 0 : _b.value) === "virtual:__federation__") {
               manualRequired = node;
             }
-            if ((node.type === "ImportExpression" || node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration") && node.source?.value?.indexOf("/") > -1) {
+            if ((node.type === "ImportExpression" || node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration") && ((_d = (_c = node.source) == null ? void 0 : _c.value) == null ? void 0 : _d.indexOf("/")) > -1) {
               const moduleId = node.source.value;
               const remote = prodRemotes.find((r) => r.regexp.test(moduleId));
-              const needWrap = remote?.config.from === "vite";
+              const needWrap = (remote == null ? void 0 : remote.config.from) === "vite";
               if (remote) {
                 requiresRuntime = true;
                 const modName = `.${moduleId.slice(remote.id.length)}`;
@@ -627,7 +1862,7 @@ const {${imports}} = ${defaultImportDeclaration};
                     break;
                   }
                   case "ImportDeclaration": {
-                    if (node.specifiers?.length) {
+                    if ((_e = node.specifiers) == null ? void 0 : _e.length) {
                       const afterImportName = `__federation_var_${moduleId.replace(
                         /[@/\\.-]/g,
                         ""
@@ -791,8 +2026,8 @@ const {${imports}} = ${defaultImportDeclaration};
       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),
+        const basePath = resolvedConfig.base === "./" || resolvedConfig.base === "" ? path3.posix.join(
+          path3.posix.relative(entryChunk[fileName].fileName, "").slice(0, -2),
           "./"
         ) : resolvedConfig.base;
         const toOutputFilePath = (filename) => toOutputFilePathWithoutRuntime(
@@ -824,8 +2059,16 @@ const {${imports}} = ${defaultImportDeclaration};
     }
   };
 }
-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$/;
+
+// src/federation/src/prod/shared-production.ts
+import { basename, join, resolve as resolve2 } from "path";
+import { readdirSync, readFileSync, statSync } from "fs";
+
+// raw:E:\meet-hive\meethive\packages\vite\src\federation\src\prod\federation_fn_import.js
+var federation_fn_import_default = "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";
+
+// src/federation/src/prod/shared-production.ts
+var sharedFilePathReg = /__federation_shared_(.+)-.{8}\.js$/;
 function prodSharedPlugin(options) {
   parsedOptions.prodShared = parseSharedOptions(options);
   const shareName2Prop = /* @__PURE__ */ new Map();
@@ -851,7 +2094,7 @@ function prodSharedPlugin(options) {
       }
       if (conflictModules.size > 0) {
         console.info(
-          `[Federation] 检测到模块 [${Array.from(conflictModules).join(", ")}] 同时配置在 shared 和 manualChunks 中，启用协商共存模式`
+          `[Federation] \u68C0\u6D4B\u5230\u6A21\u5757 [${Array.from(conflictModules).join(", ")}] \u540C\u65F6\u914D\u7F6E\u5728 shared \u548C manualChunks \u4E2D\uFF0C\u542F\u7528\u534F\u5546\u5171\u5B58\u6A21\u5F0F`
         );
         adaptSharedToManualChunks(conflictModules);
       }
@@ -864,7 +2107,7 @@ function prodSharedPlugin(options) {
         config.manualChunkCompat = true;
         config.chunkLoading = "defer";
         console.info(
-          `[Federation] 模块 "${moduleName}" 设置为兼容模式：manualChunks 负责分块，federation 负责运行时共享`
+          `[Federation] \u6A21\u5757 "${moduleName}" \u8BBE\u7F6E\u4E3A\u517C\u5BB9\u6A21\u5F0F\uFF1AmanualChunks \u8D1F\u8D23\u5206\u5757\uFF0Cfederation \u8D1F\u8D23\u8FD0\u884C\u65F6\u5171\u4EAB`
         );
       }
     });
@@ -872,13 +2115,14 @@ function prodSharedPlugin(options) {
   return {
     name: "originjs:shared-production",
     virtualFile: {
-      __federation_fn_import: federation_fn_import
+      __federation_fn_import: federation_fn_import_default
     },
     options(inputOptions) {
+      var _a;
       isRemote = !!parsedOptions.prodExpose.length;
       isHost = options.isHost;
       if (shareName2Prop.size) {
-        inputOptions.external = inputOptions.external?.filter((item) => {
+        inputOptions.external = (_a = inputOptions.external) == null ? void 0 : _a.filter((item) => {
           if (item instanceof RegExp)
             return ![...shareName2Prop.keys()].some((key) => item.test(key));
           return !shareName2Prop.has(removeNonRegLetter(item, NAME_CHAR_REG));
@@ -888,6 +2132,7 @@ function prodSharedPlugin(options) {
       return inputOptions;
     },
     async buildStart() {
+      var _a;
       if (parsedOptions.prodShared.length && isRemote) {
         this.emitFile({
           name: "__federation_fn_import",
@@ -909,10 +2154,10 @@ function prodSharedPlugin(options) {
       };
       const monoRepos = [];
       const dirPaths = [];
-      const currentDir = resolve();
+      const currentDir = resolve2();
       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;
+          const packageJsonPath = (_a = await this.resolve(`${arr[1].packagePath}/package.json`)) == null ? void 0 : _a.id;
           if (packageJsonPath) {
             const packageJson = JSON.parse(
               readFileSync(packageJsonPath, { encoding: "utf-8" })
@@ -946,11 +2191,11 @@ function prodSharedPlugin(options) {
           for (const id of monoRepo.arr) {
             try {
               const idResolve = await this.resolve(id);
-              if (idResolve?.id) {
+              if (idResolve == null ? void 0 : idResolve.id) {
                 parsedOptions.prodShared.push([
                   `${monoRepo.root[0]}/${basename(id)}`,
                   {
-                    id: idResolve?.id,
+                    id: idResolve == null ? void 0 : idResolve.id,
                     import: monoRepo.root[1].import,
                     shareScope: monoRepo.root[1].shareScope,
                     root: monoRepo.root
@@ -972,7 +2217,10 @@ function prodSharedPlugin(options) {
       outputOption.hoistTransitiveImports = false;
       const manualChunkFunc = (id) => {
         const find = parsedOptions.prodShared.find(
-          (arr) => arr[1].dependencies?.has(id)
+          (arr) => {
+            var _a;
+            return (_a = arr[1].dependencies) == null ? void 0 : _a.has(id);
+          }
         );
         return find ? find[0] : void 0;
       };
@@ -990,6 +2238,7 @@ function prodSharedPlugin(options) {
       return outputOption;
     },
     generateBundle(options2, bundle) {
+      var _a;
       if (!isRemote) {
         return;
       }
@@ -999,7 +2248,7 @@ function prodSharedPlugin(options) {
         if (chunk.type === "chunk") {
           if (!isHost) {
             const regRst = sharedFilePathReg.exec(chunk.fileName);
-            if (regRst && shareName2Prop.get(removeNonRegLetter(regRst[1], NAME_CHAR_REG))?.generate === false) {
+            if (regRst && ((_a = shareName2Prop.get(removeNonRegLetter(regRst[1], NAME_CHAR_REG))) == null ? void 0 : _a.generate) === false) {
               needRemoveShared.add(key);
             }
           }
@@ -1013,10 +2262,14 @@ function prodSharedPlugin(options) {
     }
   };
 }
+
+// src/federation/src/prod/expose-production.ts
+import { resolve as resolve3, parse as parse2, basename as basename2, extname, relative, dirname as dirname2 } from "path";
 function prodExposePlugin(options) {
   let moduleMap = "";
   const hasOptions = parsedOptions.prodExpose.some((expose) => {
-    return expose[0] === parseExposeOptions(options)[0]?.[0];
+    var _a;
+    return expose[0] === ((_a = parseExposeOptions(options)[0]) == null ? void 0 : _a[0]);
   });
   if (!hasOptions) {
     parsedOptions.prodExpose = Array.prototype.concat(
@@ -1025,8 +2278,9 @@ function prodExposePlugin(options) {
     );
   }
   for (const item of parseExposeOptions(options)) {
-    getModuleMarker(`\${${item[0]}}`, SHARED);
-    const exposeFilepath = normalizePath(resolve(item[1].import));
+    const moduleName = getModuleMarker(`\${${item[0]}}`, SHARED);
+    EXTERNALS.push(moduleName);
+    const exposeFilepath = normalizePath(resolve3(item[1].import));
     EXPOSES_MAP.set(item[0], exposeFilepath);
     EXPOSES_KEY_MAP.set(
       item[0],
@@ -1076,11 +2330,11 @@ function prodExposePlugin(options) {
            if (isAbsoluteUrl(baseUrl)) {
              href = [cleanBaseUrl, cleanAssetsDir, cleanCssPath].filter(Boolean).join('/');
            } else {
-            // 当remoteEntry.js和CSS都在assets目录下时，使用相对路径
+            // \u5F53remoteEntry.js\u548CCSS\u90FD\u5728assets\u76EE\u5F55\u4E0B\u65F6\uFF0C\u4F7F\u7528\u76F8\u5BF9\u8DEF\u5F84
             const remoteEntryInAssets = cleanCurUrl.endsWith('/assets/') || cleanCurUrl.endsWith('/assets');
             
             if (remoteEntryInAssets) {
-              // 都在assets目录下，直接使用CSS文件名
+              // \u90FD\u5728assets\u76EE\u5F55\u4E0B\uFF0C\u76F4\u63A5\u4F7F\u7528CSS\u6587\u4EF6\u540D
               href = [cleanCurUrl, cleanCssPath].filter(Boolean).join('/');
             } else if (cleanCurUrl.includes(cleanBaseUrl)) {
               href = [cleanCurUrl, cleanAssetsDir, cleanCssPath].filter(Boolean).join('/');
@@ -1145,10 +2399,11 @@ function prodExposePlugin(options) {
       }
     },
     generateBundle(_options, bundle) {
+      var _a, _b, _c;
       let remoteEntryChunk;
       for (const file in bundle) {
         const chunk = bundle[file];
-        if (chunk?.facadeModuleId === `\0virtual:__remoteEntryHelper__${options.filename}`) {
+        if ((chunk == null ? void 0 : chunk.facadeModuleId) === `\0virtual:__remoteEntryHelper__${options.filename}`) {
           remoteEntryChunk = chunk;
           break;
         }
@@ -1156,13 +2411,13 @@ function prodExposePlugin(options) {
       if (remoteEntryChunk) {
         remoteEntryChunk.code = remoteEntryChunk.code.replace(
           "__VITE_BASE_PLACEHOLDER__",
-          `'${viteConfigResolved.config?.base || ""}'`
+          `'${((_a = viteConfigResolved.config) == null ? void 0 : _a.base) || ""}'`
         ).replace(
           "__VITE_ASSETS_DIR_PLACEHOLDER__",
           `'${builderInfo.assetsDir || ""}'`
         );
         const filepathMap = /* @__PURE__ */ new Map();
-        const getFilename = (name) => parse(parse(name).name).name;
+        const getFilename = (name) => parse2(parse2(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]);
@@ -1174,7 +2429,7 @@ function prodExposePlugin(options) {
             if (viteConfigResolved.config && !viteConfigResolved.config.build.cssCodeSplit) {
               if (cssBundlesMap.size) {
                 return `[${[...cssBundlesMap.values()].map(
-                  (cssBundle) => JSON.stringify(basename(cssBundle.fileName))
+                  (cssBundle) => JSON.stringify(basename2(cssBundle.fileName))
                 ).join(",")}]`;
               } else {
                 return "[]";
@@ -1209,7 +2464,7 @@ function prodExposePlugin(options) {
               }
             };
             [fileBundle.fileName, ...fileBundle.imports].forEach(addDepCss);
-            return `[${[...depCssFiles].map((d) => JSON.stringify(basename(d))).join(",")}]`;
+            return `[${[...depCssFiles].map((d) => JSON.stringify(basename2(d))).join(",")}]`;
           }
         );
         for (const expose of parseExposeOptions(options)) {
@@ -1220,13 +2475,13 @@ function prodExposePlugin(options) {
           if (module) {
             const chunk = bundle[module];
             const fileRelativePath = relative(
-              dirname(remoteEntryChunk.fileName),
+              dirname2(remoteEntryChunk.fileName),
               chunk.fileName
             );
             const slashPath = fileRelativePath.replace(/\\/g, "/");
             remoteEntryChunk.code = remoteEntryChunk.code.replace(
               `\${__federation_expose_${expose[0]}}`,
-              viteConfigResolved.config?.base?.replace(/\/+$/, "") ? [
+              ((_c = (_b = viteConfigResolved.config) == null ? void 0 : _b.base) == null ? void 0 : _c.replace(/\/+$/, "")) ? [
                 viteConfigResolved.config.base.replace(/\/+$/, ""),
                 slashPath
               ].filter(Boolean).join("/") : `./${slashPath}`
@@ -1245,9 +2500,10 @@ function prodExposePlugin(options) {
         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(
+            var _a2, _b2;
+            if (node && node.type === "CallExpression" && typeof ((_a2 = node.arguments[0]) == null ? void 0 : _a2.value) === "string" && ((_b2 = node.arguments[0]) == null ? void 0 : _b2.value.indexOf(
               `${DYNAMIC_LOADING_CSS_PREFIX}`
-            ) > -1) {
+            )) > -1) {
               magicString.remove(node.start, node.end + 1);
             }
           }
@@ -1257,12 +2513,18 @@ function prodExposePlugin(options) {
     }
   };
 }
+
+// src/federation/src/dev/shared-development.ts
 function devSharedPlugin(options) {
   parsedOptions.devShared = parseSharedOptions(options);
   return {
     name: "originjs:shared-development"
   };
 }
+
+// src/federation/src/dev/remote-development.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { posix as posix2 } from "path";
 function devRemotePlugin(options) {
   parsedOptions.devRemote = parseRemoteOptions(options);
   for (const item of parsedOptions.devRemote) {
@@ -1412,17 +2674,18 @@ export {__federation_method_ensure, __federation_method_getRemote , __federation
       viteDevServer = server;
     },
     async transform(code, id) {
+      var _a;
       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;
+            const packageJsonPath = (_a = await this.resolve(`${arr[0]}/package.json`)) == null ? void 0 : _a.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" })
+                readFileSync2(packageJsonPath, { encoding: "utf-8" })
               );
               arr[1].version = json.version;
             }
@@ -1455,13 +2718,14 @@ export {__federation_method_ensure, __federation_method_getRemote , __federation
       let manualRequired = null;
       walk(ast, {
         enter(node) {
-          if (node.type === "ImportDeclaration" && node.source?.value === "virtual:__federation__") {
+          var _a2, _b, _c, _d;
+          if (node.type === "ImportDeclaration" && ((_a2 = node.source) == null ? void 0 : _a2.value) === "virtual:__federation__") {
             manualRequired = node;
           }
-          if ((node.type === "ImportExpression" || node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration") && node.source?.value?.indexOf("/") > -1) {
+          if ((node.type === "ImportExpression" || node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration") && ((_c = (_b = node.source) == null ? void 0 : _b.value) == null ? void 0 : _c.indexOf("/")) > -1) {
             const moduleId = node.source.value;
             const remote = devRemotes.find((r) => r.regexp.test(moduleId));
-            const needWrap = remote?.config.from === "vite";
+            const needWrap = (remote == null ? void 0 : remote.config.from) === "vite";
             if (remote) {
               requiresRuntime = true;
               const modName = `.${moduleId.slice(remote.id.length)}`;
@@ -1479,7 +2743,7 @@ export {__federation_method_ensure, __federation_method_getRemote , __federation
                   break;
                 }
                 case "ImportDeclaration": {
-                  if (node.specifiers?.length) {
+                  if ((_d = node.specifiers) == null ? void 0 : _d.length) {
                     const afterImportName = `__federation_var_${moduleId.replace(
                       /[@/\\.-]/g,
                       ""
@@ -1607,7 +2871,7 @@ export {__federation_method_ensure, __federation_method_getRemote , __federation
         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 relativePath = idx === 0 ? posix2.join(base, moduleFilePath.slice(cwdPath.length)) : null;
         const sharedName = item[0];
         const obj = item[1];
         let str = "";
@@ -1623,19 +2887,150 @@ export {__federation_method_ensure, __federation_method_getRemote , __federation
     return res;
   }
 }
+
+// src/federation/src/dev/expose-development.ts
 function devExposePlugin(options) {
   parsedOptions.devExpose = parseExposeOptions(options);
   return {
     name: "originjs:expose-development"
   };
 }
-const normalizeAssetsDir = (config) => {
-  const configured = config?.build?.assetsDir ?? "assets";
+
+// src/federation/src/runtime/dynamic-remote.ts
+var DynamicRemoteManager = class {
+  remoteCache = /* @__PURE__ */ new Map();
+  loadingPromises = /* @__PURE__ */ new Map();
+  /**
+   * Add a remote dynamically at runtime
+   * @param name Remote name
+   * @param config Remote configuration
+   */
+  async addRemote(name, config) {
+    try {
+      const federationModule = await import("virtual:__federation__");
+      const { __federation_method_add_origin_setRemote } = federationModule;
+      await __federation_method_add_origin_setRemote(name, config.url, {
+        format: config.format || "esm",
+        from: config.from || "vite",
+        shareScope: config.shareScope || "default",
+        external: config.external,
+        externalType: config.externalType || "url"
+      });
+    } catch (error) {
+      throw new Error(`Failed to add dynamic remote '${name}': ${error.message}. Make sure to enable dynamic remotes in your plugin configuration with 'enableDynamicRemotes: true'.`);
+    }
+  }
+  /**
+   * Load a remote component dynamically
+   * @param remoteName Remote name
+   * @param componentName Component name to load from remote
+   * @returns Promise of the loaded component
+   */
+  async loadRemoteComponent(remoteName, componentName) {
+    const cacheKey = `${remoteName}/${componentName}`;
+    if (this.remoteCache.has(cacheKey)) {
+      return this.remoteCache.get(cacheKey);
+    }
+    if (this.loadingPromises.has(cacheKey)) {
+      return this.loadingPromises.get(cacheKey);
+    }
+    const loadingPromise = this.doLoadRemoteComponent(remoteName, componentName);
+    this.loadingPromises.set(cacheKey, loadingPromise);
+    try {
+      const component = await loadingPromise;
+      this.remoteCache.set(cacheKey, component);
+      return component;
+    } finally {
+      this.loadingPromises.delete(cacheKey);
+    }
+  }
+  async doLoadRemoteComponent(remoteName, componentName) {
+    try {
+      const federationModule = await import("virtual:__federation__");
+      const { __federation_method_getRemote } = federationModule;
+      return __federation_method_getRemote(remoteName, componentName);
+    } catch (error) {
+      throw new Error(`Failed to load remote component '${remoteName}/${componentName}': ${error.message}. Make sure to enable dynamic remotes in your plugin configuration with 'enableDynamicRemotes: true'.`);
+    }
+  }
+  /**
+   * Preload a remote component
+   * @param remoteName Remote name
+   * @param componentName Component name
+   */
+  async preloadRemoteComponent(remoteName, componentName) {
+    try {
+      await this.loadRemoteComponent(remoteName, componentName);
+    } catch (error) {
+      console.warn(`Failed to preload remote component ${remoteName}/${componentName}:`, error);
+    }
+  }
+  /**
+   * Remove a remote component from cache
+   * @param remoteName Remote name
+   * @param componentName Component name
+   */
+  clearRemoteComponentCache(remoteName, componentName) {
+    if (componentName) {
+      const cacheKey = `${remoteName}/${componentName}`;
+      this.remoteCache.delete(cacheKey);
+    } else {
+      for (const key of this.remoteCache.keys()) {
+        if (key.startsWith(`${remoteName}/`)) {
+          this.remoteCache.delete(key);
+        }
+      }
+    }
+  }
+  /**
+   * Get all cached remote components
+   */
+  getCachedRemotes() {
+    return Array.from(this.remoteCache.keys());
+  }
+  /**
+   * Check if a remote component is cached
+   * @param remoteName Remote name
+   * @param componentName Component name
+   */
+  isRemoteComponentCached(remoteName, componentName) {
+    const cacheKey = `${remoteName}/${componentName}`;
+    return this.remoteCache.has(cacheKey);
+  }
+};
+var dynamicRemoteManager = new DynamicRemoteManager();
+function isVueAvailable() {
+  try {
+    return typeof ref !== "undefined" && typeof onMounted !== "undefined";
+  } catch {
+    return false;
+  }
+}
+var ref;
+var onMounted;
+var 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 {
+  }
+}
+
+// src/federation/src/index.ts
+var normalizeAssetsDir = (config) => {
+  var _a, _b;
+  const configured = ((_a = config == null ? void 0 : config.build) == null ? void 0 : _a.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, "/");
+  const root = (config == null ? void 0 : config.root) ? resolve4(config.root) : process.cwd();
+  const resolvedOutDir = ((_b = config == null ? void 0 : config.build) == null ? void 0 : _b.outDir) ? isAbsolute(config.build.outDir) ? config.build.outDir : resolve4(root, config.build.outDir) : resolve4(root, "dist");
+  const normalized = relative2(resolvedOutDir, configured).replace(/\\/g, "/");
   return normalized.startsWith("..") ? "" : normalized || "assets";
 };
 function federation(options) {
@@ -1678,6 +3073,7 @@ function federation(options) {
     enforce: "post",
     // apply:'build',
     options(_options) {
+      var _a;
       if (!registerCount++) {
         registerPlugins(options.mode = options.mode ?? "production", "");
       }
@@ -1689,36 +3085,41 @@ function federation(options) {
         _options.external = [_options.external];
       }
       for (const pluginHook of pluginList) {
-        pluginHook.options?.call(this, _options);
+        (_a = pluginHook.options) == null ? void 0 : _a.call(this, _options);
       }
       return _options;
     },
     config(config, env) {
+      var _a;
       options.mode = options.mode ?? env.mode;
       registerPlugins(options.mode, env.command);
       registerCount++;
       for (const pluginHook of pluginList) {
-        pluginHook.config?.call(this, config, env);
+        (_a = pluginHook.config) == null ? void 0 : _a.call(this, config, env);
       }
       builderInfo.builder = "vite";
       builderInfo.assetsDir = normalizeAssetsDir(config) ?? "assets";
     },
     configureServer(server) {
+      var _a;
       for (const pluginHook of pluginList) {
-        pluginHook.configureServer?.call(this, server);
+        (_a = pluginHook.configureServer) == null ? void 0 : _a.call(this, server);
       }
     },
     configResolved(config) {
+      var _a;
       for (const pluginHook of pluginList) {
-        pluginHook.configResolved?.call(this, config);
+        (_a = pluginHook.configResolved) == null ? void 0 : _a.call(this, config);
       }
     },
     buildStart(inputOptions) {
+      var _a;
       for (const pluginHook of pluginList) {
-        pluginHook.buildStart?.call(this, inputOptions);
+        (_a = pluginHook.buildStart) == null ? void 0 : _a.call(this, inputOptions);
       }
     },
     async resolveId(...args) {
+      var _a;
       const v = virtualMod.resolveId.call(this, ...args);
       if (v) {
         return v;
@@ -1730,9 +3131,9 @@ function federation(options) {
         };
       }
       if (args[0] === "__federation_fn_satisfy") {
-        const federationId = (await this.resolve("@meethive/vite"))?.id;
+        const federationId = (_a = await this.resolve("@meethive/vite")) == null ? void 0 : _a.id;
         if (federationId) {
-          return await this.resolve(`${dirname(federationId)}/satisfy.mjs`);
+          return await this.resolve(`${dirname3(federationId)}/satisfy.mjs`);
         }
         return null;
       }
@@ -1752,8 +3153,9 @@ function federation(options) {
       return null;
     },
     transform(code, id) {
+      var _a;
       for (const pluginHook of pluginList) {
-        const result = pluginHook.transform?.call(this, code, id);
+        const result = (_a = pluginHook.transform) == null ? void 0 : _a.call(this, code, id);
         if (result) {
           return result;
         }
@@ -1761,19 +3163,22 @@ function federation(options) {
       return code;
     },
     moduleParsed(moduleInfo) {
+      var _a;
       for (const pluginHook of pluginList) {
-        pluginHook.moduleParsed?.call(this, moduleInfo);
+        (_a = pluginHook.moduleParsed) == null ? void 0 : _a.call(this, moduleInfo);
       }
     },
     outputOptions(outputOptions) {
+      var _a;
       for (const pluginHook of pluginList) {
-        pluginHook.outputOptions?.call(this, outputOptions);
+        (_a = pluginHook.outputOptions) == null ? void 0 : _a.call(this, outputOptions);
       }
       return outputOptions;
     },
     renderChunk(code, chunkInfo, _options) {
+      var _a;
       for (const pluginHook of pluginList) {
-        const result = pluginHook.renderChunk?.call(
+        const result = (_a = pluginHook.renderChunk) == null ? void 0 : _a.call(
           this,
           code,
           chunkInfo,
@@ -1786,13 +3191,20 @@ function federation(options) {
       return null;
     },
     generateBundle: function(_options, bundle, isWrite) {
+      var _a;
       for (const pluginHook of pluginList) {
-        pluginHook.generateBundle?.call(this, _options, bundle, isWrite);
+        (_a = pluginHook.generateBundle) == null ? void 0 : _a.call(this, _options, bundle, isWrite);
       }
     }
   };
 }
-const languageWorkAttr = [
+
+// src/monaco-editor/index.ts
+import { resolve as resolve5, join as join2 } from "path";
+import { buildSync as buildSync2 } from "esbuild";
+
+// src/monaco-editor/languageWork.ts
+var languageWorkAttr = [
   {
     label: "editorWorkerService",
     entry: "monaco-editor/esm/vs/editor/editor.worker"
@@ -1814,15 +3226,20 @@ const languageWorkAttr = [
     entry: "monaco-editor/esm/vs/language/typescript/ts.worker"
   }
 ];
-const languageWorksByLabel = {};
+var languageWorksByLabel = {};
 languageWorkAttr.forEach(
   (languageWork) => languageWorksByLabel[languageWork.label] = languageWork
 );
+
+// src/monaco-editor/workerMiddleware.ts
+import { buildSync } from "esbuild";
+import { existsSync, readFileSync as readFileSync3, rmSync } from "fs";
+import { basename as basename3 } from "path";
 function getFilenameByEntry(entry) {
-  entry = basename(entry, "js");
+  entry = basename3(entry, "js");
   return entry + ".bundle.js";
 }
-const cacheDir = "node_modules/.monaco/";
+var cacheDir = "node_modules/.monaco/";
 function getWorkPath(works, options, config) {
   const workerPaths = {};
   for (const work of works) {
@@ -1861,18 +3278,20 @@ function workerMiddleware(middlewares, config, options) {
             outfile: cacheDir + getFilenameByEntry(work.entry)
           });
         }
-        const contentBuffer = readFileSync(cacheDir + getFilenameByEntry(work.entry));
+        const contentBuffer = readFileSync3(cacheDir + getFilenameByEntry(work.entry));
         res.setHeader("Content-Type", "text/javascript");
         res.end(contentBuffer);
       }
     );
   }
 }
+
+// src/monaco-editor/index.ts
 function resolveMonacoPath(filePath) {
   try {
-    return resolve(join(process.cwd(), "node_modules", filePath));
+    return resolve5(join2(process.cwd(), "node_modules", filePath));
   } catch (err) {
-    return resolve(filePath);
+    return resolve5(filePath);
   }
 }
 function getWorks(options) {
@@ -1882,8 +3301,9 @@ function getWorks(options) {
   works.push(...options.customWorkers);
   return works;
 }
-const getFS = async () => {
-  if (typeof process !== "undefined" && process.versions?.node) {
+var getFS = async () => {
+  var _a;
+  if (typeof process !== "undefined" && ((_a = process.versions) == null ? void 0 : _a.node)) {
     const fs = await import("fs");
     return {
       existsSync: fs.existsSync,
@@ -1973,7 +3393,7 @@ function monacoEditorPlugin(options) {
         resolvedConfig.root,
         resolvedConfig.build.outDir,
         resolvedConfig.base
-      ) : join(
+      ) : join2(
         resolvedConfig.root,
         resolvedConfig.build.outDir,
         resolvedConfig.base,
@@ -1986,14 +3406,14 @@ function monacoEditorPlugin(options) {
       }
       for (const work of works) {
         if (!fs.existsSync(cacheDir + getFilenameByEntry(work.entry))) {
-          buildSync({
+          buildSync2({
             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));
+        const workDistPath = resolve5(distPath, getFilenameByEntry(work.entry));
         fs.writeFileSync(workDistPath, contentBuffer);
       }
     }
@@ -2005,6 +3425,9 @@ function isCDN(publicPath) {
   }
   return false;
 }
+
+// src/sharp/index.ts
+import path4 from "path";
 function matches(filename, patterns) {
   if (!patterns || patterns.length === 0) return true;
   return patterns.some(
@@ -2036,7 +3459,7 @@ function sharpOptimize(options = {}) {
     async generateBundle(_opts, bundle) {
       for (const [fileName, asset] of Object.entries(bundle)) {
         if (asset.type !== "asset") continue;
-        const ext = path$1.extname(fileName).toLowerCase();
+        const ext = path4.extname(fileName).toLowerCase();
         if (!imageExts.has(ext)) continue;
         if (exclude && matches(fileName, exclude)) continue;
         if (include && !matches(fileName, include)) continue;