@module-federation/retry-plugin 2.0.1 → 2.2.0

package/dist/index.js

@@ -1,390 +1,307 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// packages/retry-plugin/src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  RetryPlugin: () => RetryPlugin,
-  appendRetryCountQuery: () => appendRetryCountQuery,
-  combineUrlDomainWithPathQuery: () => combineUrlDomainWithPathQuery,
-  getRetryUrl: () => getRetryUrl,
-  rewriteWithNextDomain: () => rewriteWithNextDomain
-});
-module.exports = __toCommonJS(src_exports);
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _module_federation_sdk = require("@module-federation/sdk");
 
-// packages/retry-plugin/src/constant.ts
-var defaultRetries = 3;
-var defaultRetryDelay = 1e3;
-var PLUGIN_IDENTIFIER = "[ Module Federation RetryPlugin ]";
-var ERROR_ABANDONED = "The request failed and has now been abandoned";
-var RUNTIME_008 = "RUNTIME-008";
+//#region src/constant.ts
+const defaultRetries = 3;
+const defaultRetryDelay = 1e3;
+const PLUGIN_IDENTIFIER = "[ Module Federation RetryPlugin ]";
+const ERROR_ABANDONED = "The request failed and has now been abandoned";
+const RUNTIME_008 = "RUNTIME-008";
 
-// packages/retry-plugin/src/logger.ts
-var import_sdk = require("@module-federation/sdk");
-var logger = (0, import_sdk.createLogger)(PLUGIN_IDENTIFIER);
-var logger_default = logger;
+//#endregion
+//#region src/logger.ts
+const logger = (0, _module_federation_sdk.createLogger)(PLUGIN_IDENTIFIER);
 
-// packages/retry-plugin/src/utils.ts
+//#endregion
+//#region src/utils.ts
 function rewriteWithNextDomain(currentUrl, domains) {
-  if (!domains || domains.length === 0)
-    return null;
-  try {
-    const u = new URL(currentUrl);
-    const currentHostname = u.hostname;
-    const currentPort = u.port;
-    const currentHost = `${currentHostname}${currentPort ? `:${currentPort}` : ""}`;
-    const normalized = domains.map((d) => {
-      try {
-        const du = new URL(d.startsWith("http") ? d : `https://${d}`);
-        return {
-          hostname: du.hostname,
-          port: du.port,
-          protocol: du.protocol
-        };
-      } catch {
-        return {
-          hostname: d,
-          port: "",
-          protocol: u.protocol
-        };
-      }
-    }).filter((d) => !!d.hostname);
-    if (normalized.length === 0)
-      return null;
-    let idx = -1;
-    for (let i = normalized.length - 1; i >= 0; i--) {
-      const candHost = `${normalized[i].hostname}${normalized[i].port ? `:${normalized[i].port}` : ""}`;
-      if (candHost === currentHost) {
-        idx = i;
-        break;
-      }
-    }
-    const total = normalized.length;
-    for (let step = 1; step <= total; step++) {
-      const nextIdx = ((idx >= 0 ? idx : -1) + step) % total;
-      const candidate = normalized[nextIdx];
-      const candidateHost = `${candidate.hostname}${candidate.port ? `:${candidate.port}` : ""}`;
-      if (candidateHost !== currentHost) {
-        u.hostname = candidate.hostname;
-        if (candidate.port !== void 0 && candidate.port !== null && candidate.port !== "") {
-          u.port = candidate.port;
-        } else {
-          u.port = "";
-        }
-        u.protocol = candidate.protocol || u.protocol;
-        return u.toString();
-      }
-    }
-    return null;
-  } catch {
-    return null;
-  }
+	if (!domains || domains.length === 0) return null;
+	try {
+		const u = new URL(currentUrl);
+		const currentHostname = u.hostname;
+		const currentPort = u.port;
+		const currentHost = `${currentHostname}${currentPort ? `:${currentPort}` : ""}`;
+		const normalized = domains.map((d) => {
+			try {
+				const du = new URL(d.startsWith("http") ? d : `https://${d}`);
+				return {
+					hostname: du.hostname,
+					port: du.port,
+					protocol: du.protocol
+				};
+			} catch {
+				return {
+					hostname: d,
+					port: "",
+					protocol: u.protocol
+				};
+			}
+		}).filter((d) => !!d.hostname);
+		if (normalized.length === 0) return null;
+		let idx = -1;
+		for (let i = normalized.length - 1; i >= 0; i--) if (`${normalized[i].hostname}${normalized[i].port ? `:${normalized[i].port}` : ""}` === currentHost) {
+			idx = i;
+			break;
+		}
+		const total = normalized.length;
+		for (let step = 1; step <= total; step++) {
+			const candidate = normalized[((idx >= 0 ? idx : -1) + step) % total];
+			if (`${candidate.hostname}${candidate.port ? `:${candidate.port}` : ""}` !== currentHost) {
+				u.hostname = candidate.hostname;
+				if (candidate.port !== void 0 && candidate.port !== null && candidate.port !== "") u.port = candidate.port;
+				else u.port = "";
+				u.protocol = candidate.protocol || u.protocol;
+				return u.toString();
+			}
+		}
+		return null;
+	} catch {
+		return null;
+	}
 }
-__name(rewriteWithNextDomain, "rewriteWithNextDomain");
 function appendRetryCountQuery(url, retryIndex, key = "retryCount") {
-  try {
-    const u = new URL(url);
-    u.searchParams.delete(key);
-    u.searchParams.set(key, String(retryIndex));
-    return u.toString();
-  } catch {
-    return url;
-  }
+	try {
+		const u = new URL(url);
+		u.searchParams.delete(key);
+		u.searchParams.set(key, String(retryIndex));
+		return u.toString();
+	} catch {
+		return url;
+	}
 }
-__name(appendRetryCountQuery, "appendRetryCountQuery");
 function getRetryUrl(baseUrl, opts = {}) {
-  const { domains, addQuery, retryIndex = 0, queryKey = "retryCount" } = opts;
-  let cleanBaseUrl = baseUrl;
-  try {
-    const urlObj = new URL(baseUrl);
-    urlObj.searchParams.delete(queryKey);
-    cleanBaseUrl = urlObj.toString();
-  } catch {
-  }
-  let nextUrl = rewriteWithNextDomain(cleanBaseUrl, domains) ?? cleanBaseUrl;
-  if (retryIndex > 0 && addQuery) {
-    try {
-      const u = new URL(nextUrl);
-      const originalUrl = new URL(baseUrl);
-      originalUrl.searchParams.delete(queryKey);
-      const originalQuery = originalUrl.search.startsWith("?") ? originalUrl.search.slice(1) : originalUrl.search;
-      if (typeof addQuery === "function") {
-        const newQuery = addQuery({
-          times: retryIndex,
-          originalQuery
-        });
-        u.search = newQuery ? `?${newQuery.replace(/^\?/, "")}` : "";
-        nextUrl = u.toString();
-      } else if (addQuery === true) {
-        u.searchParams.delete(queryKey);
-        u.searchParams.set(queryKey, String(retryIndex));
-        nextUrl = u.toString();
-      }
-    } catch {
-      if (addQuery === true) {
-        nextUrl = appendRetryCountQuery(nextUrl, retryIndex, queryKey);
-      }
-    }
-  }
-  return nextUrl;
+	const { domains, addQuery, retryIndex = 0, queryKey = "retryCount" } = opts;
+	let cleanBaseUrl = baseUrl;
+	try {
+		const urlObj = new URL(baseUrl);
+		urlObj.searchParams.delete(queryKey);
+		cleanBaseUrl = urlObj.toString();
+	} catch {}
+	let nextUrl = rewriteWithNextDomain(cleanBaseUrl, domains) ?? cleanBaseUrl;
+	if (retryIndex > 0 && addQuery) try {
+		const u = new URL(nextUrl);
+		const originalUrl = new URL(baseUrl);
+		originalUrl.searchParams.delete(queryKey);
+		const originalQuery = originalUrl.search.startsWith("?") ? originalUrl.search.slice(1) : originalUrl.search;
+		if (typeof addQuery === "function") {
+			const newQuery = addQuery({
+				times: retryIndex,
+				originalQuery
+			});
+			u.search = newQuery ? `?${newQuery.replace(/^\?/, "")}` : "";
+			nextUrl = u.toString();
+		} else if (addQuery === true) {
+			u.searchParams.delete(queryKey);
+			u.searchParams.set(queryKey, String(retryIndex));
+			nextUrl = u.toString();
+		}
+	} catch {
+		if (addQuery === true) nextUrl = appendRetryCountQuery(nextUrl, retryIndex, queryKey);
+	}
+	return nextUrl;
 }
-__name(getRetryUrl, "getRetryUrl");
+/**
+* Extract domain/host info from a URL and combine it with path/query from another URL
+* This is useful for domain rotation while preserving original path and query parameters
+* @param domainUrl - URL containing the target domain/host
+* @param pathQueryUrl - URL containing the target path and query parameters
+* @returns Combined URL with domain from domainUrl and path/query from pathQueryUrl
+*/
 function combineUrlDomainWithPathQuery(domainUrl, pathQueryUrl) {
-  try {
-    const domainUrlObj = new URL(domainUrl);
-    const pathQueryUrlObj = new URL(pathQueryUrl);
-    domainUrlObj.pathname = pathQueryUrlObj.pathname;
-    domainUrlObj.search = pathQueryUrlObj.search;
-    return domainUrlObj.toString();
-  } catch {
-    return pathQueryUrl;
-  }
+	try {
+		const domainUrlObj = new URL(domainUrl);
+		const pathQueryUrlObj = new URL(pathQueryUrl);
+		domainUrlObj.pathname = pathQueryUrlObj.pathname;
+		domainUrlObj.search = pathQueryUrlObj.search;
+		return domainUrlObj.toString();
+	} catch {
+		return pathQueryUrl;
+	}
 }
-__name(combineUrlDomainWithPathQuery, "combineUrlDomainWithPathQuery");
 
-// packages/retry-plugin/src/fetch-retry.ts
+//#endregion
+//#region src/fetch-retry.ts
 function autoParseResponse(url, response) {
-  try {
-    const parsed = new URL(url);
-    if (parsed.pathname.endsWith(".js") || parsed.pathname.endsWith(".cjs") || parsed.pathname.endsWith(".mjs")) {
-      return response.text();
-    }
-    return response.json();
-  } catch (error) {
-    return response.json();
-  }
+	try {
+		const parsed = new URL(url);
+		if (parsed.pathname.endsWith(".js") || parsed.pathname.endsWith(".cjs") || parsed.pathname.endsWith(".mjs")) return response.text();
+		return response.json();
+	} catch (error) {
+		return response.json();
+	}
 }
-__name(autoParseResponse, "autoParseResponse");
 async function fetchRetry(params, lastRequestUrl, originalTotal) {
-  const {
-    url,
-    fetchOptions = {},
-    retryTimes = defaultRetries,
-    retryDelay = defaultRetryDelay,
-    // List of retry domains when resource loading fails. In the domains array, the first item is the default domain for static resources, and the subsequent items are backup domains. When a request to a domain fails, the system will find that domain in the array and replace it with the next domain in the array.
-    domains,
-    // Whether to add query parameters during resource retry to avoid being affected by browser and CDN cache. When set to true, retry=${times} will be added to the query, requesting in the order of retry=1, retry=2, retry=3.
-    addQuery,
-    onRetry,
-    onSuccess,
-    onError
-  } = params;
-  if (!url) {
-    throw new Error(`${PLUGIN_IDENTIFIER}: url is required in fetchWithRetry`);
-  }
-  const total = originalTotal ?? params.retryTimes ?? defaultRetries;
-  const isFirstAttempt = !lastRequestUrl;
-  let baseUrl = url;
-  if (!isFirstAttempt && lastRequestUrl) {
-    baseUrl = combineUrlDomainWithPathQuery(lastRequestUrl, url);
-  }
-  let requestUrl = baseUrl;
-  if (!isFirstAttempt) {
-    requestUrl = getRetryUrl(baseUrl, {
-      domains,
-      addQuery,
-      retryIndex: total - retryTimes,
-      queryKey: "retryCount"
-    });
-  }
-  try {
-    if (!isFirstAttempt && retryDelay > 0) {
-      await new Promise((resolve) => setTimeout(resolve, retryDelay));
-    }
-    const response = await fetch(requestUrl, fetchOptions);
-    const responseClone = response.clone();
-    if (!response.ok) {
-      throw new Error(`${PLUGIN_IDENTIFIER}: Request failed: ${response.status} ${response.statusText || ""} | url: ${requestUrl}`);
-    }
-    await autoParseResponse(requestUrl, responseClone).catch((error) => {
-      throw new Error(`${PLUGIN_IDENTIFIER}: JSON parse failed: ${error?.message || String(error)} | url: ${requestUrl}`);
-    });
-    if (!isFirstAttempt) {
-      onSuccess && requestUrl && onSuccess({
-        domains,
-        url: requestUrl,
-        tagName: "fetch"
-      });
-    }
-    return response;
-  } catch (error) {
-    if (retryTimes <= 0) {
-      const attemptedRetries = total - retryTimes;
-      if (!isFirstAttempt && attemptedRetries > 0) {
-        onError && onError({
-          domains,
-          url: requestUrl,
-          tagName: "fetch"
-        });
-        logger_default.log(`${PLUGIN_IDENTIFIER}: retry failed, no retries left for url: ${requestUrl}`);
-      }
-      throw new Error(`${RUNTIME_008}: ${PLUGIN_IDENTIFIER}: ${ERROR_ABANDONED} | url: ${requestUrl}`);
-    } else {
-      const nextIndex = total - retryTimes + 1;
-      const predictedBaseUrl = combineUrlDomainWithPathQuery(requestUrl, url);
-      const predictedNextUrl = getRetryUrl(predictedBaseUrl, {
-        domains,
-        addQuery,
-        retryIndex: nextIndex,
-        queryKey: "retryCount"
-      });
-      onRetry && onRetry({
-        times: nextIndex,
-        domains,
-        url: predictedNextUrl,
-        tagName: "fetch"
-      });
-      logger_default.log(`${PLUGIN_IDENTIFIER}: Trying again. Number of retries left: ${retryTimes - 1}`);
-      return await fetchRetry({
-        ...params,
-        retryTimes: retryTimes - 1
-      }, requestUrl, total);
-    }
-  }
+	const { url, fetchOptions = {}, retryTimes = defaultRetries, retryDelay = defaultRetryDelay, domains, addQuery, onRetry, onSuccess, onError } = params;
+	if (!url) throw new Error(`${PLUGIN_IDENTIFIER}: url is required in fetchWithRetry`);
+	const total = originalTotal ?? params.retryTimes ?? defaultRetries;
+	const isFirstAttempt = !lastRequestUrl;
+	let baseUrl = url;
+	if (!isFirstAttempt && lastRequestUrl) baseUrl = combineUrlDomainWithPathQuery(lastRequestUrl, url);
+	let requestUrl = baseUrl;
+	if (!isFirstAttempt) requestUrl = getRetryUrl(baseUrl, {
+		domains,
+		addQuery,
+		retryIndex: total - retryTimes,
+		queryKey: "retryCount"
+	});
+	try {
+		if (!isFirstAttempt && retryDelay > 0) await new Promise((resolve) => setTimeout(resolve, retryDelay));
+		const response = await fetch(requestUrl, fetchOptions);
+		const responseClone = response.clone();
+		if (!response.ok) throw new Error(`${PLUGIN_IDENTIFIER}: Request failed: ${response.status} ${response.statusText || ""} | url: ${requestUrl}`);
+		await autoParseResponse(requestUrl, responseClone).catch((error) => {
+			throw new Error(`${PLUGIN_IDENTIFIER}: JSON parse failed: ${error?.message || String(error)} | url: ${requestUrl}`);
+		});
+		if (!isFirstAttempt) onSuccess && requestUrl && onSuccess({
+			domains,
+			url: requestUrl,
+			tagName: "fetch"
+		});
+		return response;
+	} catch (error) {
+		if (retryTimes <= 0) {
+			const attemptedRetries = total - retryTimes;
+			if (!isFirstAttempt && attemptedRetries > 0) {
+				onError && onError({
+					domains,
+					url: requestUrl,
+					tagName: "fetch"
+				});
+				logger.log(`${PLUGIN_IDENTIFIER}: retry failed, no retries left for url: ${requestUrl}`);
+			}
+			throw new Error(`${RUNTIME_008}: ${PLUGIN_IDENTIFIER}: ${ERROR_ABANDONED} | url: ${requestUrl}`);
+		} else {
+			const nextIndex = total - retryTimes + 1;
+			const predictedNextUrl = getRetryUrl(combineUrlDomainWithPathQuery(requestUrl, url), {
+				domains,
+				addQuery,
+				retryIndex: nextIndex,
+				queryKey: "retryCount"
+			});
+			onRetry && onRetry({
+				times: nextIndex,
+				domains,
+				url: predictedNextUrl,
+				tagName: "fetch"
+			});
+			logger.log(`${PLUGIN_IDENTIFIER}: Trying again. Number of retries left: ${retryTimes - 1}`);
+			return await fetchRetry({
+				...params,
+				retryTimes: retryTimes - 1
+			}, requestUrl, total);
+		}
+	}
 }
-__name(fetchRetry, "fetchRetry");
 
-// packages/retry-plugin/src/script-retry.ts
-function scriptRetry({ retryOptions, retryFn, beforeExecuteRetry = /* @__PURE__ */ __name(() => {
-}, "beforeExecuteRetry") }) {
-  return async function(params) {
-    let retryWrapper;
-    let lastError;
-    let lastRequestUrl;
-    let originalUrl;
-    const { retryTimes = defaultRetries, retryDelay = defaultRetryDelay, domains, addQuery, onRetry, onSuccess, onError } = retryOptions || {};
-    let attempts = 0;
-    const maxAttempts = retryTimes;
-    while (attempts < maxAttempts) {
-      try {
-        beforeExecuteRetry();
-        if (retryDelay > 0 && attempts > 0) {
-          await new Promise((resolve) => setTimeout(resolve, retryDelay));
-        }
-        const retryIndex = attempts + 1;
-        retryWrapper = await retryFn({
-          ...params,
-          getEntryUrl: (url) => {
-            if (!originalUrl) {
-              originalUrl = url;
-            }
-            let baseUrl = originalUrl;
-            if (lastRequestUrl) {
-              baseUrl = combineUrlDomainWithPathQuery(lastRequestUrl, originalUrl);
-            }
-            const next = getRetryUrl(baseUrl, {
-              domains,
-              addQuery,
-              retryIndex,
-              queryKey: "retryCount"
-            });
-            onRetry && onRetry({
-              times: retryIndex,
-              domains,
-              url: next,
-              tagName: "script"
-            });
-            lastRequestUrl = next;
-            return next;
-          }
-        });
-        onSuccess && lastRequestUrl && onSuccess({
-          domains,
-          url: lastRequestUrl,
-          tagName: "script"
-        });
-        break;
-      } catch (error) {
-        lastError = error;
-        attempts++;
-        if (attempts >= maxAttempts) {
-          onError && lastRequestUrl && onError({
-            domains,
-            url: lastRequestUrl,
-            tagName: "script"
-          });
-          throw new Error(`${PLUGIN_IDENTIFIER}: ${ERROR_ABANDONED} | url: ${lastRequestUrl || "unknown"}`);
-        }
-      }
-    }
-    return retryWrapper;
-  };
+//#endregion
+//#region src/script-retry.ts
+function scriptRetry({ retryOptions, retryFn, beforeExecuteRetry = () => {} }) {
+	return async function(params) {
+		let retryWrapper;
+		let lastRequestUrl;
+		let originalUrl;
+		const { retryTimes = defaultRetries, retryDelay = defaultRetryDelay, domains, addQuery, onRetry, onSuccess, onError } = retryOptions || {};
+		let attempts = 0;
+		const maxAttempts = retryTimes;
+		while (attempts < maxAttempts) try {
+			beforeExecuteRetry();
+			if (retryDelay > 0 && attempts > 0) await new Promise((resolve) => setTimeout(resolve, retryDelay));
+			const retryIndex = attempts + 1;
+			retryWrapper = await retryFn({
+				...params,
+				getEntryUrl: (url) => {
+					if (!originalUrl) originalUrl = url;
+					let baseUrl = originalUrl;
+					if (lastRequestUrl) baseUrl = combineUrlDomainWithPathQuery(lastRequestUrl, originalUrl);
+					const next = getRetryUrl(baseUrl, {
+						domains,
+						addQuery,
+						retryIndex,
+						queryKey: "retryCount"
+					});
+					onRetry && onRetry({
+						times: retryIndex,
+						domains,
+						url: next,
+						tagName: "script"
+					});
+					lastRequestUrl = next;
+					return next;
+				}
+			});
+			onSuccess && lastRequestUrl && onSuccess({
+				domains,
+				url: lastRequestUrl,
+				tagName: "script"
+			});
+			break;
+		} catch (error) {
+			attempts++;
+			if (attempts >= maxAttempts) {
+				onError && lastRequestUrl && onError({
+					domains,
+					url: lastRequestUrl,
+					tagName: "script"
+				});
+				throw new Error(`${PLUGIN_IDENTIFIER}: ${ERROR_ABANDONED} | url: ${lastRequestUrl || "unknown"}`);
+			}
+		}
+		return retryWrapper;
+	};
 }
-__name(scriptRetry, "scriptRetry");
 
-// packages/retry-plugin/src/index.ts
-var RetryPlugin = /* @__PURE__ */ __name((params) => {
-  if (params?.fetch || params?.script) {
-    logger_default.warn(`${PLUGIN_IDENTIFIER}: params is ${params}, fetch or script config is deprecated, please use the new config style. See docs: https://module-federation.io/plugin/plugins/retry-plugin.html`);
-  }
-  const { fetchOptions = {}, retryTimes = defaultRetries, successTimes = 0, retryDelay = defaultRetryDelay, domains = [], manifestDomains = [], addQuery, onRetry, onSuccess, onError } = params || {};
-  return {
-    name: "retry-plugin",
-    async fetch(manifestUrl, options) {
-      return fetchRetry({
-        url: manifestUrl,
-        fetchOptions: {
-          ...options,
-          ...fetchOptions
-        },
-        domains: manifestDomains || domains,
-        addQuery,
-        onRetry,
-        onSuccess,
-        onError,
-        retryTimes,
-        successTimes,
-        retryDelay
-      });
-    },
-    async loadEntryError({ getRemoteEntry, origin, remoteInfo, remoteEntryExports, globalLoading, uniqueKey }) {
-      const beforeExecuteRetry = /* @__PURE__ */ __name(() => {
-        delete globalLoading[uniqueKey];
-      }, "beforeExecuteRetry");
-      const getRemoteEntryRetry = scriptRetry({
-        retryOptions: {
-          retryTimes,
-          retryDelay,
-          domains,
-          addQuery,
-          onRetry,
-          onSuccess,
-          onError
-        },
-        retryFn: getRemoteEntry,
-        beforeExecuteRetry
-      });
-      const result = await getRemoteEntryRetry({
-        origin,
-        remoteInfo,
-        remoteEntryExports
-      });
-      return result;
-    }
-  };
-}, "RetryPlugin");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  RetryPlugin,
-  appendRetryCountQuery,
-  combineUrlDomainWithPathQuery,
-  getRetryUrl,
-  rewriteWithNextDomain
-});
+//#endregion
+//#region src/index.ts
+const RetryPlugin = (params) => {
+	if (params?.fetch || params?.script) logger.warn(`${PLUGIN_IDENTIFIER}: params is ${params}, fetch or script config is deprecated, please use the new config style. See docs: https://module-federation.io/plugin/plugins/retry-plugin.html`);
+	const { fetchOptions = {}, retryTimes = defaultRetries, successTimes = 0, retryDelay = defaultRetryDelay, domains = [], manifestDomains = [], addQuery, onRetry, onSuccess, onError } = params || {};
+	return {
+		name: "retry-plugin",
+		async fetch(manifestUrl, options) {
+			return fetchRetry({
+				url: manifestUrl,
+				fetchOptions: {
+					...options,
+					...fetchOptions
+				},
+				domains: manifestDomains || domains,
+				addQuery,
+				onRetry,
+				onSuccess,
+				onError,
+				retryTimes,
+				successTimes,
+				retryDelay
+			});
+		},
+		async loadEntryError({ getRemoteEntry, origin, remoteInfo, remoteEntryExports, globalLoading, uniqueKey }) {
+			const beforeExecuteRetry = () => {
+				delete globalLoading[uniqueKey];
+			};
+			return await scriptRetry({
+				retryOptions: {
+					retryTimes,
+					retryDelay,
+					domains,
+					addQuery,
+					onRetry,
+					onSuccess,
+					onError
+				},
+				retryFn: getRemoteEntry,
+				beforeExecuteRetry
+			})({
+				origin,
+				remoteInfo,
+				remoteEntryExports
+			});
+		}
+	};
+};
+
+//#endregion
+exports.RetryPlugin = RetryPlugin;
+exports.appendRetryCountQuery = appendRetryCountQuery;
+exports.combineUrlDomainWithPathQuery = combineUrlDomainWithPathQuery;
+exports.getRetryUrl = getRetryUrl;
+exports.rewriteWithNextDomain = rewriteWithNextDomain;