@tsparticles/rollup-plugin 3.4.14 → 4.0.0-beta.12

package/dist/index.js

@@ -1,4 +1,6 @@
+import fs from 'node:fs';
 import path from 'node:path';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
 import replace from '@rollup/plugin-replace';
 import terser from '@rollup/plugin-terser';
 import { visualizer } from 'rollup-plugin-visualizer';
@@ -86,19 +88,276 @@ const buildMap = {
         banner: ({ version }) => `Updater v${version}`,
         minBanner: ({ version }) => `Updater v${version}`,
     },
+    util: {
+        format: "",
+        hasBundle: false,
+        banner: ({ version }) => `Utility v${version}`,
+        minBanner: ({ version, bundleName }) => `tsParticles ${bundleName ?? "Utility"} v${version}`,
+    },
 };
 
 const getEntry = (data) => {
-    const { bundle, format, lazy, min, name } = data, fileName = bundle ? "bundle" : "index", completeFileName = lazy ? `${fileName}.lazy` : fileName, fixFormat = format ? `.${format}` : "", fixName = name ? `.${name}` : "", fixMin = min ? ".min" : "", fixLazy = lazy ? ".lazy" : "";
+    const { bundle, dir, format, lazy, min, name } = data, fileName = bundle ? "bundle" : "index", browserFileName = "browser", completeFileName = lazy ? `${fileName}.lazy` : fileName, completeBrowserFileName = lazy ? `${browserFileName}.lazy` : browserFileName, browserCandidate = path.resolve(dir, "dist/browser", `${completeBrowserFileName}.js`), inputFileName = !bundle && fs.existsSync(browserCandidate) ? completeBrowserFileName : completeFileName, fixFormat = format ? `.${format}` : "", fixName = name ? `.${name}` : "", fixMin = min ? ".min" : "", fixLazy = lazy ? ".lazy" : "";
     return {
         name: `tsparticles${fixFormat}${fixName}${fixLazy}${fixMin}`,
-        input: `./dist/browser/${completeFileName}.js`,
+        input: `./dist/browser/${inputFileName}.js`,
+    };
+};
+
+const internalRoot = "__tsParticlesInternals";
+const toScopeSegment = (value) => {
+    const normalized = value
+        .replaceAll(/([a-z\d])([A-Z])/g, "$1-$2")
+        .replaceAll(/[._\s]+/g, "-")
+        .toLowerCase();
+    return normalized
+        .split("-")
+        .filter(Boolean)
+        .map((segment, index) => index === 0 ? segment : `${segment[0]?.toUpperCase() ?? ""}${segment.slice(1)}`)
+        .join("");
+};
+const resolveBundleScope = (moduleName) => {
+    if (!moduleName) {
+        return "full";
+    }
+    return toScopeSegment(moduleName);
+};
+const resolveKind = (scope) => {
+    if (scope === "pjs") {
+        return "pjs";
+    }
+    if (scope === "confetti") {
+        return "confetti";
+    }
+    if (scope === "fireworks") {
+        return "fireworks";
+    }
+    return "bundle";
+};
+const buildTypePrefix = {
+    effect: "effects",
+    interaction: "interactions",
+    interactionExternal: "interactions",
+    interactionParticles: "interactions",
+    palette: "palettes",
+    path: "paths",
+    plugin: "plugins",
+    pluginEasing: "plugins",
+    pluginEmittersShape: "plugins.emittersShapes",
+    pluginExport: "plugins",
+    preset: "presets",
+    shape: "shapes",
+    template: "utils",
+    updater: "updaters",
+};
+/**
+ * Qualifies a raw module-name leaf with a type-specific prefix so that
+ * `getUmdPolicyData` produces the same namespace as `getUmdGlobalForExternal`.
+ * Without this, `interactionExternal "parallax"` would land on
+ * `interactions.parallax` while the non-bundled consumer expects
+ * `interactions.externalParallax`, causing a UMD global mismatch.
+ */
+const leafPrefixes = {
+    interactionExternal: "external-",
+    interactionParticles: "particles-",
+    pluginEasing: "easing-",
+};
+const qualifyLeaf = (type, rawLeaf) => {
+    const prefix = leafPrefixes[type];
+    return prefix ? `${prefix}${rawLeaf}` : rawLeaf;
+};
+const getUmdPolicyData = (type, moduleName) => {
+    if (type === "engine") {
+        return {
+            kind: "engine",
+            scope: `${internalRoot}.engine`,
+        };
+    }
+    if (type === "bundle") {
+        const scope = resolveBundleScope(moduleName);
+        return {
+            kind: resolveKind(scope),
+            scope: `${internalRoot}.bundles.${scope}`,
+        };
+    }
+    if (type === "util") {
+        // Util packages use the moduleName as-is (dots as separators), e.g. "canvas.utils" -> "__tsParticlesInternals.canvas.utils"
+        // This must match the getUmdGlobalForExternal fallback for deps that reference these packages.
+        return {
+            kind: "package",
+            scope: `${internalRoot}.${moduleName ?? "util"}`,
+        };
+    }
+    const prefix = buildTypePrefix[type], rawLeaf = moduleName ?? "default", leaf = toScopeSegment(qualifyLeaf(type, rawLeaf));
+    return {
+        kind: "package",
+        scope: `${internalRoot}.${prefix}.${leaf}`,
     };
 };
+const buildScopedPath = (prefix, rawLeaf) => {
+    const leaf = toScopeSegment(rawLeaf);
+    return `${internalRoot}.${prefix}.${leaf}`;
+};
+const bundleLeafGlobals = new Map(["all", "basic", "confetti", "fireworks", "pjs", "slim"].map(leaf => [leaf, `${internalRoot}.bundles.${leaf}`]));
+const scopedPrefixRules = [
+    {
+        // @tsparticles/plugin-export-image -> __tsParticlesInternals.plugins.image
+        prefix: "plugin-export-",
+        scope: "plugins",
+    },
+    {
+        prefix: "plugin-emitters-shape-",
+        scope: "plugins.emittersShapes",
+    },
+    {
+        prefix: "plugin-",
+        scope: "plugins",
+    },
+    {
+        prefix: "interaction-external-",
+        scope: "interactions",
+        transform: segment => `external-${segment}`,
+    },
+    {
+        prefix: "interaction-particles-",
+        scope: "interactions",
+        transform: segment => `particles-${segment}`,
+    },
+    {
+        prefix: "interaction-",
+        scope: "interactions",
+    },
+    {
+        prefix: "effect-",
+        scope: "effects",
+    },
+    {
+        prefix: "path-",
+        scope: "paths",
+    },
+    {
+        prefix: "shape-",
+        scope: "shapes",
+    },
+    {
+        prefix: "updater-",
+        scope: "updaters",
+    },
+    {
+        prefix: "palette-",
+        scope: "palettes",
+    },
+    {
+        prefix: "preset-",
+        scope: "presets",
+    },
+];
+const getScopedGlobalFromPrefix = (leaf) => {
+    for (const rule of scopedPrefixRules) {
+        if (!leaf.startsWith(rule.prefix)) {
+            continue;
+        }
+        const segment = leaf.slice(rule.prefix.length);
+        return buildScopedPath(rule.scope, rule.transform ? rule.transform(segment) : segment);
+    }
+    return undefined;
+};
+const getScopedGlobalForLeaf = (leaf) => {
+    const directLeafMap = new Map([
+        ["engine", `${internalRoot}.engine`],
+        // Util packages: not "path plugins" but helper utilities; map to their actual scope
+        ["path-utils", `${internalRoot}.path.utils`],
+        ["canvas-utils", `${internalRoot}.canvas.utils`],
+        // Historical package name mismatch: @tsparticles/path-zig-zag exposes paths.zigzag.
+        ["path-zig-zag", `${internalRoot}.paths.zigzag`],
+        // Historical package name mismatch: @tsparticles/plugin-poisson-disc exposes plugins.poisson.
+        ["plugin-poisson-disc", `${internalRoot}.plugins.poisson`],
+        ...bundleLeafGlobals,
+    ]), bundleLeaf = directLeafMap.get(leaf);
+    if (bundleLeaf) {
+        return bundleLeaf;
+    }
+    const scopedLeaf = getScopedGlobalFromPrefix(leaf);
+    if (scopedLeaf) {
+        return scopedLeaf;
+    }
+    return `${internalRoot}.${leaf.split("-").map(toScopeSegment).join(".")}`;
+};
+const getUmdGlobalForExternal = (id) => {
+    if (id === "tsparticles") {
+        return `${internalRoot}.bundles.full`;
+    }
+    if (id.startsWith("tsparticles-")) {
+        return buildScopedPath("bundles", id.slice("tsparticles-".length));
+    }
+    if (!id.startsWith("@tsparticles/")) {
+        return undefined;
+    }
+    return getScopedGlobalForLeaf(id.slice("@tsparticles/".length));
+};
+const getUmdGlobalsBootstrap = (temporaryGlobalName) => {
+    const temporaryBootstrap = `g.${temporaryGlobalName}=g.${temporaryGlobalName}||{};`
+        ;
+    // Pre-create namespaces (including nested ones) to avoid eager UMD external lookups
+    // crashing on missing branches like plugins.emittersShapes.circle.
+    const namespaces = [
+        "bundles",
+        "effects",
+        "engine",
+        "interactions",
+        "palettes",
+        "paths",
+        "plugins",
+        "plugins.emittersShapes",
+        "presets",
+        "shapes",
+        "updaters",
+        "utils",
+        "canvas",
+        "canvas.utils",
+        "path",
+        "path.utils",
+    ], namespacesBootstrap = namespaces
+        .map(namespace => {
+        const segments = namespace.split(".");
+        let currentPath = "g.__tsParticlesInternals";
+        return segments
+            .map(segment => {
+            currentPath += `.${segment}`;
+            return `${currentPath}=${currentPath}||{};`;
+        })
+            .join("");
+    })
+        .join("");
+    return (`(function(g){g.__tsParticlesInternals=g.__tsParticlesInternals||{};${namespacesBootstrap}` +
+        `var __tsProxyFactory=typeof Proxy!=="undefined"?function(obj){return new Proxy(obj,{get:function(target,key){if(!(key in target)){target[key]={};}return target[key];}});}:function(obj){return obj;};` +
+        `g.__tsParticlesInternals.bundles=__tsProxyFactory(g.__tsParticlesInternals.bundles);` +
+        `g.__tsParticlesInternals.effects=__tsProxyFactory(g.__tsParticlesInternals.effects);` +
+        `g.__tsParticlesInternals.interactions=__tsProxyFactory(g.__tsParticlesInternals.interactions);` +
+        `g.__tsParticlesInternals.palettes=__tsProxyFactory(g.__tsParticlesInternals.palettes);` +
+        `g.__tsParticlesInternals.paths=__tsProxyFactory(g.__tsParticlesInternals.paths);` +
+        `g.__tsParticlesInternals.plugins=__tsProxyFactory(g.__tsParticlesInternals.plugins);` +
+        `g.__tsParticlesInternals.plugins.emittersShapes=__tsProxyFactory(g.__tsParticlesInternals.plugins.emittersShapes);` +
+        `g.__tsParticlesInternals.presets=__tsProxyFactory(g.__tsParticlesInternals.presets);` +
+        `g.__tsParticlesInternals.shapes=__tsProxyFactory(g.__tsParticlesInternals.shapes);` +
+        `g.__tsParticlesInternals.updaters=__tsProxyFactory(g.__tsParticlesInternals.updaters);` +
+        `g.__tsParticlesInternals.utils=__tsProxyFactory(g.__tsParticlesInternals.utils);` +
+        `g.__tsParticlesInternals.canvas=__tsProxyFactory(g.__tsParticlesInternals.canvas);` +
+        `g.__tsParticlesInternals.path=__tsProxyFactory(g.__tsParticlesInternals.path);` +
+        `${temporaryBootstrap}})(typeof globalThis!=="undefined"?globalThis:typeof window!=="undefined"?window:this);\n`);
+};
 
+const defaultGlobal = "window";
+const getRootGlobal = (external) => {
+    const root = external.data?.root;
+    if (Array.isArray(root)) {
+        return root.filter((t) => typeof t === "string").join(".") || defaultGlobal;
+    }
+    return typeof root === "string" ? root : defaultGlobal;
+};
 const getExternal = ({ bundle, additionalExternals = [] }) => {
     if (bundle) {
-        return [];
+        return additionalExternals.filter(e => !e.bundle).map(e => e.name);
     }
     return [
         ...additionalExternals.map(e => e.name),
@@ -108,22 +367,302 @@ const getExternal = ({ bundle, additionalExternals = [] }) => {
     ];
 };
 const getGlobals = (additionalExternals = [], bundle) => {
-    if (bundle) {
-        return {};
+    const globalsAdditional = bundle ? additionalExternals.filter(e => !e.bundle) : additionalExternals;
+    const additionalMap = new Map(globalsAdditional.map(e => [e.name, getRootGlobal(e)]));
+    return (id) => {
+        if (additionalMap.has(id)) {
+            return additionalMap.get(id) ?? defaultGlobal;
+        }
+        const tsparticlesGlobal = getUmdGlobalForExternal(id);
+        if (tsparticlesGlobal) {
+            return tsparticlesGlobal;
+        }
+        return defaultGlobal;
+    };
+};
+
+const toJsBanner = (text) => {
+    return `/* ${text} */`;
+};
+const temporaryUmdGlobal = "tsparticlesInternalExports";
+const lazyWrapperVirtualPrefix = "\0tsparticles-lazy-wrapper:";
+// Public export predicate per kind
+const getPublicExports = (exports$1, kind) => {
+    const fixedPublicMap = {
+        confetti: "confetti",
+        engine: "tsParticles",
+        fireworks: "fireworks",
+        pjs: "initPjs",
+    };
+    if (kind === "bundle") {
+        // Bundles expose load* functions AND the tsParticles instance (needed for bundle users)
+        return exports$1.filter(t => /^load[A-Z]/.test(t) || t === "tsParticles");
+    }
+    if (kind === "package") {
+        return exports$1.filter(t => /^load[A-Z]/.test(t));
     }
-    return Object.fromEntries(additionalExternals.map(e => [e.name, "window"]));
+    const requiredExport = fixedPublicMap[kind];
+    if (!exports$1.includes(requiredExport)) {
+        throw new Error(`UMD public export policy violated: missing ${requiredExport}`);
+    }
+    return [requiredExport];
+};
+const validatePublicExports = (publicExports, allExports, kind) => {
+    const fixedPublicMap = {
+        confetti: "confetti",
+        engine: "tsParticles",
+        fireworks: "fireworks",
+        pjs: "initPjs",
+    };
+    if (kind !== "bundle" && kind !== "package") {
+        const required = fixedPublicMap[kind];
+        if (!allExports.includes(required)) {
+            throw new Error(`UMD public export policy violated: missing ${required}`);
+        }
+        if (publicExports.length !== 1 || publicExports[0] !== required) {
+            throw new Error(`UMD public export policy violated: ${kind} can expose only ${required}`);
+        }
+        return;
+    }
+    // For bundle/package: only load* (and tsParticles for bundle) are allowed on window
+    const invalid = publicExports.filter(t => !/^load[A-Z]/.test(t) && t !== "tsParticles");
+    if (invalid.length > 0) {
+        throw new Error(`UMD public export policy violated: only load* exports (and tsParticles for bundles) are allowed on window, found ${invalid.join(", ")}`);
+    }
+};
+/**
+ * Build the namespace initialization expression to use as the UMD factory's first argument.
+ * Example: scope = "__tsParticlesInternals.engine"
+ * Result: "(global.__tsParticlesInternals = global.__tsParticlesInternals || {}, global.__tsParticlesInternals.engine = global.__tsParticlesInternals.engine || {})"
+ *
+ * This is used to REPLACE `global.window = global.tsparticlesInternalExports || {}` in the UMD wrapper,
+ * so that rollup writes all exports directly into the correct namespace object.
+ */
+const buildGlobalNamespaceInit = (scope) => {
+    const segments = scope.split(".");
+    const inits = [];
+    let currentPath = "global";
+    for (const segment of segments) {
+        currentPath += `.${segment}`;
+        inits.push(`${currentPath} = ${currentPath} || {}`);
+    }
+    return `(${inits.join(", ")})`;
+};
+/**
+ * Replace the UMD factory's exports target (global.window = ...) with the correct namespace path.
+ * This makes rollup write all `exports.X = X` directly into __tsParticlesInternals.<scope>.
+ */
+const redirectUmdExportsToNamespace = (code, scope) => {
+    const namespaceInit = buildGlobalNamespaceInit(scope);
+    return code
+        // multi-dependency case: factory(global.window = ..., globalDep1, ...)
+        .replaceAll(`factory(global.window = global.${temporaryUmdGlobal} || {}, `, `factory(${namespaceInit}, `)
+        .replaceAll(`factory(global.window = {}, `, `factory(${namespaceInit}, `)
+        // single case: factory(global.window = ...)
+        .replaceAll(`factory(global.window = global.${temporaryUmdGlobal} || {})`, `factory(${namespaceInit})`)
+        .replaceAll(`factory(global.window = {})`, `factory(${namespaceInit})`);
+};
+/**
+ * Build the code that copies public exports from the namespace to window.
+ * Reads from globalThis.__tsParticlesInternals.<scope>.<export> after the factory has run.
+ */
+const buildWindowExposureCode = (scope, publicExports) => {
+    if (publicExports.length === 0) {
+        return "";
+    }
+    const assignments = publicExports.map(exp => `${exp}: (globalThis.${scope} || {}).${exp}`).join(", ");
+    return `Object.assign(globalThis.window || globalThis, { ${assignments} });\n`;
+};
+const buildBundleEngineAliasCode = (umdPolicy) => {
+    if (umdPolicy.kind !== "bundle") {
+        return "";
+    }
+    // Keep backward compatibility for packages that still resolve engine externals from internals.engine.
+    return (`globalThis.__tsParticlesInternals = globalThis.__tsParticlesInternals || {};\n` +
+        `if (!globalThis.__tsParticlesInternals.engine || !globalThis.__tsParticlesInternals.engine.tsParticles) {\n` +
+        `  globalThis.__tsParticlesInternals.engine = globalThis.${umdPolicy.scope} || {};\n` +
+        `}\n`);
+};
+const buildLazyRuntimePath = (name) => {
+    return `chunks/${name}.js`;
 };
+const getLazyRuntimeInputPath = (dir) => {
+    return path.resolve(dir, "dist/browser/index.lazy.js");
+};
+const parseNamedExports = (content) => {
+    const exports$1 = new Set();
+    for (const match of content.matchAll(/export\s+(?:async\s+)?(?:function|class|const|let|var)\s+([A-Za-z_$][\w$]*)/g)) {
+        exports$1.add(match[1]);
+    }
+    for (const match of content.matchAll(/export\s*{([^}]+)}(?!\s*from)/g)) {
+        const values = match[1]
+            .split(",")
+            .map(value => value.trim())
+            .filter(Boolean)
+            .map(value => value.split(/\s+as\s+/).pop()?.trim())
+            .filter((value) => Boolean(value));
+        for (const value of values) {
+            exports$1.add(value);
+        }
+    }
+    return [...exports$1];
+};
+const resolveLazyEntryExports = (filePath, visited = new Set()) => {
+    if (visited.has(filePath) || !fs.existsSync(filePath)) {
+        return [];
+    }
+    visited.add(filePath);
+    const content = fs.readFileSync(filePath, "utf8");
+    const exports$1 = new Set(parseNamedExports(content));
+    for (const match of content.matchAll(/export\s+(?:\*|{[^}]+})\s+from\s+["'](.+?)["']/g)) {
+        const specifier = match[1];
+        if (!specifier.startsWith(".")) {
+            continue;
+        }
+        const resolvedPath = path.resolve(path.dirname(filePath), specifier);
+        const normalizedPath = path.extname(resolvedPath) ? resolvedPath : `${resolvedPath}.js`;
+        for (const value of resolveLazyEntryExports(normalizedPath, visited)) {
+            exports$1.add(value);
+        }
+    }
+    return [...exports$1];
+};
+const createLazyWrapperEntryPlugin = (params, min) => {
+    const { dir, umdPolicy } = params;
+    const { name } = getEntry({ ...params.entry, dir, min, lazy: true });
+    const runtimePath = buildLazyRuntimePath(name);
+    const runtimeInputPath = getLazyRuntimeInputPath(dir);
+    const lazyExports = resolveLazyEntryExports(runtimeInputPath);
+    const publicExports = getPublicExports([...new Set(umdPolicy.kind === "bundle" ? [...lazyExports, "tsParticles"] : lazyExports)], umdPolicy.kind);
+    const needsEngineExports = publicExports.includes("tsParticles") || umdPolicy.kind === "bundle";
+    const exportedDeclarations = publicExports
+        .filter(exp => exp !== "tsParticles")
+        .map(exp => `const ${exp} = async (...args) => { const module = await getLazyModule(); return module.${exp}(...args); };`)
+        .join("\n");
+    const tsParticlesExport = publicExports.includes("tsParticles")
+        ? "const tsParticles = engineExports.tsParticles;"
+        : "";
+    const namedExports = publicExports.join(", ");
+    const engineBootstrap = needsEngineExports
+        ? [
+            "globalThis.__tsParticlesInternals = globalThis.__tsParticlesInternals || {};",
+            "globalThis.__tsParticlesInternals.engine = globalThis.__tsParticlesInternals.engine || engineExports;",
+        ].join("\n")
+        : "";
+    const imports = needsEngineExports ? 'import * as engineExports from "@tsparticles/engine";\n' : "";
+    const source = `${imports}
+const currentScript = typeof document !== "undefined" ? document.currentScript : undefined;
+const runtimeUrl = new URL("${runtimePath}", currentScript?.src ?? globalThis.location?.href ?? "/").href;
+let lazyModulePromise;
+const dynamicImport = new Function("path", "return import(path);");
+const getLazyModule = () => {
+  lazyModulePromise ??= dynamicImport(runtimeUrl);
 
+  return lazyModulePromise;
+};
+${engineBootstrap}
+${tsParticlesExport}
+${exportedDeclarations}
+export { ${namedExports} };
+`;
+    return {
+        name: "tsparticles-lazy-wrapper-entry",
+        resolveId(id) {
+            return id === `${lazyWrapperVirtualPrefix}${name}` ? id : null;
+        },
+        load(id) {
+            return id === `${lazyWrapperVirtualPrefix}${name}` ? source : null;
+        },
+    };
+};
+const exposeEntryExports = (enabled, umdPolicy) => {
+    return {
+        name: "expose-entry-exports",
+        renderChunk(code, chunk) {
+            if (!chunk.isEntry) {
+                return null;
+            }
+            const exports$1 = chunk.exports.filter(t => t !== "default");
+            // No exports at all - just bootstrap namespace and clean up
+            if (exports$1.length === 0) {
+                if (!umdPolicy) {
+                    return null;
+                }
+                const umdCode = redirectUmdExportsToNamespace(code, umdPolicy.scope);
+                return {
+                    code: `${getUmdGlobalsBootstrap(temporaryUmdGlobal)}${umdCode}\ndelete (globalThis.window || globalThis).${temporaryUmdGlobal};\n`,
+                    map: null,
+                };
+            }
+            // No UMD policy (e.g. ESM lazy split bundles) - expose all to window (old behavior)
+            if (!umdPolicy) {
+                const assignments = exports$1.map(t => `${t}: ${t}`).join(", ");
+                return {
+                    code: `${code}\nObject.assign(globalThis.window || globalThis, { ${assignments} });\n`,
+                    map: null,
+                };
+            }
+            // With UMD policy:
+            // 1) Redirect factory's exports target to the internal namespace
+            // 2) After factory runs, copy public exports from namespace to window
+            const publicExports = getPublicExports(exports$1, umdPolicy.kind);
+            validatePublicExports(publicExports, exports$1, umdPolicy.kind);
+            // The key step: replace factory's first arg so rollup writes all exports to __tsParticlesInternals.<scope>
+            const umdCode = redirectUmdExportsToNamespace(code, umdPolicy.scope);
+            // Read public exports from the namespace and expose on window
+            const windowCode = buildWindowExposureCode(umdPolicy.scope, publicExports);
+            const engineAliasCode = buildBundleEngineAliasCode(umdPolicy);
+            return {
+                code: `${getUmdGlobalsBootstrap(temporaryUmdGlobal)}${umdCode}\n${windowCode}${engineAliasCode}` +
+                    `delete (globalThis.window || globalThis).${temporaryUmdGlobal};\n`,
+                map: null,
+            };
+        },
+    };
+};
 const createSingleConfig = (params, min, lazy) => {
-    const { additionalExternals, banner, bundle, dir, entry, minBanner, version, } = params, { name, input } = getEntry({ ...entry, min, lazy });
+    const { additionalExternals, banner, bundle, dir, entry, minBanner, version } = params, { name, input } = getEntry({ ...entry, dir, min, lazy }), wrapperEntryPlugin = lazy ? createLazyWrapperEntryPlugin(params, min) : undefined;
+    if (lazy) {
+        return {
+            input: `${lazyWrapperVirtualPrefix}${name}`,
+            external: getExternal({ bundle, additionalExternals }),
+            plugins: [
+                wrapperEntryPlugin,
+                nodeResolve({
+                    browser: true,
+                }),
+                replace({
+                    preventAssignment: true,
+                    __VERSION__: JSON.stringify(version),
+                }),
+                exposeEntryExports(true, params.umdPolicy),
+                min && terser(),
+            ].filter(Boolean),
+            output: {
+                file: path.resolve(dir, "dist", `${name}.js`),
+                format: "umd",
+                name: temporaryUmdGlobal,
+                globals: getGlobals(additionalExternals, bundle),
+                banner: toJsBanner(min ? minBanner : banner),
+                // inlineDynamicImports must be true for UMD (Rollup doesn't support code-splitting in UMD format).
+                // The actual lazy loading is handled at runtime via `new Function("path", "return import(path)")`
+                // which Rollup cannot see/inline — so setting this to true has no effect on lazy behaviour.
+                inlineDynamicImports: true,
+            },
+        };
+    }
     return {
         input,
         external: getExternal({ bundle, additionalExternals }),
         plugins: [
+            nodeResolve({
+                browser: true,
+            }),
             replace({
                 preventAssignment: true,
                 __VERSION__: JSON.stringify(version),
             }),
+            exposeEntryExports(true, params.umdPolicy),
             !min &&
                 visualizer({
                     filename: path.resolve(dir, "dist/report.html"),
@@ -133,21 +672,44 @@ const createSingleConfig = (params, min, lazy) => {
         output: {
             file: path.resolve(dir, "dist", `${name}.js`),
             format: "umd",
-            name: "tsParticles",
+            name: temporaryUmdGlobal,
             globals: getGlobals(additionalExternals, bundle),
-            banner: min ? minBanner : banner,
+            banner: toJsBanner(min ? minBanner : banner),
             inlineDynamicImports: true,
         },
     };
 };
+const createLazyRuntimeConfig = (params, min) => {
+    const { additionalExternals, banner, bundle, dir, entry, minBanner, version } = params, { name } = getEntry({ ...entry, dir, min, lazy: true });
+    return {
+        input: getLazyRuntimeInputPath(dir),
+        external: getExternal({ bundle, additionalExternals }),
+        plugins: [
+            nodeResolve({
+                browser: true,
+            }),
+            replace({
+                preventAssignment: true,
+                __VERSION__: JSON.stringify(version),
+            }),
+            min && terser(),
+        ].filter(Boolean),
+        output: {
+            dir: path.resolve(dir, "dist"),
+            format: "es",
+            entryFileNames: buildLazyRuntimePath(name),
+            chunkFileNames: min ? "chunks/[name]-[hash].min.js" : "chunks/[name]-[hash].js",
+            banner: toJsBanner(min ? minBanner : banner),
+        },
+    };
+};
 
 const createConfig = (params) => {
-    return [
-        createSingleConfig(params, false, false),
-        createSingleConfig(params, true, false),
-        createSingleConfig(params, false, true),
-        createSingleConfig(params, true, true),
-    ];
+    const configs = [createSingleConfig(params, false, false), createSingleConfig(params, true, false)];
+    if (params.includeLazy) {
+        configs.push(createLazyRuntimeConfig(params, false), createSingleConfig(params, false, true), createLazyRuntimeConfig(params, true), createSingleConfig(params, true, true));
+    }
+    return configs;
 };
 
 const createParticlesBuild = (type, params) => {
@@ -155,7 +717,7 @@ const createParticlesBuild = (type, params) => {
     if (!def) {
         throw new Error(`Unknown build type: ${type}`);
     }
-    const dir = params.dir, version = params.version, additionalExternals = params.additionalExternals, moduleName = params.moduleName, bundle = params.bundle, banner = def.banner(params), minBanner = def.minBanner(params), base = createConfig({
+    const dir = params.dir, version = params.version, additionalExternals = params.additionalExternals, moduleName = params.moduleName, bundle = params.bundle, umdPolicy = getUmdPolicyData(type, moduleName), banner = def.banner(params), minBanner = def.minBanner(params), base = createConfig({
         entry: {
             format: def.format,
             name: moduleName,
@@ -166,6 +728,8 @@ const createParticlesBuild = (type, params) => {
         minBanner,
         dir,
         bundle: false,
+        includeLazy: false,
+        umdPolicy,
         additionalExternals,
     });
     if (def.hasBundle && (bundle ?? true)) {
@@ -184,6 +748,8 @@ const createParticlesBuild = (type, params) => {
                 minBanner,
                 dir,
                 bundle: true,
+                includeLazy: false,
+                umdPolicy,
                 additionalExternals,
             }),
         ];
@@ -207,5 +773,6 @@ const loadParticlesPreset = (p) => createParticlesBuild("preset", p);
 const loadParticlesShape = (p) => createParticlesBuild("shape", p);
 const loadParticlesTemplate = (p) => createParticlesBuild("template", p);
 const loadParticlesUpdater = (p) => createParticlesBuild("updater", p);
+const loadParticlesUtil = (p) => createParticlesBuild("util", p);
 
-export { createParticlesBuild, loadParticlesBundle, loadParticlesEffect, loadParticlesEngine, loadParticlesInteraction, loadParticlesInteractionExternal, loadParticlesInteractionParticles, loadParticlesPalette, loadParticlesPath, loadParticlesPlugin, loadParticlesPluginEasing, loadParticlesPluginEmittersShape, loadParticlesPluginExport, loadParticlesPreset, loadParticlesShape, loadParticlesTemplate, loadParticlesUpdater };
+export { createParticlesBuild, loadParticlesBundle, loadParticlesEffect, loadParticlesEngine, loadParticlesInteraction, loadParticlesInteractionExternal, loadParticlesInteractionParticles, loadParticlesPalette, loadParticlesPath, loadParticlesPlugin, loadParticlesPluginEasing, loadParticlesPluginEmittersShape, loadParticlesPluginExport, loadParticlesPreset, loadParticlesShape, loadParticlesTemplate, loadParticlesUpdater, loadParticlesUtil };