@modern-js/plugin 2.69.5 → 3.0.0-alpha.0

package/dist/cjs/cli/run/create.js

@@ -0,0 +1,187 @@
+"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__, {
+    createStorybookOptions: ()=>createStorybookOptions,
+    createCli: ()=>createCli
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const commander_namespaceObject = require("@modern-js/utils/commander");
+const core_namespaceObject = require("@rsbuild/core");
+const external_manager_js_namespaceObject = require("../../manager.js");
+const external_api_js_namespaceObject = require("../api.js");
+const external_context_js_namespaceObject = require("../context.js");
+const createLoadedConfig_js_namespaceObject = require("./config/createLoadedConfig.js");
+const createResolvedConfig_js_namespaceObject = require("./config/createResolvedConfig.js");
+const checkIsDuplicationPlugin_js_namespaceObject = require("./utils/checkIsDuplicationPlugin.js");
+const commander_js_namespaceObject = require("./utils/commander.js");
+const createFileWatcher_js_namespaceObject = require("./utils/createFileWatcher.js");
+const initAppDir_js_namespaceObject = require("./utils/initAppDir.js");
+const debug = (0, utils_namespaceObject.createDebugger)('plugin');
+const createCli = ()=>{
+    let initOptions;
+    const pluginManager = (0, external_manager_js_namespaceObject.createPluginManager)();
+    const existListenerMap = new Map();
+    function createExistListener(event, context) {
+        return async function(err) {
+            await context.hooks.onBeforeExit.call();
+            let hasError = false;
+            if (err instanceof Error) {
+                utils_namespaceObject.logger.error(err.stack);
+                hasError = true;
+            } else if (err && ('unhandledRejection' === event || 'uncaughtException' === event)) {
+                console.trace('Unknown Error', err);
+                hasError = true;
+            }
+            process.nextTick(()=>{
+                process.exit(hasError ? 1 : 0);
+            });
+        };
+    }
+    async function init(options) {
+        pluginManager.clear();
+        initOptions = options;
+        const { metaName = 'modern-js', configFile, config, command, version, internalPlugins, handleSetupResult } = options;
+        const appDirectory = await (0, initAppDir_js_namespaceObject.initAppDir)(options?.cwd);
+        (0, commander_js_namespaceObject.initCommandsMap)();
+        (0, commander_js_namespaceObject.setProgramVersion)(version);
+        const envName = 'modern-js' === metaName ? 'MODERN' : metaName;
+        (0, core_namespaceObject.loadEnv)({
+            cwd: appDirectory,
+            mode: process.env[`${envName.toUpperCase()}_ENV`] || process.env.NODE_ENV,
+            prefixes: [
+                `${envName.toUpperCase()}_`
+            ]
+        });
+        const loaded = await (0, createLoadedConfig_js_namespaceObject.createLoadedConfig)(appDirectory, configFile, config);
+        const allPlugins = [
+            ...internalPlugins || [],
+            ...loaded.config.plugins || []
+        ];
+        (0, checkIsDuplicationPlugin_js_namespaceObject.checkIsDuplicationPlugin)(allPlugins.map((plugin)=>plugin.name));
+        pluginManager.addPlugins(allPlugins);
+        const plugins = await pluginManager.getPlugins();
+        debug('CLI Plugins:', plugins.map((p)=>p.name));
+        const context = await (0, external_context_js_namespaceObject.createContext)({
+            appContext: (0, external_context_js_namespaceObject.initAppContext)({
+                packageName: loaded.packageName,
+                configFile: loaded.configFile,
+                command: command,
+                appDirectory,
+                plugins,
+                metaName
+            }),
+            config: loaded.config,
+            normalizedConfig: {}
+        });
+        const pluginAPI = (0, external_api_js_namespaceObject.initPluginAPI)({
+            context,
+            pluginManager
+        });
+        context.pluginAPI = pluginAPI;
+        for (const plugin of plugins){
+            const setupResult = await plugin.setup?.(pluginAPI);
+            if (handleSetupResult) await handleSetupResult(setupResult, pluginAPI);
+        }
+        [
+            'SIGINT',
+            'SIGTERM',
+            'unhandledRejection',
+            'uncaughtException'
+        ].forEach((event)=>{
+            if (existListenerMap.get(event)) process.off(event, existListenerMap.get(event));
+            const existListener = createExistListener(event, context);
+            existListenerMap.set(event, existListener);
+            process.on(event, existListener);
+        });
+        const extraConfigs = await context.hooks.config.call();
+        const normalizedConfig = await (0, createResolvedConfig_js_namespaceObject.createResolveConfig)(loaded, extraConfigs);
+        const resolved = await context.hooks.modifyResolvedConfig.call(normalizedConfig);
+        context.normalizedConfig = resolved || normalizedConfig;
+        await pluginAPI.updateAppContext(context);
+        await context.hooks.onPrepare.call();
+        await context.hooks?.onAfterPrepare?.call();
+        return {
+            appContext: context
+        };
+    }
+    async function run(options) {
+        const { appContext } = await init(options);
+        await appContext.hooks.addCommand.call({
+            program: commander_namespaceObject.program
+        });
+        await (0, createFileWatcher_js_namespaceObject.createFileWatcher)(appContext);
+        commander_namespaceObject.program.parse(process.argv);
+        if (!commander_namespaceObject.program.commands?.length) utils_namespaceObject.logger.warn('No command found, please make sure you have registered plugins correctly.');
+    }
+    return {
+        init,
+        run,
+        getPrevInitOptions: ()=>initOptions
+    };
+};
+const createStorybookOptions = async (options)=>{
+    const pluginManager = (0, external_manager_js_namespaceObject.createPluginManager)();
+    pluginManager.clear();
+    const { configFile, cwd, metaName = 'modern-js' } = options;
+    const appDirectory = await (0, initAppDir_js_namespaceObject.initAppDir)(cwd);
+    const loaded = await (0, createLoadedConfig_js_namespaceObject.createLoadedConfig)(appDirectory, configFile);
+    pluginManager.addPlugins(loaded.config.plugins || []);
+    const plugins = await pluginManager.getPlugins();
+    const context = await (0, external_context_js_namespaceObject.createContext)({
+        appContext: (0, external_context_js_namespaceObject.initAppContext)({
+            packageName: loaded.packageName,
+            configFile: loaded.configFile,
+            command: 'storybook',
+            appDirectory,
+            plugins,
+            metaName
+        }),
+        config: loaded.config,
+        normalizedConfig: {}
+    });
+    const pluginAPI = (0, external_api_js_namespaceObject.initPluginAPI)({
+        context,
+        pluginManager
+    });
+    context.pluginAPI = pluginAPI;
+    for (const plugin of plugins)await plugin.setup?.(pluginAPI);
+    const extraConfigs = await context.hooks.config.call();
+    const normalizedConfig = await (0, createResolvedConfig_js_namespaceObject.createResolveConfig)(loaded, extraConfigs);
+    const resolved = await context.hooks.modifyResolvedConfig.call(normalizedConfig);
+    return {
+        config: resolved || normalizedConfig,
+        getAppContext: ()=>pluginAPI.getAppContext()
+    };
+};
+exports.createCli = __webpack_exports__.createCli;
+exports.createStorybookOptions = __webpack_exports__.createStorybookOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCli",
+    "createStorybookOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/run/index.js

@@ -0,0 +1,56 @@
+"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: ()=>cli,
+    initAppDir: ()=>initAppDir_js_namespaceObject.initAppDir,
+    run: ()=>external_run_js_namespaceObject.run,
+    loadTypeScriptFile: ()=>loadConfig_js_namespaceObject.loadTypeScriptFile,
+    createCli: ()=>external_create_js_namespaceObject.createCli,
+    createLoadedConfig: ()=>createLoadedConfig_js_namespaceObject.createLoadedConfig
+});
+const external_create_js_namespaceObject = require("./create.js");
+const createLoadedConfig_js_namespaceObject = require("./config/createLoadedConfig.js");
+const initAppDir_js_namespaceObject = require("./utils/initAppDir.js");
+const loadConfig_js_namespaceObject = require("./config/loadConfig.js");
+const external_run_js_namespaceObject = require("./run.js");
+const cli = (0, external_create_js_namespaceObject.createCli)();
+exports.cli = __webpack_exports__.cli;
+exports.createCli = __webpack_exports__.createCli;
+exports.createLoadedConfig = __webpack_exports__.createLoadedConfig;
+exports.initAppDir = __webpack_exports__.initAppDir;
+exports.loadTypeScriptFile = __webpack_exports__.loadTypeScriptFile;
+exports.run = __webpack_exports__.run;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "cli",
+    "createCli",
+    "createLoadedConfig",
+    "initAppDir",
+    "loadTypeScriptFile",
+    "run"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,57 @@
+"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__, {
+    run: ()=>run
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_index_js_namespaceObject = require("./index.js");
+const run = async (options)=>{
+    const { initialLog, version, cwd, configFile, ...params } = options;
+    if (initialLog) utils_namespaceObject.logger.greet(`  ${initialLog}\n`);
+    const command = process.argv[2];
+    if (!process.env.NODE_ENV) if ([
+        'build',
+        'serve',
+        'deploy',
+        'analyze'
+    ].includes(command)) process.env.NODE_ENV = 'production';
+    else if ('test' === command) process.env.NODE_ENV = 'test';
+    else process.env.NODE_ENV = 'development';
+    await external_index_js_namespaceObject.cli.run({
+        version,
+        cwd,
+        command,
+        configFile,
+        ...params
+    });
+};
+exports.run = __webpack_exports__.run;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "run"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/run/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/run/utils/checkIsDuplicationPlugin.js

@@ -0,0 +1,45 @@
+"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__, {
+    checkIsDuplicationPlugin: ()=>checkIsDuplicationPlugin
+});
+const utils_namespaceObject = require("@modern-js/utils");
+function checkIsDuplicationPlugin(plugins) {
+    const set = new Set();
+    const duplicationPlugins = [];
+    plugins.filter((plugin)=>'string' == typeof plugin).forEach((plugin)=>{
+        if (set.has(plugin)) duplicationPlugins.push(plugin);
+        else set.add(plugin);
+    });
+    if (duplicationPlugins.length > 0) utils_namespaceObject.logger.warn(`Duplicate registration plugins: ${duplicationPlugins.join(',')}.`);
+}
+exports.checkIsDuplicationPlugin = __webpack_exports__.checkIsDuplicationPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "checkIsDuplicationPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/run/utils/commander.js

@@ -0,0 +1,56 @@
+"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__, {
+    initCommandsMap: ()=>initCommandsMap,
+    program: ()=>utils_namespaceObject.program,
+    setProgramVersion: ()=>setProgramVersion
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const setProgramVersion = (version = 'unknown')=>{
+    const name = process.argv[1];
+    utils_namespaceObject.program.name(name).usage('<command> [options]').version(version);
+};
+function initCommandsMap() {
+    if (!utils_namespaceObject.program.hasOwnProperty('commandsMap')) Object.defineProperty(utils_namespaceObject.program, 'commandsMap', {
+        get () {
+            const map = new Map();
+            for (const command of utils_namespaceObject.program.commands)map.set(command._name, command);
+            return map;
+        },
+        configurable: false
+    });
+}
+exports.initCommandsMap = __webpack_exports__.initCommandsMap;
+exports.program = __webpack_exports__.program;
+exports.setProgramVersion = __webpack_exports__.setProgramVersion;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initCommandsMap",
+    "program",
+    "setProgramVersion"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/run/utils/createFileWatcher.js

@@ -0,0 +1,112 @@
+"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__, {
+    createFileWatcher: ()=>createFileWatcher
+});
+const external_crypto_namespaceObject = require("crypto");
+var external_crypto_default = /*#__PURE__*/ __webpack_require__.n(external_crypto_namespaceObject);
+const external_fs_namespaceObject = require("fs");
+const external_path_namespaceObject = require("path");
+const utils_namespaceObject = require("@modern-js/utils");
+const debug = (0, utils_namespaceObject.createDebugger)('watch-files');
+const hashMap = new Map();
+const md5 = (data)=>external_crypto_default().createHash('md5').update(data).digest('hex');
+const createFileWatcher = async (appContext)=>{
+    if ((0, utils_namespaceObject.isDevCommand)()) {
+        const { appDirectory } = appContext;
+        const extraFiles = await appContext.hooks.addWatchFiles.call();
+        const watched = extraFiles.filter((extra)=>Array.isArray(extra)).flat();
+        const privateWatched = extraFiles.filter((extra)=>!Array.isArray(extra) && extra.isPrivate).map((extra)=>extra.files).flat();
+        const isPrivate = (filename)=>privateWatched.some((ff)=>external_path_namespaceObject.resolve(appDirectory, filename).startsWith(ff));
+        debug("watched: %o", watched);
+        const watcher = utils_namespaceObject.chokidar.watch([
+            ...watched,
+            ...privateWatched
+        ], {
+            cwd: appDirectory,
+            ignoreInitial: true,
+            ignorePermissionErrors: true,
+            ignored: [
+                '**/__test__/**',
+                '**/*.test.(js|jsx|ts|tsx)',
+                '**/*.spec.(js|jsx|ts|tsx)',
+                '**/*.stories.(js|jsx|ts|tsx)'
+            ]
+        });
+        watcher.on('change', (changed)=>{
+            const lastHash = hashMap.get(changed);
+            const currentHash = md5(external_fs_namespaceObject.readFileSync(external_path_namespaceObject.join(appDirectory, changed), 'utf8'));
+            if (currentHash !== lastHash) {
+                debug("file change: %s", changed);
+                hashMap.set(changed, currentHash);
+                appContext.hooks.onFileChanged.call({
+                    filename: changed,
+                    eventType: 'change',
+                    isPrivate: isPrivate(changed)
+                });
+            }
+        });
+        watcher.on('add', (changed)=>{
+            debug("add file: %s", changed);
+            const currentHash = md5(external_fs_namespaceObject.readFileSync(external_path_namespaceObject.join(appDirectory, changed), 'utf8'));
+            hashMap.set(changed, currentHash);
+            appContext.hooks.onFileChanged.call({
+                filename: changed,
+                eventType: 'add',
+                isPrivate: isPrivate(changed)
+            });
+        });
+        watcher.on('unlink', (changed)=>{
+            debug("remove file: %s", changed);
+            if (hashMap.has(changed)) hashMap.delete(changed);
+            appContext.hooks.onFileChanged.call({
+                filename: changed,
+                eventType: 'unlink',
+                isPrivate: isPrivate(changed)
+            });
+        });
+        watcher.on('error', (err)=>{
+            throw err;
+        });
+        return watcher;
+    }
+};
+exports.createFileWatcher = __webpack_exports__.createFileWatcher;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createFileWatcher"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/run/utils/debug.js

@@ -0,0 +1,37 @@
+"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__, {
+    debug: ()=>debug
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const debug = (0, utils_namespaceObject.createDebugger)('plugin');
+exports.debug = __webpack_exports__.debug;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "debug"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/run/utils/initAppDir.js

@@ -0,0 +1,55 @@
+"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__, {
+    initAppDir: ()=>initAppDir
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const initAppDir = async (currentDir)=>{
+    const cwd = currentDir || process.cwd();
+    const pkg = await (0, utils_namespaceObject.pkgUp)({
+        cwd
+    });
+    if (!pkg) throw new Error(`no package.json found in current work dir: ${cwd}`);
+    return external_path_default().dirname(pkg);
+};
+exports.initAppDir = __webpack_exports__.initAppDir;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initAppDir"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});