rollup-plugin-iife-split 0.0.1

package/README.md

@@ -0,0 +1,119 @@
+# rollup-plugin-iife-split
+
+A Rollup plugin that enables intelligent code-splitting for IIFE output.
+
+## The Problem
+
+Rollup's native IIFE output doesn't support code-splitting. With ESM, Rollup automatically creates shared chunks that are imported transparently. But with IIFE, you'd need to manually add `<script>` tags for each chunk, and those chunk names change between builds.
+
+## The Solution
+
+This plugin:
+1. Uses Rollup's ESM code-splitting internally
+2. Merges all shared code into a "primary" entry point
+3. Converts everything to IIFE at the last moment
+4. Satellite entries access shared code via a global variable
+
+The result: You get code-splitting benefits with only one `<script>` tag per entry point.
+
+## Installation
+
+```bash
+npm install rollup-plugin-iife-split
+```
+
+## Usage
+
+```js
+// rollup.config.js
+import iifeSplit from 'rollup-plugin-iife-split';
+
+export default {
+  input: {
+    main: 'src/main.js',
+    admin: 'src/admin.js',
+    widget: 'src/widget.js'
+  },
+  plugins: [
+    iifeSplit({
+      primary: 'main',        // Which entry gets the shared code
+      primaryGlobal: 'MyLib', // Browser global: window.MyLib
+      secondaryProps: {
+        admin: 'Admin',       // Browser global: window.MyLib.Admin
+        widget: 'Widget',     // Browser global: window.MyLib.Widget
+      },
+      sharedProp: 'Shared',   // Shared code at: window.MyLib.Shared
+    })
+  ],
+  output: {
+    dir: 'dist'
+  }
+};
+```
+
+## Output
+
+**main.js** (primary entry):
+```js
+var MyLib = (function (exports) {
+  // Shared code from all common dependencies
+  function sharedUtil() { /* ... */ }
+
+  // Main entry code
+  function mainFeature() { /* ... */ }
+
+  exports.mainFeature = mainFeature;
+  exports.Shared = { sharedUtil };
+  return exports;
+})({});
+```
+
+**admin.js** (satellite entry):
+```js
+MyLib.Admin = (function (exports, shared) {
+  // Uses shared code via parameter
+  function adminFeature() {
+    return shared.sharedUtil();
+  }
+
+  exports.adminFeature = adminFeature;
+  return exports;
+})({}, MyLib.Shared);
+```
+
+## HTML Usage
+
+```html
+<!-- Load primary first (contains shared code) -->
+<script src="dist/main.js"></script>
+
+<!-- Then load any satellite entries you need -->
+<script src="dist/admin.js"></script>
+
+<script>
+  MyLib.mainFeature();
+  MyLib.Admin.adminFeature();
+</script>
+```
+
+## Options
+
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `primary` | `string` | Yes | Name of the primary entry (must match a key in Rollup's `input`). Shared code is merged into this entry. |
+| `primaryGlobal` | `string` | Yes | Browser global variable name for the primary entry. Example: `'MyLib'` → `window.MyLib` |
+| `secondaryProps` | `Record<string, string>` | Yes | Maps secondary entry names to their property name on the primary global. Example: `{ admin: 'Admin' }` → `window.MyLib.Admin` |
+| `sharedProp` | `string` | Yes | Property name on the global where shared exports are attached. Example: `'Shared'` → `window.MyLib.Shared` |
+| `debug` | `boolean` | No | Enable debug logging to see intermediate transformation steps. |
+
+## How It Works
+
+1. **Build phase**: Rollup builds with ESM format, using `manualChunks` to consolidate all shared modules into one chunk
+2. **Transform phase**: In `generateBundle`, the plugin:
+   - Merges the shared chunk into the primary entry
+   - Converts each chunk from ESM to IIFE using a nested Rollup instance
+   - Deletes the shared chunk from output
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import { Plugin } from 'rollup';
+
+interface IifeSplitOptions {
+    /**
+     * The name of the primary entry point (must match a key in Rollup's input map).
+     * The shared chunk will be merged into this entry.
+     */
+    primary: string;
+    /**
+     * The global variable name for the primary entry's exports.
+     * Example: 'MyLib' results in `window.MyLib = ...`
+     */
+    primaryGlobal: string;
+    /**
+     * Maps secondary entry names to their property name on the primary global.
+     * Example: { admin: 'Admin', widget: 'Widget' } results in:
+     *   - `window.MyLib.Admin` for the 'admin' entry
+     *   - `window.MyLib.Widget` for the 'widget' entry
+     */
+    secondaryProps: Record<string, string>;
+    /**
+     * The property name on the global where shared exports are attached.
+     * Example: 'Shared' results in `window.MyLib.Shared = { ... }`
+     */
+    sharedProp: string;
+    /**
+     * Enable debug logging to see intermediate transformation steps.
+     */
+    debug?: boolean;
+}
+
+declare function iifeSplit(options: IifeSplitOptions): Plugin;
+
+export { type IifeSplitOptions, iifeSplit as default };

package/dist/index.js

@@ -0,0 +1,564 @@
+// src/chunk-analyzer.ts
+function isOutputChunk(item) {
+  return item.type === "chunk";
+}
+var SHARED_CHUNK_NAME = "__shared__";
+function analyzeChunks(bundle, primaryEntryName) {
+  const chunks = Object.values(bundle).filter(isOutputChunk);
+  const sharedChunk = chunks.find(
+    (chunk) => !chunk.isEntry && chunk.name === SHARED_CHUNK_NAME
+  ) || null;
+  const primaryChunk = chunks.find(
+    (chunk) => chunk.isEntry && chunk.name === primaryEntryName
+  );
+  if (!primaryChunk) {
+    const availableEntries = chunks.filter((c) => c.isEntry).map((c) => c.name).join(", ");
+    throw new Error(
+      `Primary entry "${primaryEntryName}" not found in bundle. Available entries: ${availableEntries}`
+    );
+  }
+  const satelliteChunks = chunks.filter(
+    (chunk) => chunk.isEntry && chunk.name !== primaryEntryName
+  );
+  return { sharedChunk, primaryChunk, satelliteChunks };
+}
+
+// src/esm-to-iife.ts
+import { rollup } from "rollup";
+import { walk } from "estree-walker";
+import MagicString from "magic-string";
+var VIRTUAL_ENTRY = "\0virtual:entry";
+function createVirtualPlugin(code) {
+  return {
+    name: "virtual-entry",
+    resolveId(id) {
+      if (id === VIRTUAL_ENTRY) {
+        return id;
+      }
+      return { id, external: true };
+    },
+    load(id) {
+      if (id === VIRTUAL_ENTRY) {
+        return code;
+      }
+      return null;
+    }
+  };
+}
+function extractSharedImportMappings(code, parse) {
+  const ast = parse(code);
+  const mappings = [];
+  walk(ast, {
+    enter(node) {
+      if (node.type === "ImportDeclaration") {
+        const importNode = node;
+        const source = importNode.source.value;
+        if (typeof source === "string" && source.includes(SHARED_CHUNK_NAME)) {
+          for (const spec of importNode.specifiers) {
+            if (spec.type === "ImportSpecifier" && spec.imported) {
+              mappings.push({
+                imported: spec.imported.name,
+                local: spec.local.name
+              });
+            } else if (spec.type === "ImportDefaultSpecifier") {
+              mappings.push({
+                imported: "default",
+                local: spec.local.name
+              });
+            }
+          }
+        }
+      }
+    }
+  });
+  return mappings;
+}
+function stripNamespaceGuards(code) {
+  let result = code.replace(/^this\.\w+\s*=\s*this\.\w+\s*\|\|\s*\{\};\n/gm, "");
+  result = result.replace(/^this\.(\w+\.\w+)\s*=/gm, "$1 =");
+  return result;
+}
+function destructureSharedParameter(code, mappings, parse) {
+  const ast = parse(code);
+  const ms = new MagicString(code);
+  let sharedParamStart = -1;
+  let sharedParamEnd = -1;
+  let sharedParamName = null;
+  walk(ast, {
+    enter(node) {
+      if (sharedParamName === null && node.type === "FunctionExpression") {
+        const fn = node;
+        const params = fn.params;
+        if (params.length > 0) {
+          const lastParam = params[params.length - 1];
+          if (lastParam.type === "Identifier") {
+            const acornParam = lastParam;
+            sharedParamStart = acornParam.start;
+            sharedParamEnd = acornParam.end;
+            sharedParamName = lastParam.name;
+          }
+        }
+      }
+    }
+  });
+  if (sharedParamName === null) {
+    return code;
+  }
+  const propertyAccesses = [];
+  walk(ast, {
+    enter(node) {
+      if (node.type === "MemberExpression") {
+        const memberNode = node;
+        const obj = memberNode.object;
+        if (obj.type === "Identifier" && obj.name === sharedParamName && !memberNode.computed) {
+          const prop = memberNode.property;
+          propertyAccesses.push({
+            start: memberNode.start,
+            end: memberNode.end,
+            propName: prop.name
+          });
+        }
+      }
+    }
+  });
+  let effectiveMappings = mappings;
+  if (effectiveMappings.length === 0) {
+    const propNames = new Set(propertyAccesses.map((a) => a.propName));
+    effectiveMappings = Array.from(propNames).map((prop) => ({
+      imported: prop,
+      local: prop
+    }));
+  }
+  if (effectiveMappings.length === 0) {
+    return code;
+  }
+  const importToLocal = new Map(effectiveMappings.map((m) => [m.imported, m.local]));
+  const destructureEntries = effectiveMappings.map(
+    (m) => m.imported === m.local ? m.imported : `${m.imported}: ${m.local}`
+  );
+  const destructurePattern = `{ ${destructureEntries.join(", ")} }`;
+  ms.overwrite(sharedParamStart, sharedParamEnd, destructurePattern);
+  for (const { start, end, propName } of propertyAccesses) {
+    const localName = importToLocal.get(propName) ?? propName;
+    ms.overwrite(start, end, localName);
+  }
+  walk(ast, {
+    enter(node) {
+      if (node.type === "ExpressionStatement") {
+        const exprStmt = node;
+        if (exprStmt.expression.type === "Literal" && exprStmt.expression.value === "use strict") {
+          ms.remove(exprStmt.start, exprStmt.end);
+        }
+      }
+    }
+  });
+  return ms.toString();
+}
+async function convertToIife(options) {
+  const { code, globalName, globals, sharedGlobalPath, sharedChunkFileName, parse, debug } = options;
+  const importMappings = sharedGlobalPath ? extractSharedImportMappings(code, parse) : [];
+  if (debug && sharedGlobalPath) {
+    console.log("\n=== DEBUG convertToIife ===");
+    console.log("globalName:", globalName);
+    console.log("sharedGlobalPath:", sharedGlobalPath);
+    console.log("sharedChunkFileName:", sharedChunkFileName);
+    console.log("--- ESM code (first 500 chars) ---");
+    console.log(code.slice(0, 500));
+    console.log("--- Import mappings ---");
+    console.log(importMappings);
+  }
+  const rollupGlobals = (id) => {
+    if (sharedGlobalPath) {
+      if (id.includes(SHARED_CHUNK_NAME)) {
+        return sharedGlobalPath;
+      }
+      if (sharedChunkFileName) {
+        const fileNameWithoutExt = sharedChunkFileName.replace(/\.js$/, "");
+        if (id.includes(fileNameWithoutExt)) {
+          return sharedGlobalPath;
+        }
+      }
+    }
+    return globals[id] ?? id;
+  };
+  const bundle = await rollup({
+    input: VIRTUAL_ENTRY,
+    plugins: [createVirtualPlugin(code)],
+    onwarn: () => {
+    }
+    // Suppress warnings
+  });
+  const { output } = await bundle.generate({
+    format: "iife",
+    name: globalName,
+    globals: rollupGlobals,
+    exports: "named"
+  });
+  await bundle.close();
+  let result = output[0].code;
+  if (debug && sharedGlobalPath) {
+    console.log("--- IIFE before destructuring (first 800 chars) ---");
+    console.log(result.slice(0, 800));
+  }
+  if (sharedGlobalPath) {
+    result = stripNamespaceGuards(result);
+    result = destructureSharedParameter(result, importMappings, parse);
+    if (debug) {
+      console.log("--- IIFE after destructuring (first 800 chars) ---");
+      console.log(result.slice(0, 800));
+      console.log("=== END DEBUG ===\n");
+    }
+  }
+  return result;
+}
+
+// src/chunk-merger.ts
+import MagicString2 from "magic-string";
+import { walk as walk2 } from "estree-walker";
+function extractTopLevelDeclarations(code, parse) {
+  const ast = parse(code);
+  const declarations = /* @__PURE__ */ new Set();
+  for (const node of ast.body) {
+    if (node.type === "VariableDeclaration") {
+      const varDecl = node;
+      for (const decl of varDecl.declarations) {
+        if (decl.id.type === "Identifier") {
+          declarations.add(decl.id.name);
+        }
+      }
+    } else if (node.type === "FunctionDeclaration") {
+      const funcDecl = node;
+      if (funcDecl.id) {
+        declarations.add(funcDecl.id.name);
+      }
+    } else if (node.type === "ClassDeclaration") {
+      const classDecl = node;
+      if (classDecl.id) {
+        declarations.add(classDecl.id.name);
+      }
+    } else if (node.type === "ExportNamedDeclaration") {
+      const exportNode = node;
+      if (exportNode.declaration) {
+        if (exportNode.declaration.type === "VariableDeclaration") {
+          for (const decl of exportNode.declaration.declarations) {
+            if (decl.id.type === "Identifier") {
+              declarations.add(decl.id.name);
+            }
+          }
+        } else if (exportNode.declaration.type === "FunctionDeclaration" && exportNode.declaration.id) {
+          declarations.add(exportNode.declaration.id.name);
+        } else if (exportNode.declaration.type === "ClassDeclaration" && exportNode.declaration.id) {
+          declarations.add(exportNode.declaration.id.name);
+        }
+      }
+    }
+  }
+  return declarations;
+}
+function renameIdentifiers(code, renameMap, parse) {
+  if (renameMap.size === 0) return code;
+  const ast = parse(code);
+  const s = new MagicString2(code);
+  walk2(ast, {
+    enter(node) {
+      if (node.type === "Identifier") {
+        const id = node;
+        const newName = renameMap.get(id.name);
+        if (newName) {
+          s.overwrite(id.start, id.end, newName);
+        }
+      }
+    }
+  });
+  return s.toString();
+}
+function extractExports(code, parse) {
+  const ast = parse(code);
+  const exports = [];
+  let hasDefault = false;
+  walk2(ast, {
+    enter(node) {
+      if (node.type === "ExportNamedDeclaration") {
+        const exportNode = node;
+        if (exportNode.declaration) {
+          if (exportNode.declaration.type === "VariableDeclaration") {
+            for (const decl of exportNode.declaration.declarations) {
+              if (decl.id.type === "Identifier") {
+                exports.push({ exportedName: decl.id.name, localName: decl.id.name });
+              }
+            }
+          } else if (exportNode.declaration.type === "FunctionDeclaration" && exportNode.declaration.id) {
+            const name = exportNode.declaration.id.name;
+            exports.push({ exportedName: name, localName: name });
+          } else if (exportNode.declaration.type === "ClassDeclaration" && exportNode.declaration.id) {
+            const name = exportNode.declaration.id.name;
+            exports.push({ exportedName: name, localName: name });
+          }
+        }
+        if (exportNode.specifiers) {
+          for (const spec of exportNode.specifiers) {
+            const exported = spec.exported;
+            const local = spec.local;
+            exports.push({ exportedName: exported.name, localName: local.name });
+          }
+        }
+      }
+      if (node.type === "ExportDefaultDeclaration") {
+        hasDefault = true;
+      }
+    }
+  });
+  return { exports, hasDefault };
+}
+function stripExports(code, parse) {
+  const ast = parse(code);
+  const s = new MagicString2(code);
+  walk2(ast, {
+    enter(node) {
+      const n = node;
+      if (node.type === "ExportNamedDeclaration") {
+        const exportNode = node;
+        if (exportNode.declaration) {
+          const declNode = exportNode.declaration;
+          s.remove(exportNode.start, declNode.start);
+        } else {
+          s.remove(n.start, n.end);
+        }
+      }
+      if (node.type === "ExportDefaultDeclaration") {
+        const exportNode = node;
+        const declNode = exportNode.declaration;
+        s.overwrite(exportNode.start, declNode.start, "const __shared_default__ = ");
+      }
+    }
+  });
+  return s.toString();
+}
+function isSharedChunkSource(source, sharedChunkFileName) {
+  return source.includes(SHARED_CHUNK_NAME) || source.includes(sharedChunkFileName.replace(/\.js$/, ""));
+}
+function removeSharedImportsAndRewriteRefs(code, sharedChunkFileName, sharedExportToLocal, parse) {
+  const ast = parse(code);
+  const s = new MagicString2(code);
+  const namespaceNames = /* @__PURE__ */ new Set();
+  walk2(ast, {
+    enter(node) {
+      if (node.type === "ImportDeclaration") {
+        const importNode = node;
+        const source = importNode.source.value;
+        if (typeof source === "string" && isSharedChunkSource(source, sharedChunkFileName)) {
+          for (const spec of importNode.specifiers) {
+            if (spec.type === "ImportNamespaceSpecifier") {
+              namespaceNames.add(spec.local.name);
+            }
+          }
+        }
+      }
+    }
+  });
+  walk2(ast, {
+    enter(node) {
+      if (node.type === "ImportDeclaration") {
+        const importNode = node;
+        const source = importNode.source.value;
+        if (typeof source === "string" && isSharedChunkSource(source, sharedChunkFileName)) {
+          s.remove(importNode.start, importNode.end);
+        }
+      }
+      if (node.type === "ExportNamedDeclaration") {
+        const exportNode = node;
+        if (exportNode.source) {
+          const source = exportNode.source.value;
+          if (typeof source === "string" && isSharedChunkSource(source, sharedChunkFileName)) {
+            const exportParts = [];
+            for (const spec of exportNode.specifiers) {
+              const exportedName = spec.exported.name;
+              const importedName = spec.local.name;
+              const localName = sharedExportToLocal.get(importedName) ?? importedName;
+              if (localName === exportedName) {
+                exportParts.push(localName);
+              } else {
+                exportParts.push(`${localName} as ${exportedName}`);
+              }
+            }
+            s.overwrite(exportNode.start, exportNode.end, `export { ${exportParts.join(", ")} };`);
+          }
+        }
+      }
+      if (node.type === "MemberExpression") {
+        const memberNode = node;
+        if (memberNode.object.type === "Identifier" && memberNode.object.name && namespaceNames.has(memberNode.object.name) && memberNode.property.type === "Identifier" && memberNode.property.name && !memberNode.computed) {
+          const propertyName = memberNode.property.name;
+          const localName = sharedExportToLocal.get(propertyName) ?? propertyName;
+          s.overwrite(memberNode.start, memberNode.end, localName);
+        }
+      }
+    }
+  });
+  return s.toString();
+}
+function extractSharedImports(code, sharedChunkFileName, parse) {
+  const ast = parse(code);
+  const imports = /* @__PURE__ */ new Set();
+  walk2(ast, {
+    enter(node) {
+      if (node.type === "ImportDeclaration") {
+        const importNode = node;
+        const source = importNode.source.value;
+        if (typeof source === "string" && isSharedChunkSource(source, sharedChunkFileName)) {
+          for (const spec of importNode.specifiers) {
+            if (spec.type === "ImportSpecifier" && spec.imported) {
+              imports.add(spec.imported.name);
+            } else if (spec.type === "ImportDefaultSpecifier") {
+              imports.add("default");
+            } else if (spec.type === "ImportNamespaceSpecifier") {
+            }
+          }
+        }
+      }
+    }
+  });
+  return imports;
+}
+function mergeSharedIntoPrimary(primaryChunk, sharedChunk, sharedProperty, neededExports, parse) {
+  const { exports: sharedExports, hasDefault } = extractExports(sharedChunk.code, parse);
+  const sharedDeclarations = extractTopLevelDeclarations(sharedChunk.code, parse);
+  const primaryDeclarations = extractTopLevelDeclarations(primaryChunk.code, parse);
+  const renameMap = /* @__PURE__ */ new Map();
+  for (const name of sharedDeclarations) {
+    if (primaryDeclarations.has(name)) {
+      renameMap.set(name, `__shared$${name}`);
+    }
+  }
+  let processedSharedCode = sharedChunk.code;
+  if (renameMap.size > 0) {
+    processedSharedCode = renameIdentifiers(processedSharedCode, renameMap, parse);
+  }
+  const strippedSharedCode = stripExports(processedSharedCode, parse);
+  const sharedExportToLocal = /* @__PURE__ */ new Map();
+  for (const exp of sharedExports) {
+    const renamedLocal = renameMap.get(exp.localName) ?? exp.localName;
+    sharedExportToLocal.set(exp.exportedName, renamedLocal);
+  }
+  if (hasDefault) {
+    sharedExportToLocal.set("default", "__shared_default__");
+  }
+  const primaryWithoutSharedImports = removeSharedImportsAndRewriteRefs(
+    primaryChunk.code,
+    sharedChunk.fileName,
+    sharedExportToLocal,
+    parse
+  );
+  const sharedExportEntries = [
+    ...sharedExports.filter((exp) => neededExports.has(exp.exportedName)).map((exp) => {
+      const renamedLocal = renameMap.get(exp.localName) ?? exp.localName;
+      return exp.exportedName === renamedLocal ? renamedLocal : `${exp.exportedName}: ${renamedLocal}`;
+    }),
+    ...hasDefault && neededExports.has("default") ? ["default: __shared_default__"] : []
+  ];
+  const sharedExportObject = `const ${sharedProperty} = { ${sharedExportEntries.join(", ")} };`;
+  primaryChunk.code = [
+    "// === Shared code (merged by rollup-plugin-iife-split) ===",
+    strippedSharedCode.trim(),
+    "",
+    "// === Primary entry code ===",
+    primaryWithoutSharedImports.trim(),
+    "",
+    "// === Shared exports object ===",
+    sharedExportObject,
+    `export { ${sharedProperty} };`
+  ].join("\n");
+}
+
+// src/index.ts
+function iifeSplit(options) {
+  const { primary, primaryGlobal, secondaryProps, sharedProp, debug } = options;
+  let outputGlobals = {};
+  const manualChunks = (id, { getModuleInfo }) => {
+    const moduleInfo = getModuleInfo(id);
+    if (!moduleInfo) return void 0;
+    if (moduleInfo.isEntry) return void 0;
+    const importers = moduleInfo.importers || [];
+    if (importers.length > 1) {
+      return SHARED_CHUNK_NAME;
+    }
+    return void 0;
+  };
+  return {
+    name: "iife-split",
+    // Hook into outputOptions to capture globals and configure chunking
+    outputOptions(outputOptions) {
+      outputGlobals = outputOptions.globals ?? {};
+      return {
+        ...outputOptions,
+        format: "es",
+        manualChunks
+      };
+    },
+    // Main transformation hook - convert ESM chunks to IIFE
+    async generateBundle(outputOptions, bundle) {
+      const parse = this.parse.bind(this);
+      const analysis = analyzeChunks(bundle, primary);
+      const sharedChunkFileName = analysis.sharedChunk?.fileName ?? null;
+      if (analysis.sharedChunk) {
+        const neededExports = /* @__PURE__ */ new Set();
+        for (const satellite of analysis.satelliteChunks) {
+          const imports = extractSharedImports(satellite.code, analysis.sharedChunk.fileName, parse);
+          for (const imp of imports) {
+            neededExports.add(imp);
+          }
+        }
+        mergeSharedIntoPrimary(
+          analysis.primaryChunk,
+          analysis.sharedChunk,
+          sharedProp,
+          neededExports,
+          parse
+        );
+        delete bundle[analysis.sharedChunk.fileName];
+      }
+      const conversions = [];
+      conversions.push(
+        convertToIife({
+          code: analysis.primaryChunk.code,
+          globalName: primaryGlobal,
+          globals: outputGlobals,
+          sharedGlobalPath: null,
+          // Primary doesn't need to import shared
+          sharedChunkFileName: null,
+          parse,
+          debug
+        }).then((code) => {
+          analysis.primaryChunk.code = code;
+        })
+      );
+      for (const satellite of analysis.satelliteChunks) {
+        const satelliteProp = secondaryProps[satellite.name];
+        const hasExports = satellite.exports.length > 0;
+        if (!satelliteProp && hasExports) {
+          throw new Error(
+            `Secondary entry "${satellite.name}" not found in secondaryProps. Available entries: ${Object.keys(secondaryProps).join(", ") || "(none)"}`
+          );
+        }
+        const satelliteGlobalName = satelliteProp ? `${primaryGlobal}.${satelliteProp}` : void 0;
+        conversions.push(
+          convertToIife({
+            code: satellite.code,
+            globalName: satelliteGlobalName,
+            globals: outputGlobals,
+            sharedGlobalPath: `${primaryGlobal}.${sharedProp}`,
+            sharedChunkFileName,
+            parse,
+            debug
+          }).then((code) => {
+            satellite.code = code;
+          })
+        );
+      }
+      await Promise.all(conversions);
+    }
+  };
+}
+export {
+  iifeSplit as default
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "rollup-plugin-iife-split",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "Rollup plugin for intelligent IIFE code-splitting",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "rollup": "^3.0.0 || ^4.0.0"
+  },
+  "dependencies": {
+    "magic-string": "^0.30.0",
+    "estree-walker": "^3.0.0"
+  },
+  "devDependencies": {
+    "rollup": "^4.0.0",
+    "typescript": "^5.0.0",
+    "tsup": "^8.0.0",
+    "vitest": "^1.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "keywords": [
+    "rollup",
+    "plugin",
+    "iife",
+    "code-splitting",
+    "bundle"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "tsup src/index.ts --format esm --dts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:run": "vitest run"
+  }
+}