@modern-js/server 2.69.4 → 3.0.0-alpha.0

package/dist/cjs/helpers/index.js

@@ -1,112 +1,173 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var helpers_exports = {};
-__export(helpers_exports, {
-  startWatcher: () => startWatcher
-});
-module.exports = __toCommonJS(helpers_exports);
-var import_path = __toESM(require("path"));
-var import_server_core = require("@modern-js/server-core");
-var import_utils = require("@modern-js/utils");
-var import_watcher = __toESM(require("../dev-tools/watcher"));
-var import_mock = require("./mock");
-var import_utils2 = require("./utils");
-__reExport(helpers_exports, require("./repack"), module.exports);
-__reExport(helpers_exports, require("./devOptions"), module.exports);
-__reExport(helpers_exports, require("./fileReader"), module.exports);
-__reExport(helpers_exports, require("./mock"), module.exports);
-async function onServerChange({ pwd, filepath, event, server }) {
-  const { mock } = import_server_core.AGGRED_DIR;
-  const mockPath = import_path.default.normalize(import_path.default.join(pwd, mock));
-  const { hooks } = server;
-  if (filepath.startsWith(mockPath)) {
-    await (0, import_mock.initOrUpdateMockMiddlewares)(pwd);
-    import_utils.logger.info("Finish update the mock handlers");
-  } else {
-    try {
-      const fileChangeEvent = {
-        type: "file-change",
-        payload: [
-          {
-            filename: filepath,
-            event
-          }
-        ]
-      };
-      await hooks.onReset.call({
-        event: fileChangeEvent
-      });
-      (0, import_utils2.debug)(`Finish reload server, trigger by ${filepath} ${event}`);
-    } catch (e) {
-      import_utils.logger.error(e);
+var __webpack_modules__ = {
+    "../dev-tools/watcher" (module) {
+        module.exports = require("../dev-tools/watcher/index.js");
+    },
+    "./devOptions" (module) {
+        module.exports = require("./devOptions.js");
+    },
+    "./fileReader" (module) {
+        module.exports = require("./fileReader.js");
+    },
+    "./mock" (module) {
+        module.exports = require("./mock.js");
+    },
+    "./repack" (module) {
+        module.exports = require("./repack.js");
+    },
+    "./utils" (module) {
+        module.exports = require("./utils.js");
+    },
+    "@modern-js/server-core" (module) {
+        module.exports = require("@modern-js/server-core");
+    },
+    "@modern-js/utils" (module) {
+        module.exports = require("@modern-js/utils");
+    },
+    path (module) {
+        module.exports = require("path");
     }
-  }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
 }
-function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server }) {
-  const { mock } = import_server_core.AGGRED_DIR;
-  const defaultWatched = [
-    `${mock}/**/*`,
-    `${import_utils.SERVER_DIR}/**/*`,
-    `${apiDir}/**`,
-    `${sharedDir}/**/*`,
-    `${distDir}/${import_utils.SERVER_BUNDLE_DIRECTORY}/*-server-loaders.js`
-  ];
-  const mergedWatchOptions = (0, import_watcher.mergeWatchOptions)(watchOptions);
-  const defaultWatchedPaths = defaultWatched.map((p) => {
-    const finalPath = import_path.default.isAbsolute(p) ? p : import_path.default.join(pwd, p);
-    return import_path.default.normalize(finalPath);
-  });
-  const watcher = new import_watcher.default();
-  watcher.createDepTree();
-  watcher.listen(defaultWatchedPaths, mergedWatchOptions, (filepath, event) => {
-    if (filepath.includes("-server-loaders.js")) {
-      delete require.cache[filepath];
-      return;
-    } else {
-      watcher.updateDepTree();
-      watcher.cleanDepCache(filepath);
-    }
-    onServerChange({
-      pwd,
-      filepath,
-      event,
-      server
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        startWatcher: ()=>startWatcher
     });
-  });
-  return watcher;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  startWatcher,
-  ...require("./repack"),
-  ...require("./devOptions"),
-  ...require("./fileReader"),
-  ...require("./mock")
+    var path__rspack_import_0 = __webpack_require__("path");
+    var path__rspack_import_0_default = /*#__PURE__*/ __webpack_require__.n(path__rspack_import_0);
+    var _modern_js_server_core__rspack_import_1 = __webpack_require__("@modern-js/server-core");
+    var _modern_js_utils__rspack_import_2 = __webpack_require__("@modern-js/utils");
+    var _dev_tools_watcher__rspack_import_3 = __webpack_require__("../dev-tools/watcher");
+    var _dev_tools_watcher__rspack_import_3_default = /*#__PURE__*/ __webpack_require__.n(_dev_tools_watcher__rspack_import_3);
+    var _mock__rspack_import_4 = __webpack_require__("./mock");
+    var _utils__rspack_import_5 = __webpack_require__("./utils");
+    var _repack__rspack_import_6 = __webpack_require__("./repack");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _repack__rspack_import_6)if ([
+        "startWatcher",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_repack__rspack_import_6[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _devOptions__rspack_import_7 = __webpack_require__("./devOptions");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _devOptions__rspack_import_7)if ([
+        "startWatcher",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_devOptions__rspack_import_7[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _fileReader__rspack_import_8 = __webpack_require__("./fileReader");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _fileReader__rspack_import_8)if ([
+        "startWatcher",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_fileReader__rspack_import_8[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _mock__rspack_import_4)if ([
+        "startWatcher",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_mock__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    async function onServerChange({ pwd, filepath, event, server }) {
+        const { mock } = _modern_js_server_core__rspack_import_1.AGGRED_DIR;
+        const mockPath = path__rspack_import_0_default().normalize(path__rspack_import_0_default().join(pwd, mock));
+        const { hooks } = server;
+        if (filepath.startsWith(mockPath)) {
+            await (0, _mock__rspack_import_4.initOrUpdateMockMiddlewares)(pwd);
+            _modern_js_utils__rspack_import_2.logger.info('Finish update the mock handlers');
+        } else try {
+            const fileChangeEvent = {
+                type: 'file-change',
+                payload: [
+                    {
+                        filename: filepath,
+                        event
+                    }
+                ]
+            };
+            await hooks.onReset.call({
+                event: fileChangeEvent
+            });
+            (0, _utils__rspack_import_5.debug)(`Finish reload server, trigger by ${filepath} ${event}`);
+        } catch (e) {
+            _modern_js_utils__rspack_import_2.logger.error(e);
+        }
+    }
+    function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server }) {
+        const { mock } = _modern_js_server_core__rspack_import_1.AGGRED_DIR;
+        const defaultWatched = [
+            `${mock}/**/*`,
+            `${_modern_js_utils__rspack_import_2.SERVER_DIR}/**/*`,
+            `${apiDir}/**`,
+            `${sharedDir}/**/*`,
+            `${distDir}/${_modern_js_utils__rspack_import_2.SERVER_BUNDLE_DIRECTORY}/*-server-loaders.js`
+        ];
+        const mergedWatchOptions = (0, _dev_tools_watcher__rspack_import_3.mergeWatchOptions)(watchOptions);
+        const defaultWatchedPaths = defaultWatched.map((p)=>{
+            const finalPath = path__rspack_import_0_default().isAbsolute(p) ? p : path__rspack_import_0_default().join(pwd, p);
+            return path__rspack_import_0_default().normalize(finalPath);
+        });
+        const watcher = new (_dev_tools_watcher__rspack_import_3_default())();
+        watcher.createDepTree();
+        watcher.listen(defaultWatchedPaths, mergedWatchOptions, (filepath, event)=>{
+            if (filepath.includes('-server-loaders.js')) return void delete require.cache[filepath];
+            watcher.updateDepTree();
+            watcher.cleanDepCache(filepath);
+            onServerChange({
+                pwd,
+                filepath,
+                event,
+                server
+            });
+        });
+        return watcher;
+    }
+})();
+exports.startWatcher = __webpack_exports__.startWatcher;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "startWatcher"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/helpers/mock.js

@@ -1,140 +1,137 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var mock_exports = {};
-__export(mock_exports, {
-  getMatched: () => getMatched,
-  getMockMiddleware: () => getMockMiddleware,
-  initOrUpdateMockMiddlewares: () => initOrUpdateMockMiddlewares
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getMatched: ()=>getMatched,
+    getMockMiddleware: ()=>getMockMiddleware,
+    initOrUpdateMockMiddlewares: ()=>initOrUpdateMockMiddlewares
 });
-module.exports = __toCommonJS(mock_exports);
-var import_node_path = __toESM(require("node:path"));
-var import_server_core = require("@modern-js/server-core");
-var import_node = require("@modern-js/server-core/node");
-var import_utils = require("@modern-js/utils");
-var import_path_to_regexp = require("path-to-regexp");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const server_core_namespaceObject = require("@modern-js/server-core");
+const node_namespaceObject = require("@modern-js/server-core/node");
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_to_regexp_namespaceObject = require("path-to-regexp");
 let mockAPIs = [];
 let mockConfig;
-const parseKey = (key) => {
-  const _blank = " ";
-  const splitted = key.split(_blank).filter(Boolean);
-  if (splitted.length > 1) {
-    const [method, pathname] = splitted;
+const parseKey = (key)=>{
+    const _blank = ' ';
+    const splitted = key.split(_blank).filter(Boolean);
+    if (splitted.length > 1) {
+        const [method, pathname] = splitted;
+        return {
+            method: method.toLowerCase(),
+            path: pathname
+        };
+    }
     return {
-      method: method.toLowerCase(),
-      path: pathname
+        method: 'get',
+        path: key
     };
-  }
-  return {
-    method: "get",
-    path: key
-  };
 };
-const getMockModule = async (pwd) => {
-  const exts = [
-    ".ts",
-    ".js"
-  ];
-  let mockFilePath = "";
-  for (const ext of exts) {
-    const maybeMatch = import_node_path.default.join(pwd, `${import_server_core.AGGRED_DIR.mock}/index${ext}`);
-    if (await import_utils.fs.pathExists(maybeMatch)) {
-      mockFilePath = maybeMatch;
-      break;
+const getMockModule = async (pwd)=>{
+    const exts = [
+        '.ts',
+        '.js'
+    ];
+    let mockFilePath = '';
+    for (const ext of exts){
+        const maybeMatch = external_node_path_default().join(pwd, `${server_core_namespaceObject.AGGRED_DIR.mock}/index${ext}`);
+        if (await utils_namespaceObject.fs.pathExists(maybeMatch)) {
+            mockFilePath = maybeMatch;
+            break;
+        }
     }
-  }
-  if (!mockFilePath) {
-    return void 0;
-  }
-  const { default: mockHandlers, config } = await Promise.resolve().then(() => __toESM(require(mockFilePath)));
-  const enable = config === null || config === void 0 ? void 0 : config.enable;
-  if (enable === false) {
-    return void 0;
-  }
-  if (!mockHandlers) {
-    throw new Error(`Mock file ${mockFilePath} parsed failed!`);
-  }
-  return {
-    mockHandlers,
-    config
-  };
+    if (!mockFilePath) return;
+    const { default: mockHandlers, config } = await import(mockFilePath);
+    const enable = config?.enable;
+    if (false === enable) return;
+    if (!mockHandlers) throw new Error(`Mock file ${mockFilePath} parsed failed!`);
+    return {
+        mockHandlers,
+        config
+    };
 };
-const getMatched = (request, mockApis) => {
-  const { path: targetPathname, method: targetMethod } = request;
-  const matched = mockApis.find((mockApi) => {
-    const { method, path: pathname } = mockApi;
-    if (method.toLowerCase() === targetMethod.toLowerCase()) {
-      return (0, import_path_to_regexp.match)(pathname, {
-        encode: encodeURI,
-        decode: decodeURIComponent
-      })(targetPathname);
-    }
-    return false;
-  });
-  return matched;
+const getMatched = (request, mockApis)=>{
+    const { path: targetPathname, method: targetMethod } = request;
+    const matched = mockApis.find((mockApi)=>{
+        const { method, path: pathname } = mockApi;
+        if (method.toLowerCase() === targetMethod.toLowerCase()) return (0, external_path_to_regexp_namespaceObject.match)(pathname, {
+            encode: encodeURI,
+            decode: decodeURIComponent
+        })(targetPathname);
+        return false;
+    });
+    return matched;
 };
 async function initOrUpdateMockMiddlewares(pwd) {
-  const mockModule = await getMockModule(pwd);
-  mockConfig = mockModule === null || mockModule === void 0 ? void 0 : mockModule.config;
-  mockAPIs = Object.entries((mockModule === null || mockModule === void 0 ? void 0 : mockModule.mockHandlers) || {}).map(([key, handler]) => {
-    const { method, path: path2 } = parseKey(key);
-    return {
-      method,
-      path: path2,
-      handler
-    };
-  });
+    const mockModule = await getMockModule(pwd);
+    mockConfig = mockModule?.config;
+    mockAPIs = Object.entries(mockModule?.mockHandlers || {}).map(([key, handler])=>{
+        const { method, path } = parseKey(key);
+        return {
+            method,
+            path,
+            handler
+        };
+    });
 }
 async function getMockMiddleware(pwd) {
-  await initOrUpdateMockMiddlewares(pwd);
-  const mockMiddleware = async (c, next) => {
-    if (typeof (mockConfig === null || mockConfig === void 0 ? void 0 : mockConfig.enable) === "function") {
-      const isEnabled = mockConfig.enable(c.env.node.req, c.env.node.res);
-      if (!isEnabled) {
+    await initOrUpdateMockMiddlewares(pwd);
+    const mockMiddleware = async (c, next)=>{
+        if ('function' == typeof mockConfig?.enable) {
+            const isEnabled = mockConfig.enable(c.env.node.req, c.env.node.res);
+            if (!isEnabled) return next();
+        }
+        const matchedMockAPI = getMatched(c.req, mockAPIs);
+        if (matchedMockAPI) {
+            const { handler } = matchedMockAPI;
+            if ('function' == typeof handler) return await (0, node_namespaceObject.connectMockMid2HonoMid)(handler)(c, next);
+            return c.json(handler);
+        }
         return next();
-      }
-    }
-    const matchedMockAPI = getMatched(c.req, mockAPIs);
-    if (matchedMockAPI) {
-      const { handler } = matchedMockAPI;
-      if (typeof handler === "function") {
-        return await (0, import_node.connectMockMid2HonoMid)(handler)(c, next);
-      } else {
-        return c.json(handler);
-      }
-    }
-    return next();
-  };
-  return mockMiddleware;
+    };
+    return mockMiddleware;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getMatched,
-  getMockMiddleware,
-  initOrUpdateMockMiddlewares
+exports.getMatched = __webpack_exports__.getMatched;
+exports.getMockMiddleware = __webpack_exports__.getMockMiddleware;
+exports.initOrUpdateMockMiddlewares = __webpack_exports__.initOrUpdateMockMiddlewares;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getMatched",
+    "getMockMiddleware",
+    "initOrUpdateMockMiddlewares"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/helpers/repack.js

@@ -1,44 +1,50 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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);
-var repack_exports = {};
-__export(repack_exports, {
-  onRepack: () => onRepack
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    onRepack: ()=>onRepack
 });
-module.exports = __toCommonJS(repack_exports);
-var import_fileReader = require("@modern-js/runtime-utils/fileReader");
-const cleanSSRCache = (distDir) => {
-  Object.keys(require.cache).forEach((key) => {
-    if (key.startsWith(distDir)) {
-      delete require.cache[key];
-    }
-  });
+const fileReader_namespaceObject = require("@modern-js/runtime-utils/fileReader");
+const cleanSSRCache = (distDir)=>{
+    Object.keys(require.cache).forEach((key)=>{
+        if (key.startsWith(distDir)) delete require.cache[key];
+    });
 };
-const onRepack = (distDir, hooks) => {
-  cleanSSRCache(distDir);
-  import_fileReader.fileReader.reset();
-  hooks.onReset.call({
-    event: {
-      type: "repack"
-    }
-  });
+const onRepack = (distDir, hooks)=>{
+    cleanSSRCache(distDir);
+    fileReader_namespaceObject.fileReader.reset();
+    hooks.onReset.call({
+        event: {
+            type: 'repack'
+        }
+    });
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  onRepack
+exports.onRepack = __webpack_exports__.onRepack;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "onRepack"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });