@rsbuild/plugin-assets-retry 1.0.1 → 1.0.3

package/dist/index.js

@@ -1,223 +1,372 @@
-import { createRequire } from 'module';
-var require = createRequire(import.meta['url']);
-
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
+import { fileURLToPath as __webpack_fileURLToPath__ } from "url";
+import { dirname as __webpack_dirname__ } from "path";
+import * as __WEBPACK_EXTERNAL_MODULE_crypto__ from "crypto";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE__rsbuild_core__ from "@rsbuild/core";
+var __webpack_modules__ = {
+    "../../node_modules/.pnpm/randombytes@2.1.0/node_modules/randombytes/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        module.exports = __webpack_require__("crypto")/* .randomBytes */ .randomBytes;
+    },
+    "../../node_modules/.pnpm/serialize-javascript@6.0.2/node_modules/serialize-javascript/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        /*
+Copyright (c) 2014, Yahoo! Inc. All rights reserved.
+Copyrights licensed under the New BSD License.
+See the accompanying LICENSE file for terms.
+*/ var randomBytes = __webpack_require__("../../node_modules/.pnpm/randombytes@2.1.0/node_modules/randombytes/index.js");
+        // Generate an internal UID to make the regexp pattern harder to guess.
+        var UID_LENGTH = 16;
+        var UID = generateUID();
+        var PLACE_HOLDER_REGEXP = new RegExp('(\\\\)?"@__(F|R|D|M|S|A|U|I|B|L)-' + UID + '-(\\d+)__@"', 'g');
+        var IS_NATIVE_CODE_REGEXP = /\{\s*\[native code\]\s*\}/g;
+        var IS_PURE_FUNCTION = /function.*?\(/;
+        var IS_ARROW_FUNCTION = /.*?=>.*?/;
+        var UNSAFE_CHARS_REGEXP = /[<>\/\u2028\u2029]/g;
+        var RESERVED_SYMBOLS = [
+            '*',
+            'async'
+        ];
+        // Mapping of unsafe HTML and invalid JavaScript line terminator chars to their
+        // Unicode char counterparts which are safe to use in JavaScript strings.
+        var ESCAPED_CHARS = {
+            '<': '\\u003C',
+            '>': '\\u003E',
+            '/': '\\u002F',
+            '\u2028': '\\u2028',
+            '\u2029': '\\u2029'
+        };
+        function escapeUnsafeChars(unsafeChar) {
+            return ESCAPED_CHARS[unsafeChar];
+        }
+        function generateUID() {
+            var bytes = randomBytes(UID_LENGTH);
+            var result = '';
+            for(var i = 0; i < UID_LENGTH; ++i)result += bytes[i].toString(16);
+            return result;
+        }
+        function deleteFunctions(obj) {
+            var functionKeys = [];
+            for(var key in obj)if ("function" == typeof obj[key]) functionKeys.push(key);
+            for(var i = 0; i < functionKeys.length; i++)delete obj[functionKeys[i]];
+        }
+        module.exports = function serialize(obj, options) {
+            options || (options = {});
+            // Backwards-compatibility for `space` as the second argument.
+            if ('number' == typeof options || 'string' == typeof options) options = {
+                space: options
+            };
+            var functions = [];
+            var regexps = [];
+            var dates = [];
+            var maps = [];
+            var sets = [];
+            var arrays = [];
+            var undefs = [];
+            var infinities = [];
+            var bigInts = [];
+            var urls = [];
+            // Returns placeholders for functions and regexps (identified by index)
+            // which are later replaced by their string representation.
+            function replacer(key, value) {
+                // For nested function
+                if (options.ignoreFunction) deleteFunctions(value);
+                if (!value && void 0 !== value && value !== BigInt(0)) return value;
+                // If the value is an object w/ a toJSON method, toJSON is called before
+                // the replacer runs, so we use this[key] to get the non-toJSONed value.
+                var origValue = this[key];
+                var type = typeof origValue;
+                if ('object' === type) {
+                    if (origValue instanceof RegExp) return '@__R-' + UID + '-' + (regexps.push(origValue) - 1) + '__@';
+                    if (origValue instanceof Date) return '@__D-' + UID + '-' + (dates.push(origValue) - 1) + '__@';
+                    if (origValue instanceof Map) return '@__M-' + UID + '-' + (maps.push(origValue) - 1) + '__@';
+                    if (origValue instanceof Set) return '@__S-' + UID + '-' + (sets.push(origValue) - 1) + '__@';
+                    if (origValue instanceof Array) {
+                        var isSparse = origValue.filter(function() {
+                            return true;
+                        }).length !== origValue.length;
+                        if (isSparse) return '@__A-' + UID + '-' + (arrays.push(origValue) - 1) + '__@';
+                    }
+                    if (origValue instanceof URL) return '@__L-' + UID + '-' + (urls.push(origValue) - 1) + '__@';
+                }
+                if ('function' === type) return '@__F-' + UID + '-' + (functions.push(origValue) - 1) + '__@';
+                if ('undefined' === type) return '@__U-' + UID + '-' + (undefs.push(origValue) - 1) + '__@';
+                if ('number' === type && !isNaN(origValue) && !isFinite(origValue)) return '@__I-' + UID + '-' + (infinities.push(origValue) - 1) + '__@';
+                if ('bigint' === type) return '@__B-' + UID + '-' + (bigInts.push(origValue) - 1) + '__@';
+                return value;
+            }
+            function serializeFunc(fn) {
+                var serializedFn = fn.toString();
+                if (IS_NATIVE_CODE_REGEXP.test(serializedFn)) throw new TypeError('Serializing native function: ' + fn.name);
+                // pure functions, example: {key: function() {}}
+                if (IS_PURE_FUNCTION.test(serializedFn)) return serializedFn;
+                // arrow functions, example: arg1 => arg1+5
+                if (IS_ARROW_FUNCTION.test(serializedFn)) return serializedFn;
+                var argsStartsAt = serializedFn.indexOf('(');
+                var def = serializedFn.substr(0, argsStartsAt).trim().split(' ').filter(function(val) {
+                    return val.length > 0;
+                });
+                var nonReservedSymbols = def.filter(function(val) {
+                    return -1 === RESERVED_SYMBOLS.indexOf(val);
+                });
+                // enhanced literal objects, example: {key() {}}
+                if (nonReservedSymbols.length > 0) return (def.indexOf('async') > -1 ? 'async ' : '') + 'function' + (def.join('').indexOf('*') > -1 ? '*' : '') + serializedFn.substr(argsStartsAt);
+                // arrow functions
+                return serializedFn;
+            }
+            // Check if the parameter is function
+            if (options.ignoreFunction && "function" == typeof obj) obj = void 0;
+            // Protects against `JSON.stringify()` returning `undefined`, by serializing
+            // to the literal string: "undefined".
+            if (void 0 === obj) return String(obj);
+            var str;
+            // Creates a JSON string representation of the value.
+            // NOTE: Node 0.12 goes into slow mode with extra JSON.stringify() args.
+            str = options.isJSON && !options.space ? JSON.stringify(obj) : JSON.stringify(obj, options.isJSON ? null : replacer, options.space);
+            // Protects against `JSON.stringify()` returning `undefined`, by serializing
+            // to the literal string: "undefined".
+            if ('string' != typeof str) return String(str);
+            // Replace unsafe HTML and invalid JavaScript line terminator chars with
+            // their safe Unicode char counterpart. This _must_ happen before the
+            // regexps and functions are serialized and added back to the string.
+            if (true !== options.unsafe) str = str.replace(UNSAFE_CHARS_REGEXP, escapeUnsafeChars);
+            if (0 === functions.length && 0 === regexps.length && 0 === dates.length && 0 === maps.length && 0 === sets.length && 0 === arrays.length && 0 === undefs.length && 0 === infinities.length && 0 === bigInts.length && 0 === urls.length) return str;
+            // Replaces all occurrences of function, regexp, date, map and set placeholders in the
+            // JSON string with their string representations. If the original value can
+            // not be found, then `undefined` is used.
+            return str.replace(PLACE_HOLDER_REGEXP, function(match, backSlash, type, valueIndex) {
+                // The placeholder may not be preceded by a backslash. This is to prevent
+                // replacing things like `"a\"@__R-<UID>-0__@"` and thus outputting
+                // invalid JS.
+                if (backSlash) return match;
+                if ('D' === type) return "new Date(\"" + dates[valueIndex].toISOString() + "\")";
+                if ('R' === type) return "new RegExp(" + serialize(regexps[valueIndex].source) + ", \"" + regexps[valueIndex].flags + "\")";
+                if ('M' === type) return "new Map(" + serialize(Array.from(maps[valueIndex].entries()), options) + ")";
+                if ('S' === type) return "new Set(" + serialize(Array.from(sets[valueIndex].values()), options) + ")";
+                if ('A' === type) return "Array.prototype.slice.call(" + serialize(Object.assign({
+                    length: arrays[valueIndex].length
+                }, arrays[valueIndex]), options) + ")";
+                if ('U' === type) return 'undefined';
+                if ('I' === type) return infinities[valueIndex];
+                if ('B' === type) return "BigInt(\"" + bigInts[valueIndex] + "\")";
+                if ('L' === type) return "new URL(" + serialize(urls[valueIndex].toString(), options) + ")";
+                var fn = functions[valueIndex];
+                return serializeFunc(fn);
+            });
+        };
+    },
+    crypto: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_crypto__;
+    }
 };
-
-// ../../node_modules/.pnpm/@modern-js+module-tools@2.59.0_typescript@5.5.2/node_modules/@modern-js/module-tools/shims/esm.js
-import path from "path";
-import { fileURLToPath } from "url";
-var getFilename, getDirname, __dirname;
-var init_esm = __esm({
-  "../../node_modules/.pnpm/@modern-js+module-tools@2.59.0_typescript@5.5.2/node_modules/@modern-js/module-tools/shims/esm.js"() {
-    "use strict";
-    getFilename = () => fileURLToPath(import.meta.url);
-    getDirname = () => path.dirname(getFilename());
-    __dirname = /* @__PURE__ */ getDirname();
-  }
-});
-
-// src/AsyncChunkRetryPlugin.ts
-var AsyncChunkRetryPlugin_exports = {};
-__export(AsyncChunkRetryPlugin_exports, {
-  AsyncChunkRetryPlugin: () => AsyncChunkRetryPlugin
-});
-import fs from "fs";
-import path2 from "path";
-import { rspack } from "@rsbuild/core";
-import serialize from "serialize-javascript";
+/************************************************************************/ // The module cache
+var __webpack_module_cache__ = {};
+// The require function
+function __webpack_require__(moduleId) {
+    // Check if module is in cache
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    // Create a new module (and put it into the cache)
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    // Execute the module function
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    // Return the exports of the module
+    return module.exports;
+}
+/************************************************************************/ // webpack/runtime/compat_get_default_export
+(()=>{
+    // getDefaultExport function for compatibility with non-harmony modules
+    __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module['default'];
+        } : function() {
+            return module;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+// webpack/runtime/define_property_getters
+(()=>{
+    __webpack_require__.d = function(exports, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+// webpack/runtime/has_own_property
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})(); /************************************************************************/ 
+// EXTERNAL MODULE: ../../node_modules/.pnpm/serialize-javascript@6.0.2/node_modules/serialize-javascript/index.js
+var serialize_javascript = __webpack_require__("../../node_modules/.pnpm/serialize-javascript@6.0.2/node_modules/serialize-javascript/index.js");
+var serialize_javascript_default = /*#__PURE__*/ __webpack_require__.n(serialize_javascript);
+var AsyncChunkRetryPlugin_dirname = __webpack_dirname__(__webpack_fileURLToPath__(import.meta.url));
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+// https://github.com/web-infra-dev/rspack/pull/5370
 function appendWebpackScript(module, appendSource) {
-  try {
-    const originSource = module.getGeneratedCode();
-    module.getGeneratedCode = () => `${originSource}
-${appendSource}`;
-  } catch (err) {
-    console.error("Failed to modify Webpack RuntimeModule");
-    throw err;
-  }
+    try {
+        const originSource = module.getGeneratedCode();
+        module.getGeneratedCode = ()=>`${originSource}\n${appendSource}`;
+    } catch (err) {
+        console.error('Failed to modify Webpack RuntimeModule');
+        throw err;
+    }
 }
 function appendRspackScript(module, appendSource) {
-  try {
-    const source = module.source.source.toString();
-    module.source.source = Buffer.from(`${source}
-${appendSource}`, "utf-8");
-  } catch (err) {
-    console.error("Failed to modify Rspack RuntimeModule");
-    throw err;
-  }
+    try {
+        const source = module.source.source.toString();
+        module.source.source = Buffer.from(`${source}\n${appendSource}`, 'utf-8');
+    } catch (err) {
+        console.error('Failed to modify Rspack RuntimeModule');
+        throw err;
+    }
 }
 function pick(obj, keys) {
-  return keys.reduce(
-    (ret, key) => {
-      if (obj[key] !== void 0) {
-        ret[key] = obj[key];
-      }
-      return ret;
-    },
-    {}
-  );
+    return keys.reduce((ret, key)=>{
+        if (void 0 !== obj[key]) ret[key] = obj[key];
+        return ret;
+    }, {});
 }
-var AsyncChunkRetryPlugin;
-var init_AsyncChunkRetryPlugin = __esm({
-  "src/AsyncChunkRetryPlugin.ts"() {
-    "use strict";
-    init_esm();
-    AsyncChunkRetryPlugin = class {
-      constructor(options) {
-        __publicField(this, "name", "ASYNC_CHUNK_RETRY_PLUGIN");
-        __publicField(this, "options");
-        __publicField(this, "runtimeOptions");
+class AsyncChunkRetryPlugin {
+    getRawRuntimeRetryCode() {
+        const { RuntimeGlobals } = __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack;
+        const filename = 'asyncChunkRetry';
+        const runtimeFilePath = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(AsyncChunkRetryPlugin_dirname, 'runtime', this.options.minify ? `${filename}.min.js` : `${filename}.js`);
+        const rawText = __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].readFileSync(runtimeFilePath, 'utf-8');
+        return rawText.replaceAll('__RUNTIME_GLOBALS_REQUIRE__', RuntimeGlobals.require).replaceAll('__RUNTIME_GLOBALS_ENSURE_CHUNK__', RuntimeGlobals.ensureChunk).replaceAll('__RUNTIME_GLOBALS_GET_CHUNK_SCRIPT_FILENAME__', RuntimeGlobals.getChunkScriptFilename).replaceAll('__RUNTIME_GLOBALS_GET_CSS_FILENAME__', RuntimeGlobals.getChunkCssFilename).replaceAll('__RUNTIME_GLOBALS_GET_MINI_CSS_EXTRACT_FILENAME__', '__webpack_require__.miniCssF').replaceAll('__RUNTIME_GLOBALS_PUBLIC_PATH__', RuntimeGlobals.publicPath).replaceAll('__RUNTIME_GLOBALS_LOAD_SCRIPT__', RuntimeGlobals.loadScript).replaceAll('__RETRY_OPTIONS__', serialize_javascript_default()(this.runtimeOptions));
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(this.name, (compilation)=>{
+            compilation.hooks.runtimeModule.tap(this.name, (module)=>{
+                var _module_constructor;
+                const { isRspack } = this.options;
+                const constructorName = isRspack ? module.constructorName : null === (_module_constructor = module.constructor) || void 0 === _module_constructor ? void 0 : _module_constructor.name;
+                const isPublicPathModule = 'publicPath' === module.name || 'PublicPathRuntimeModule' === constructorName || 'AutoPublicPathRuntimeModule' === constructorName;
+                if (!isPublicPathModule) return;
+                const runtimeCode = this.getRawRuntimeRetryCode();
+                // Rspack currently does not have module.addRuntimeModule on the js side,
+                // so we insert our runtime code after PublicPathRuntimeModule or AutoPublicPathRuntimeModule.
+                if (isRspack) appendRspackScript(module, runtimeCode);
+                else appendWebpackScript(module, runtimeCode);
+            });
+        });
+    }
+    constructor(options){
+        _define_property(this, "name", 'ASYNC_CHUNK_RETRY_PLUGIN');
+        _define_property(this, "options", void 0);
+        _define_property(this, "runtimeOptions", void 0);
         this.options = options;
         this.runtimeOptions = pick(options, [
-          "domain",
-          "max",
-          "onRetry",
-          "onSuccess",
-          "onFail",
-          "addQuery",
-          "test"
+            'domain',
+            'max',
+            'onRetry',
+            'onSuccess',
+            'onFail',
+            'addQuery',
+            'test'
         ]);
-      }
-      getRawRuntimeRetryCode() {
-        const { RuntimeGlobals } = rspack;
-        const filename = "asyncChunkRetry";
-        const runtimeFilePath = path2.join(
-          __dirname,
-          "runtime",
-          this.options.minify ? `${filename}.min.js` : `${filename}.js`
-        );
-        const rawText = fs.readFileSync(runtimeFilePath, "utf-8");
-        return rawText.replaceAll("__RUNTIME_GLOBALS_REQUIRE__", RuntimeGlobals.require).replaceAll(
-          "__RUNTIME_GLOBALS_ENSURE_CHUNK__",
-          RuntimeGlobals.ensureChunk
-        ).replaceAll(
-          "__RUNTIME_GLOBALS_GET_CHUNK_SCRIPT_FILENAME__",
-          RuntimeGlobals.getChunkScriptFilename
-        ).replaceAll(
-          "__RUNTIME_GLOBALS_GET_CSS_FILENAME__",
-          RuntimeGlobals.getChunkCssFilename
-        ).replaceAll(
-          "__RUNTIME_GLOBALS_GET_MINI_CSS_EXTRACT_FILENAME__",
-          "__webpack_require__.miniCssF"
-        ).replaceAll("__RUNTIME_GLOBALS_PUBLIC_PATH__", RuntimeGlobals.publicPath).replaceAll("__RUNTIME_GLOBALS_LOAD_SCRIPT__", RuntimeGlobals.loadScript).replaceAll("__RETRY_OPTIONS__", serialize(this.runtimeOptions));
-      }
-      apply(compiler) {
-        compiler.hooks.thisCompilation.tap(this.name, (compilation) => {
-          compilation.hooks.runtimeModule.tap(this.name, (module) => {
-            const { isRspack } = this.options;
-            const constructorName = isRspack ? module.constructorName : module.constructor?.name;
-            const isPublicPathModule = module.name === "publicPath" || constructorName === "PublicPathRuntimeModule" || constructorName === "AutoPublicPathRuntimeModule";
-            if (!isPublicPathModule) {
-              return;
-            }
-            const runtimeCode = this.getRawRuntimeRetryCode();
-            if (isRspack) {
-              appendRspackScript(module, runtimeCode);
-            } else {
-              appendWebpackScript(module, runtimeCode);
-            }
-          });
-        });
-      }
-    };
-  }
-});
-
-// src/index.ts
-init_esm();
-import fs2 from "fs";
-import path3 from "path";
-import { ensureAssetPrefix } from "@rsbuild/core";
-var PLUGIN_ASSETS_RETRY_NAME = "rsbuild:assets-retry";
+    }
+}
+var src_dirname = __webpack_dirname__(__webpack_fileURLToPath__(import.meta.url));
+const PLUGIN_ASSETS_RETRY_NAME = 'rsbuild:assets-retry';
 async function getRetryCode(options) {
-  const { default: serialize2 } = await import("serialize-javascript");
-  const filename = "initialChunkRetry";
-  const { minify, inlineScript: _, ...restOptions } = options;
-  const runtimeFilePath = path3.join(
-    __dirname,
-    "runtime",
-    minify ? `${filename}.min.js` : `${filename}.js`
-  );
-  const runtimeCode = await fs2.promises.readFile(runtimeFilePath, "utf-8");
-  return `(function(){${runtimeCode};init(${serialize2(restOptions)});})()`;
+    const filename = 'initialChunkRetry';
+    const { minify, inlineScript: _, ...restOptions } = options;
+    const runtimeFilePath = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(src_dirname, 'runtime', minify ? `${filename}.min.js` : `${filename}.js`);
+    const runtimeCode = await __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].promises.readFile(runtimeFilePath, 'utf-8');
+    return `(function(){${runtimeCode};init(${serialize_javascript_default()(restOptions)});})()`;
 }
-var pluginAssetsRetry = (userOptions = {}) => ({
-  name: PLUGIN_ASSETS_RETRY_NAME,
-  setup(api) {
-    const { inlineScript = true } = userOptions;
-    const getScriptPath = (environment) => {
-      const distDir = environment.config.output.distPath.js;
-      return path3.posix.join(distDir, `assets-retry.${"1.0.1"}.js`);
-    };
-    const formatOptions = (config) => {
-      const options = { ...userOptions };
-      if (options.crossOrigin === void 0) {
-        options.crossOrigin = config.html.crossorigin;
-      }
-      if (options.minify === void 0) {
-        const minify = typeof config.output.minify === "boolean" ? config.output.minify : config.output.minify?.js;
-        options.minify = minify && config.mode === "production";
-      }
-      return options;
-    };
-    if (inlineScript) {
-      api.modifyHTMLTags(async ({ headTags, bodyTags }, { environment }) => {
-        const code = await getRetryCode(formatOptions(environment.config));
-        headTags.unshift({
-          tag: "script",
-          attrs: {},
-          children: code
-        });
-        return { headTags, bodyTags };
-      });
-    } else {
-      api.modifyHTMLTags(
-        async ({ headTags, bodyTags }, { assetPrefix, environment }) => {
-          const scriptPath = getScriptPath(environment);
-          const url = ensureAssetPrefix(scriptPath, assetPrefix);
-          headTags.unshift({
-            tag: "script",
-            attrs: {
-              src: url
+const pluginAssetsRetry = function() {
+    let userOptions = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
+    return {
+        name: PLUGIN_ASSETS_RETRY_NAME,
+        setup (api) {
+            const { inlineScript = true } = userOptions;
+            const getScriptPath = (environment)=>{
+                const distDir = environment.config.output.distPath.js;
+                return __WEBPACK_EXTERNAL_MODULE_node_path__["default"].posix.join(distDir, "assets-retry.1-0-3.js");
+            };
+            const formatOptions = (config)=>{
+                const options = {
+                    ...userOptions
+                };
+                // options.crossOrigin should be same as html.crossorigin by default
+                if (void 0 === options.crossOrigin) options.crossOrigin = config.html.crossorigin;
+                if (void 0 === options.minify) {
+                    var _config_output_minify;
+                    const minify = 'boolean' == typeof config.output.minify ? config.output.minify : null === (_config_output_minify = config.output.minify) || void 0 === _config_output_minify ? void 0 : _config_output_minify.js;
+                    options.minify = minify && 'production' === config.mode;
+                }
+                return options;
+            };
+            if (inlineScript) api.modifyHTMLTags(async (param, param1)=>{
+                let { headTags, bodyTags } = param, { environment } = param1;
+                const code = await getRetryCode(formatOptions(environment.config));
+                headTags.unshift({
+                    tag: 'script',
+                    attrs: {},
+                    children: code
+                });
+                return {
+                    headTags,
+                    bodyTags
+                };
+            });
+            else {
+                api.modifyHTMLTags(async (param, param1)=>{
+                    let { headTags, bodyTags } = param, { assetPrefix, environment } = param1;
+                    const scriptPath = getScriptPath(environment);
+                    const url = (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.ensureAssetPrefix)(scriptPath, assetPrefix);
+                    headTags.unshift({
+                        tag: 'script',
+                        attrs: {
+                            src: url
+                        }
+                    });
+                    return {
+                        headTags,
+                        bodyTags
+                    };
+                });
+                api.processAssets({
+                    stage: 'additional'
+                }, async (param)=>{
+                    let { sources, compilation, environment } = param;
+                    const scriptPath = getScriptPath(environment);
+                    const code = await getRetryCode(formatOptions(environment.config));
+                    compilation.emitAsset(scriptPath, new sources.RawSource(code));
+                });
             }
-          });
-          return { headTags, bodyTags };
+            api.modifyBundlerChain(async (chain, param)=>{
+                let { environment } = param;
+                const { config, htmlPaths } = environment;
+                if (!userOptions || 0 === Object.keys(htmlPaths).length) return;
+                const options = formatOptions(config);
+                const isRspack = 'rspack' === api.context.bundlerType;
+                chain.plugin('async-chunk-retry').use(AsyncChunkRetryPlugin, [
+                    {
+                        ...options,
+                        isRspack
+                    }
+                ]);
+            });
         }
-      );
-      api.processAssets(
-        { stage: "additional" },
-        async ({ sources, compilation, environment }) => {
-          const scriptPath = getScriptPath(environment);
-          const code = await getRetryCode(formatOptions(environment.config));
-          compilation.emitAsset(scriptPath, new sources.RawSource(code));
-        }
-      );
-    }
-    api.modifyBundlerChain(async (chain, { environment }) => {
-      const { config, htmlPaths } = environment;
-      if (!userOptions || Object.keys(htmlPaths).length === 0) {
-        return;
-      }
-      const { AsyncChunkRetryPlugin: AsyncChunkRetryPlugin2 } = await Promise.resolve().then(() => (init_AsyncChunkRetryPlugin(), AsyncChunkRetryPlugin_exports));
-      const options = formatOptions(config);
-      const isRspack = api.context.bundlerType === "rspack";
-      chain.plugin("async-chunk-retry").use(AsyncChunkRetryPlugin2, [{ ...options, isRspack }]);
-    });
-  }
-});
-export {
-  PLUGIN_ASSETS_RETRY_NAME,
-  pluginAssetsRetry
+    };
 };
+export { PLUGIN_ASSETS_RETRY_NAME, pluginAssetsRetry };

package/{dist-types → dist}/runtime/asyncChunkRetry.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeRetryOptions } from '../types';
+import type { RuntimeRetryOptions } from '../types.js';
 type ChunkId = string;
 type ChunkFilename = string;
 type ChunkSrcUrl = string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/plugin-assets-retry",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Assets retry plugin for Rsbuild",
   "homepage": "https://rsbuild.dev",
   "repository": {
@@ -12,28 +12,25 @@
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist-types/index.d.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     }
   },
   "main": "./dist/index.cjs",
-  "types": "./dist-types/index.d.ts",
+  "types": "./dist/index.d.ts",
   "files": [
-    "dist",
-    "dist-types"
+    "dist"
   ],
-  "dependencies": {
-    "serialize-javascript": "^6.0.2"
-  },
   "devDependencies": {
-    "@babel/core": "^7.25.2",
-    "@babel/preset-env": "^7.25.4",
-    "@babel/preset-typescript": "^7.24.7",
+    "@babel/core": "^7.25.8",
+    "@babel/preset-env": "^7.25.8",
+    "@babel/preset-typescript": "^7.25.7",
     "@types/serialize-javascript": "^5.0.4",
-    "terser": "5.31.6",
-    "typescript": "^5.5.2",
-    "@rsbuild/core": "1.0.1"
+    "serialize-javascript": "^6.0.2",
+    "terser": "5.35.0",
+    "typescript": "^5.6.3",
+    "@rsbuild/core": "1.0.15"
   },
   "peerDependencies": {
     "@rsbuild/core": "1.x || ^1.0.1-rc.0"
@@ -44,7 +41,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "modern build && node scripts/postCompile.mjs",
-    "dev": "modern build --watch"
+    "build": "rslib build && node scripts/postCompile.mjs",
+    "dev": "rslib build --watch"
   }
 }

package/dist-types/package.json

@@ -1 +0,0 @@
-{"//":"This file is for making TypeScript work with moduleResolution node16+.","version":"1.0.0"}