@bleedingdev/modern-js-plugin 3.2.0-ultramodern.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).

package/dist/cjs/cli/api.js

@@ -0,0 +1,119 @@
+"use strict";
+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__, {
+    initPluginAPI: ()=>initPluginAPI
+});
+const lodash_namespaceObject = require("@modern-js/utils/lodash");
+const debug_js_namespaceObject = require("./run/utils/debug.js");
+function initPluginAPI({ context, pluginManager }) {
+    const { hooks, extendsHooks, plugins } = context;
+    function getAppContext() {
+        if (context) {
+            const { hooks, extendsHooks, config, normalizedConfig, pluginAPI, ...appContext } = context;
+            appContext._internalContext = context;
+            return appContext;
+        }
+        throw new Error('Cannot access context');
+    }
+    function getConfig() {
+        if (context.config) return context.config;
+        throw new Error('Cannot access config');
+    }
+    function getNormalizedConfig() {
+        if (context.normalizedConfig) return context.normalizedConfig;
+        throw new Error('Cannot access normalized config');
+    }
+    function getHooks() {
+        return context.hooks;
+    }
+    const extendsPluginApi = {};
+    plugins.forEach((plugin)=>{
+        const { _registryApi } = plugin;
+        if (_registryApi) {
+            const apis = _registryApi(getAppContext, updateAppContext);
+            Object.keys(apis).forEach((apiName)=>{
+                extendsPluginApi[apiName] = apis[apiName];
+            });
+        }
+    });
+    if (extendsHooks) Object.keys(extendsHooks).forEach((hookName)=>{
+        extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+    });
+    function updateAppContext(updateContext) {
+        context = (0, lodash_namespaceObject.assign)(context, updateContext);
+    }
+    const pluginAPI = {
+        isPluginExists: pluginManager.isPluginExists,
+        getAppContext,
+        getConfig,
+        getNormalizedConfig,
+        getHooks,
+        updateAppContext,
+        config: hooks.config.tap,
+        modifyConfig: hooks.modifyConfig.tap,
+        modifyResolvedConfig: hooks.modifyResolvedConfig.tap,
+        modifyRsbuildConfig: hooks.modifyRsbuildConfig.tap,
+        modifyBundlerChain: hooks.modifyBundlerChain.tap,
+        modifyRspackConfig: hooks.modifyRspackConfig.tap,
+        modifyHtmlPartials: hooks.modifyHtmlPartials.tap,
+        addCommand: hooks.addCommand.tap,
+        onPrepare: hooks.onPrepare.tap,
+        addWatchFiles: hooks.addWatchFiles.tap,
+        onFileChanged: hooks.onFileChanged.tap,
+        onBeforeRestart: hooks.onBeforeRestart.tap,
+        onBeforeCreateCompiler: hooks.onBeforeCreateCompiler.tap,
+        onDevCompileDone: hooks.onDevCompileDone.tap,
+        onAfterCreateCompiler: hooks.onAfterCreateCompiler.tap,
+        onBeforeBuild: hooks.onBeforeBuild.tap,
+        onAfterBuild: hooks.onAfterBuild.tap,
+        onBeforeDev: hooks.onBeforeDev.tap,
+        onAfterDev: hooks.onAfterDev.tap,
+        onBeforeDeploy: hooks.onBeforeDeploy.tap,
+        onAfterDeploy: hooks.onAfterDeploy.tap,
+        onBeforeExit: hooks.onBeforeExit.tap,
+        _internalRuntimePlugins: hooks._internalRuntimePlugins.tap,
+        _internalServerPlugins: hooks._internalServerPlugins.tap,
+        modifyServerRoutes: hooks.modifyServerRoutes.tap,
+        ...extendsPluginApi
+    };
+    if ("u" < typeof Proxy) return pluginAPI;
+    return new Proxy(pluginAPI, {
+        get (target, prop) {
+            if ('then' === prop) return;
+            if (prop in target) return target[prop];
+            return ()=>{
+                (0, debug_js_namespaceObject.debug)(`api.${prop.toString()} not exist`);
+            };
+        }
+    });
+}
+exports.initPluginAPI = __webpack_exports__.initPluginAPI;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initPluginAPI"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/context.js

@@ -0,0 +1,85 @@
+"use strict";
+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__, {
+    createContext: ()=>createContext,
+    initAppContext: ()=>initAppContext
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_hooks_js_namespaceObject = require("./hooks.js");
+function initAppContext(params) {
+    const { appDirectory, srcDir = 'src', distDir = 'dist' } = params;
+    return {
+        metaName: params.metaName,
+        packageName: params.packageName,
+        configFile: params.configFile,
+        command: params.command,
+        isProd: 'production' === process.env.NODE_ENV,
+        appDirectory: appDirectory,
+        srcDirectory: external_path_default().resolve(appDirectory, srcDir),
+        distDirectory: '',
+        nodeModulesDirectory: external_path_default().resolve(appDirectory, 'node_modules'),
+        plugins: params.plugins
+    };
+}
+async function createContext({ appContext, config, normalizedConfig }) {
+    const { plugins } = appContext;
+    const extendsHooks = {};
+    plugins.forEach((plugin)=>{
+        const { registryHooks = {} } = plugin;
+        Object.keys(registryHooks).forEach((hookName)=>{
+            extendsHooks[hookName] = registryHooks[hookName];
+        });
+    });
+    return {
+        ...appContext,
+        hooks: {
+            ...(0, external_hooks_js_namespaceObject.initHooks)(),
+            ...extendsHooks
+        },
+        extendsHooks,
+        config,
+        normalizedConfig
+    };
+}
+exports.createContext = __webpack_exports__.createContext;
+exports.initAppContext = __webpack_exports__.initAppContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createContext",
+    "initAppContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/hooks.js

@@ -0,0 +1,65 @@
+"use strict";
+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__, {
+    initHooks: ()=>initHooks
+});
+const external_hooks_js_namespaceObject = require("../hooks.js");
+function initHooks() {
+    return {
+        config: (0, external_hooks_js_namespaceObject.createCollectAsyncHook)(),
+        modifyConfig: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        modifyResolvedConfig: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        modifyRsbuildConfig: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        modifyBundlerChain: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        modifyRspackConfig: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        modifyHtmlPartials: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        addCommand: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        addWatchFiles: (0, external_hooks_js_namespaceObject.createCollectAsyncHook)(),
+        onPrepare: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onFileChanged: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onBeforeRestart: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onBeforeCreateCompiler: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onAfterCreateCompiler: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onDevCompileDone: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onBeforeBuild: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onAfterBuild: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onBeforeDev: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onAfterDev: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onBeforeDeploy: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onAfterDeploy: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onBeforeExit: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        _internalRuntimePlugins: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        _internalServerPlugins: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        modifyServerRoutes: (0, external_hooks_js_namespaceObject.createAsyncHook)()
+    };
+}
+exports.initHooks = __webpack_exports__.initHooks;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initHooks"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/index.js

@@ -0,0 +1,71 @@
+"use strict";
+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__, {
+    cli: ()=>index_js_namespaceObject.cli,
+    createCli: ()=>index_js_namespaceObject.createCli,
+    createConfigOptions: ()=>create_js_namespaceObject.createConfigOptions,
+    createContext: ()=>external_context_js_namespaceObject.createContext,
+    createLoadedConfig: ()=>index_js_namespaceObject.createLoadedConfig,
+    createStorybookOptions: ()=>create_js_namespaceObject.createStorybookOptions,
+    initAppContext: ()=>external_context_js_namespaceObject.initAppContext,
+    initAppDir: ()=>index_js_namespaceObject.initAppDir,
+    initHooks: ()=>external_hooks_js_namespaceObject.initHooks,
+    initPluginAPI: ()=>external_api_js_namespaceObject.initPluginAPI,
+    mergeConfig: ()=>mergeConfig_js_namespaceObject.mergeConfig
+});
+const external_api_js_namespaceObject = require("./api.js");
+const external_context_js_namespaceObject = require("./context.js");
+const external_hooks_js_namespaceObject = require("./hooks.js");
+const index_js_namespaceObject = require("./run/index.js");
+const create_js_namespaceObject = require("./run/create.js");
+const mergeConfig_js_namespaceObject = require("./run/utils/mergeConfig.js");
+exports.cli = __webpack_exports__.cli;
+exports.createCli = __webpack_exports__.createCli;
+exports.createConfigOptions = __webpack_exports__.createConfigOptions;
+exports.createContext = __webpack_exports__.createContext;
+exports.createLoadedConfig = __webpack_exports__.createLoadedConfig;
+exports.createStorybookOptions = __webpack_exports__.createStorybookOptions;
+exports.initAppContext = __webpack_exports__.initAppContext;
+exports.initAppDir = __webpack_exports__.initAppDir;
+exports.initHooks = __webpack_exports__.initHooks;
+exports.initPluginAPI = __webpack_exports__.initPluginAPI;
+exports.mergeConfig = __webpack_exports__.mergeConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "cli",
+    "createCli",
+    "createConfigOptions",
+    "createContext",
+    "createLoadedConfig",
+    "createStorybookOptions",
+    "initAppContext",
+    "initAppDir",
+    "initHooks",
+    "initPluginAPI",
+    "mergeConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/run/config/createLoadedConfig.js

@@ -0,0 +1,87 @@
+"use strict";
+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__, {
+    createLoadedConfig: ()=>createLoadedConfig
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const mergeConfig_js_namespaceObject = require("../utils/mergeConfig.js");
+const external_loadConfig_js_namespaceObject = require("./loadConfig.js");
+async function getConfigObject(config) {
+    if ('function' == typeof config) return await config({
+        env: (0, utils_namespaceObject.getNodeEnv)(),
+        command: (0, utils_namespaceObject.getCommand)()
+    }) || {};
+    return config || {};
+}
+async function loadLocalConfig(appDirectory, configFile) {
+    let localConfigFile = false;
+    if ('string' == typeof configFile) {
+        for (const ext of utils_namespaceObject.CONFIG_FILE_EXTENSIONS)if (configFile.endsWith(ext)) {
+            const replacedPath = configFile.replace(ext, `.local${ext}`);
+            if (utils_namespaceObject.fs.existsSync(replacedPath)) localConfigFile = replacedPath;
+        }
+    }
+    if (localConfigFile) {
+        const loaded = await (0, external_loadConfig_js_namespaceObject.loadConfig)(appDirectory, localConfigFile);
+        return getConfigObject(loaded.config);
+    }
+    return null;
+}
+async function createLoadedConfig(appDirectory, configFilePath, otherConfig) {
+    const configFile = (0, external_loadConfig_js_namespaceObject.getConfigFilePath)(appDirectory, configFilePath);
+    const loaded = await (0, external_loadConfig_js_namespaceObject.loadConfig)(appDirectory, configFile);
+    if (!loaded.config && !loaded.pkgConfig) {
+        utils_namespaceObject.logger.warn("Can not find any config file in the current project, please check if you have a correct config file.");
+        utils_namespaceObject.logger.warn(`Current project path: ${utils_namespaceObject.chalk.yellow(appDirectory)}`);
+    }
+    const config = await getConfigObject(loaded.config);
+    let mergedConfig = config;
+    if ((0, utils_namespaceObject.isDevCommand)()) {
+        const localConfig = await loadLocalConfig(appDirectory, configFile);
+        if (localConfig) mergedConfig = (0, mergeConfig_js_namespaceObject.mergeConfig)([
+            mergedConfig,
+            localConfig
+        ]);
+    }
+    if (otherConfig) mergedConfig = (0, mergeConfig_js_namespaceObject.mergeConfig)([
+        mergedConfig,
+        otherConfig
+    ]);
+    return {
+        packageName: loaded.packageName,
+        config: mergedConfig,
+        configFile: loaded.configFile,
+        pkgConfig: loaded.pkgConfig,
+        jsConfig: loaded.config
+    };
+}
+exports.createLoadedConfig = __webpack_exports__.createLoadedConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createLoadedConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/run/config/createResolvedConfig.js

@@ -0,0 +1,48 @@
+"use strict";
+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__, {
+    createResolveConfig: ()=>createResolveConfig
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const mergeConfig_js_namespaceObject = require("../utils/mergeConfig.js");
+const debug = (0, utils_namespaceObject.createDebugger)('resolve-config');
+const createResolveConfig = async (loaded, configs)=>{
+    const { config: userConfig } = loaded;
+    const resolved = (0, mergeConfig_js_namespaceObject.mergeConfig)([
+        {},
+        ...configs,
+        userConfig
+    ]);
+    debug('resolved %o', resolved);
+    return resolved;
+};
+exports.createResolveConfig = __webpack_exports__.createResolveConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createResolveConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/run/config/loadConfig.js

@@ -0,0 +1,113 @@
+"use strict";
+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__, {
+    clearFilesOverTime: ()=>clearFilesOverTime,
+    getConfigFilePath: ()=>getConfigFilePath,
+    loadConfig: ()=>loadConfig,
+    loadTypeScriptFile: ()=>loadTypeScriptFile
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_jiti_namespaceObject = require("jiti");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const getConfigFilePath = (appDirectory, configFilePath)=>{
+    if (external_path_default().isAbsolute(configFilePath)) return configFilePath;
+    return external_path_default().resolve(appDirectory, configFilePath);
+};
+const clearFilesOverTime = async (targetDir, overtime)=>{
+    try {
+        const files = await (0, utils_namespaceObject.globby)(`${targetDir}/**/*`, {
+            stats: true,
+            absolute: true
+        });
+        const currentTime = Date.now();
+        if (files.length > 0) {
+            for (const file of files)if (currentTime - file.stats.birthtimeMs >= 1000 * overtime) utils_namespaceObject.fs.unlinkSync(file.path);
+        }
+    } catch (err) {}
+};
+async function loadConfigContent(configFile) {
+    const jitiFrom = __filename;
+    const jiti = (0, external_jiti_namespaceObject.createJiti)(jitiFrom, {
+        requireCache: false,
+        interopDefault: true
+    });
+    if (!utils_namespaceObject.fs.existsSync(configFile)) throw new Error(`Configuration file does not exist: ${configFile}`);
+    try {
+        let config;
+        config = jiti(configFile);
+        return config.default || config;
+    } catch (e) {
+        if (e instanceof Error) e.message = `Get Error while loading config file: ${configFile}, please check it and retry.\n${e.message || ''}`;
+        throw e;
+    }
+}
+const loadTypeScriptFile = (filePath)=>{
+    const jiti = (0, external_jiti_namespaceObject.createJiti)(__filename, {
+        requireCache: false,
+        interopDefault: true
+    });
+    if (!utils_namespaceObject.fs.existsSync(filePath)) throw new Error(`TypeScript file does not exist: ${filePath}`);
+    try {
+        return jiti(filePath);
+    } catch (e) {
+        if (e instanceof Error) e.message = `Get Error while loading TypeScript file: ${filePath}, please check it and retry.\n${e.message || ''}`;
+        throw e;
+    }
+};
+const loadConfig = async (appDirectory, configFile)=>{
+    const pkg = await (0, utils_namespaceObject.compatibleRequire)(external_path_default().resolve(appDirectory, './package.json'));
+    const packageName = pkg.name;
+    let config;
+    if (configFile) config = await loadConfigContent(configFile);
+    return {
+        packageName,
+        configFile,
+        config
+    };
+};
+exports.clearFilesOverTime = __webpack_exports__.clearFilesOverTime;
+exports.getConfigFilePath = __webpack_exports__.getConfigFilePath;
+exports.loadConfig = __webpack_exports__.loadConfig;
+exports.loadTypeScriptFile = __webpack_exports__.loadTypeScriptFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "clearFilesOverTime",
+    "getConfigFilePath",
+    "loadConfig",
+    "loadTypeScriptFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});