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

package/dist/cjs/cli/is/project.js

@@ -0,0 +1,147 @@
+"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__, {
+    getReactVersion: ()=>getReactVersion,
+    isApiOnly: ()=>isApiOnly,
+    isBeyondReact17: ()=>isBeyondReact17,
+    isDepExists: ()=>isDepExists,
+    isPackageInstalled: ()=>isPackageInstalled,
+    isReact18: ()=>isReact18,
+    isSupportAutomaticJsx: ()=>isSupportAutomaticJsx,
+    isTypescript: ()=>isTypescript,
+    isVersionBeyond17: ()=>isVersionBeyond17,
+    isWebOnly: ()=>isWebOnly
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const index_js_namespaceObject = require("../../../compiled/pkg-up/index.js");
+var index_js_default = /*#__PURE__*/ __webpack_require__.n(index_js_namespaceObject);
+const external_compiled_js_namespaceObject = require("../../compiled.js");
+const external_commands_js_namespaceObject = require("../commands.js");
+const external_common_js_namespaceObject = require("../common.js");
+const external_ensure_js_namespaceObject = require("../ensure.js");
+const external_require_js_namespaceObject = require("../require.js");
+const debug = (0, external_common_js_namespaceObject.createDebugger)('judge-depExists');
+const isDepExists = (appDirectory, name)=>{
+    const pkgPath = external_path_default().resolve(appDirectory, './package.json');
+    if (!external_compiled_js_namespaceObject.fs.existsSync(pkgPath)) {
+        debug("can't find package.json under: %s", appDirectory);
+        return false;
+    }
+    const json = external_compiled_js_namespaceObject.fs.readJSONSync(pkgPath);
+    const { dependencies = {}, devDependencies = {} } = json;
+    return dependencies.hasOwnProperty(name) || devDependencies.hasOwnProperty(name);
+};
+const isPackageInstalled = (name, resolvePaths)=>{
+    try {
+        (0, external_require_js_namespaceObject.tryResolve)(name, ...(0, external_ensure_js_namespaceObject.ensureArray)(resolvePaths));
+        return true;
+    } catch (err) {
+        return false;
+    }
+};
+const isApiOnly = async (appDirectory, entryDir, apiDir)=>{
+    const existApi = await external_compiled_js_namespaceObject.fs.pathExists(apiDir ?? external_path_default().join(appDirectory, 'api'));
+    const existSrc = await external_compiled_js_namespaceObject.fs.pathExists(external_path_default().join(appDirectory, entryDir ?? 'src'));
+    const options = (0, external_compiled_js_namespaceObject.minimist)((0, external_commands_js_namespaceObject.getArgv)());
+    if (options['api-only']) return true;
+    return existApi && !existSrc;
+};
+const isWebOnly = async ()=>{
+    const options = (0, external_compiled_js_namespaceObject.minimist)((0, external_commands_js_namespaceObject.getArgv)());
+    return Boolean(options['web-only']);
+};
+const isVersionBeyond17 = (version)=>external_compiled_js_namespaceObject.semver.gte(external_compiled_js_namespaceObject.semver.minVersion(version), '17.0.0');
+const getReactVersion = (cwd)=>{
+    const pkgPath = index_js_default().sync({
+        cwd
+    });
+    if (!pkgPath) return false;
+    const pkgInfo = JSON.parse(external_compiled_js_namespaceObject.fs.readFileSync(pkgPath, 'utf8'));
+    const deps = {
+        ...pkgInfo.devDependencies,
+        ...pkgInfo.dependencies
+    };
+    if ('string' != typeof deps.react) return false;
+    try {
+        const reactPath = (0, external_require_js_namespaceObject.tryResolve)('react/package.json', cwd);
+        const reactVersion = JSON.parse(external_compiled_js_namespaceObject.fs.readFileSync(reactPath, 'utf8')).version;
+        return reactVersion;
+    } catch (error) {
+        console.error('Failed to resolve React version:', error);
+        return false;
+    }
+};
+const isBeyondReact17 = (cwd)=>{
+    const reactVersion = getReactVersion(cwd);
+    if (!reactVersion) return false;
+    return isVersionBeyond17(reactVersion);
+};
+const isSupportAutomaticJsx = (cwd)=>{
+    const reactVersion = getReactVersion(cwd);
+    if (!reactVersion) return false;
+    return external_compiled_js_namespaceObject.semver.satisfies(external_compiled_js_namespaceObject.semver.minVersion(reactVersion), '>=16.14.0');
+};
+const isReact18 = (cwd = process.cwd())=>{
+    const reactVersion = getReactVersion(cwd);
+    if (!reactVersion) return false;
+    return external_compiled_js_namespaceObject.semver.gte(external_compiled_js_namespaceObject.semver.minVersion(reactVersion), '18.0.0');
+};
+const isTypescript = (root)=>external_compiled_js_namespaceObject.fs.existsSync(external_path_default().resolve(root, './tsconfig.json'));
+exports.getReactVersion = __webpack_exports__.getReactVersion;
+exports.isApiOnly = __webpack_exports__.isApiOnly;
+exports.isBeyondReact17 = __webpack_exports__.isBeyondReact17;
+exports.isDepExists = __webpack_exports__.isDepExists;
+exports.isPackageInstalled = __webpack_exports__.isPackageInstalled;
+exports.isReact18 = __webpack_exports__.isReact18;
+exports.isSupportAutomaticJsx = __webpack_exports__.isSupportAutomaticJsx;
+exports.isTypescript = __webpack_exports__.isTypescript;
+exports.isVersionBeyond17 = __webpack_exports__.isVersionBeyond17;
+exports.isWebOnly = __webpack_exports__.isWebOnly;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getReactVersion",
+    "isApiOnly",
+    "isBeyondReact17",
+    "isDepExists",
+    "isPackageInstalled",
+    "isReact18",
+    "isSupportAutomaticJsx",
+    "isTypescript",
+    "isVersionBeyond17",
+    "isWebOnly"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/is/type.js

@@ -0,0 +1,84 @@
+"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__, {
+    isArray: ()=>isArray,
+    isEmpty: ()=>isEmpty,
+    isFunction: ()=>isFunction,
+    isObject: ()=>isObject,
+    isPlainObject: ()=>isPlainObject,
+    isPromise: ()=>isPromise,
+    isRegExp: ()=>isRegExp,
+    isString: ()=>isString,
+    isUndefined: ()=>isUndefined
+});
+function isString(str) {
+    return 'string' == typeof str;
+}
+function isUndefined(obj) {
+    return void 0 === obj;
+}
+function isArray(obj) {
+    return Array.isArray(obj);
+}
+function isFunction(func) {
+    return 'function' == typeof func;
+}
+function isObject(obj) {
+    return null !== obj && 'object' == typeof obj;
+}
+function isPlainObject(obj) {
+    return isObject(obj) && '[object Object]' === Object.prototype.toString.call(obj);
+}
+function isPromise(obj) {
+    return Boolean(obj) && ('object' == typeof obj || 'function' == typeof obj) && 'function' == typeof obj.then;
+}
+function isRegExp(obj) {
+    return '[object RegExp]' === Object.prototype.toString.call(obj);
+}
+const isEmpty = (o)=>0 === Object.entries(o).length && o.constructor === Object;
+exports.isArray = __webpack_exports__.isArray;
+exports.isEmpty = __webpack_exports__.isEmpty;
+exports.isFunction = __webpack_exports__.isFunction;
+exports.isObject = __webpack_exports__.isObject;
+exports.isPlainObject = __webpack_exports__.isPlainObject;
+exports.isPromise = __webpack_exports__.isPromise;
+exports.isRegExp = __webpack_exports__.isRegExp;
+exports.isString = __webpack_exports__.isString;
+exports.isUndefined = __webpack_exports__.isUndefined;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isArray",
+    "isEmpty",
+    "isFunction",
+    "isObject",
+    "isPlainObject",
+    "isPromise",
+    "isRegExp",
+    "isString",
+    "isUndefined"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/logger.js

@@ -0,0 +1,39 @@
+"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__, {
+    createLogger: ()=>external_rslog_namespaceObject.createLogger,
+    logger: ()=>external_rslog_namespaceObject.logger
+});
+const external_rslog_namespaceObject = require("rslog");
+exports.createLogger = __webpack_exports__.createLogger;
+exports.logger = __webpack_exports__.logger;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createLogger",
+    "logger"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/modulePath.js

@@ -0,0 +1,87 @@
+"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__, {
+    JS_LIKE_EXTENSION_RE: ()=>JS_LIKE_EXTENSION_RE,
+    SOURCE_EXTENSIONS: ()=>SOURCE_EXTENSIONS,
+    findMatchedSourcePath: ()=>findMatchedSourcePath,
+    findSourceEntry: ()=>findSourceEntry
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const SOURCE_EXTENSIONS = [
+    '.ts',
+    '.js'
+];
+const JS_LIKE_EXTENSION_RE = /\.(?:c|m)?js$/;
+const isFile = (filepath)=>external_node_fs_default().existsSync(filepath) && external_node_fs_default().statSync(filepath).isFile();
+const findSourceEntry = (resolvedPath)=>{
+    const ext = external_node_path_default().extname(resolvedPath);
+    if (ext) {
+        if (isFile(resolvedPath)) return resolvedPath;
+        if (JS_LIKE_EXTENSION_RE.test(resolvedPath)) {
+            const tsPath = `${resolvedPath.slice(0, -ext.length)}.ts`;
+            if (isFile(tsPath)) return tsPath;
+        }
+        return;
+    }
+    for (const candidateExt of SOURCE_EXTENSIONS){
+        const filePath = `${resolvedPath}${candidateExt}`;
+        if (isFile(filePath)) return filePath;
+    }
+    for (const candidateExt of SOURCE_EXTENSIONS){
+        const indexPath = external_node_path_default().join(resolvedPath, `index${candidateExt}`);
+        if (isFile(indexPath)) return indexPath;
+    }
+};
+const findMatchedSourcePath = (matchPath, specifier)=>{
+    let matchedPath = matchPath(specifier, void 0, void 0, SOURCE_EXTENSIONS);
+    if (!matchedPath && JS_LIKE_EXTENSION_RE.test(specifier)) matchedPath = matchPath(specifier.replace(JS_LIKE_EXTENSION_RE, ''), void 0, void 0, SOURCE_EXTENSIONS);
+    return matchedPath;
+};
+exports.JS_LIKE_EXTENSION_RE = __webpack_exports__.JS_LIKE_EXTENSION_RE;
+exports.SOURCE_EXTENSIONS = __webpack_exports__.SOURCE_EXTENSIONS;
+exports.findMatchedSourcePath = __webpack_exports__.findMatchedSourcePath;
+exports.findSourceEntry = __webpack_exports__.findSourceEntry;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "JS_LIKE_EXTENSION_RE",
+    "SOURCE_EXTENSIONS",
+    "findMatchedSourcePath",
+    "findSourceEntry"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/monorepo.js

@@ -0,0 +1,110 @@
+"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__, {
+    findMonorepoRoot: ()=>findMonorepoRoot,
+    getMonorepoPackages: ()=>getMonorepoPackages,
+    isLerna: ()=>isLerna,
+    isMonorepo: ()=>isMonorepo,
+    isPnpmWorkspaces: ()=>isPnpmWorkspaces,
+    isYarnWorkspaces: ()=>isYarnWorkspaces
+});
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_compiled_js_namespaceObject = require("../compiled.js");
+const PACKAGE_MAX_DEPTH = 5;
+const WORKSPACE_FILES = {
+    YARN: 'package.json',
+    PNPM: 'pnpm-workspace.yaml',
+    LERNA: 'lerna.json'
+};
+const isLerna = (root)=>external_fs_default().existsSync(external_path_default().join(root, WORKSPACE_FILES.LERNA));
+const isYarnWorkspaces = (root)=>{
+    const pkg = external_path_default().join(root, WORKSPACE_FILES.YARN);
+    if (!external_fs_default().existsSync(pkg)) return false;
+    const json = JSON.parse(external_fs_default().readFileSync(pkg, 'utf8'));
+    return Boolean(json.workspaces?.packages);
+};
+const isPnpmWorkspaces = (root)=>external_fs_default().existsSync(external_path_default().join(root, WORKSPACE_FILES.PNPM));
+const isMonorepo = (root)=>isLerna(root) || isYarnWorkspaces(root) || isPnpmWorkspaces(root);
+const findMonorepoRoot = (appDirectory, maxDepth = PACKAGE_MAX_DEPTH)=>{
+    let inMonorepo = false;
+    let monorepoRoot = appDirectory;
+    for(let depth = 0; depth < maxDepth; depth++){
+        if (isMonorepo(appDirectory)) {
+            inMonorepo = true;
+            break;
+        }
+        monorepoRoot = external_path_default().dirname(appDirectory);
+    }
+    return inMonorepo ? monorepoRoot : void 0;
+};
+const getMonorepoPackages = (root)=>{
+    let packages = [];
+    if (isYarnWorkspaces(root)) {
+        const json = JSON.parse(external_fs_default().readFileSync(external_path_default().join(root, 'package.json'), 'utf8'));
+        ({ packages } = json.workspaces);
+    } else if (isLerna(root)) {
+        const json = JSON.parse(external_fs_default().readFileSync(external_path_default().resolve(root, 'lerna.json'), 'utf8'));
+        ({ packages } = json);
+    } else ({ packages } = external_compiled_js_namespaceObject.yaml.load(external_fs_default().readFileSync(external_path_default().join(root, WORKSPACE_FILES.PNPM), 'utf8')));
+    if (packages) return packages.map((name)=>external_compiled_js_namespaceObject.glob.sync(external_path_default().join(root, `${name}/`), {
+            ignore: [
+                '**/node_modules/**'
+            ]
+        })).reduce((acc, val)=>acc.concat(val), []).filter((filepath)=>external_fs_default().existsSync(external_path_default().resolve(filepath, 'package.json'))).map((filepath)=>({
+            path: filepath,
+            name: JSON.parse(external_fs_default().readFileSync(external_path_default().resolve(filepath, 'package.json'), 'utf8')).name
+        }));
+    return [];
+};
+exports.findMonorepoRoot = __webpack_exports__.findMonorepoRoot;
+exports.getMonorepoPackages = __webpack_exports__.getMonorepoPackages;
+exports.isLerna = __webpack_exports__.isLerna;
+exports.isMonorepo = __webpack_exports__.isMonorepo;
+exports.isPnpmWorkspaces = __webpack_exports__.isPnpmWorkspaces;
+exports.isYarnWorkspaces = __webpack_exports__.isYarnWorkspaces;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "findMonorepoRoot",
+    "getMonorepoPackages",
+    "isLerna",
+    "isMonorepo",
+    "isPnpmWorkspaces",
+    "isYarnWorkspaces"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/package.js

@@ -0,0 +1,97 @@
+"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__, {
+    canUseNpm: ()=>canUseNpm,
+    canUsePnpm: ()=>canUsePnpm,
+    canUseYarn: ()=>canUseYarn,
+    getPnpmVersion: ()=>getPnpmVersion,
+    removeModuleSyncFromExports: ()=>removeModuleSyncFromExports
+});
+const external_compiled_js_namespaceObject = require("../compiled.js");
+async function getPnpmVersion() {
+    const { stdout } = await (0, external_compiled_js_namespaceObject.execa)('pnpm', [
+        '--version'
+    ]);
+    return stdout;
+}
+async function canUseNpm() {
+    try {
+        await (0, external_compiled_js_namespaceObject.execa)('npm', [
+            '--version'
+        ], {
+            env: process.env
+        });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+async function canUseYarn() {
+    try {
+        await (0, external_compiled_js_namespaceObject.execa)('yarn', [
+            '--version'
+        ], {
+            env: process.env
+        });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+async function canUsePnpm() {
+    try {
+        await (0, external_compiled_js_namespaceObject.execa)('pnpm', [
+            '--version'
+        ], {
+            env: process.env
+        });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function removeModuleSyncFromExports(exports1) {
+    if ('object' != typeof exports1 || null === exports1) return exports1;
+    if (Array.isArray(exports1)) return exports1.map(removeModuleSyncFromExports);
+    const result = {};
+    for (const [key, value] of Object.entries(exports1))if ('module-sync' !== key) result[key] = removeModuleSyncFromExports(value);
+    return result;
+}
+exports.canUseNpm = __webpack_exports__.canUseNpm;
+exports.canUsePnpm = __webpack_exports__.canUsePnpm;
+exports.canUseYarn = __webpack_exports__.canUseYarn;
+exports.getPnpmVersion = __webpack_exports__.getPnpmVersion;
+exports.removeModuleSyncFromExports = __webpack_exports__.removeModuleSyncFromExports;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "canUseNpm",
+    "canUsePnpm",
+    "canUseYarn",
+    "getPnpmVersion",
+    "removeModuleSyncFromExports"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/path.js

@@ -0,0 +1,111 @@
+"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__, {
+    formatImportPath: ()=>formatImportPath,
+    getRealTemporaryDirectory: ()=>getRealTemporaryDirectory,
+    getTemplatePath: ()=>getTemplatePath,
+    isPathString: ()=>isPathString,
+    isRelativePath: ()=>isRelativePath,
+    normalizeOutputPath: ()=>normalizeOutputPath,
+    normalizeToPosixPath: ()=>normalizeToPosixPath,
+    removeLeadingSlash: ()=>removeLeadingSlash,
+    removeSlash: ()=>removeSlash,
+    removeTailSlash: ()=>removeTailSlash,
+    splitPathString: ()=>splitPathString
+});
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const external_os_namespaceObject = require("os");
+var external_os_default = /*#__PURE__*/ __webpack_require__.n(external_os_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_compiled_js_namespaceObject = require("../compiled.js");
+const isPathString = (test)=>external_path_default().posix.basename(test) !== test || external_path_default().win32.basename(test) !== test;
+const isRelativePath = (test)=>/^\.\.?($|[\\/])/.test(test);
+const normalizeOutputPath = (s)=>s.replace(/\\/g, '\\\\');
+const normalizeToPosixPath = (p)=>external_compiled_js_namespaceObject.upath.normalizeSafe(external_path_default().normalize(p || '')).replace(/^([a-zA-Z]+):/, (_, m)=>`/${m.toLowerCase()}`);
+const getTemplatePath = (prefix)=>{
+    const tmpRoot = external_fs_default().realpathSync(external_os_default().tmpdir());
+    const parts = [
+        tmpRoot
+    ];
+    prefix && parts.push(prefix);
+    parts.push((0, external_compiled_js_namespaceObject.nanoid)());
+    return external_path_default().resolve(...parts);
+};
+function getRealTemporaryDirectory() {
+    let ret = null;
+    try {
+        ret = external_os_default().tmpdir();
+        ret = external_fs_default().realpathSync(ret);
+    } catch  {}
+    return ret;
+}
+function splitPathString(str) {
+    return str.split(/[\\/]/);
+}
+const removeLeadingSlash = (s)=>s.replace(/^\/+/, '');
+const removeTailSlash = (s)=>s.replace(/\/+$/, '');
+const removeSlash = (s)=>removeLeadingSlash(removeTailSlash(s));
+function formatImportPath(str) {
+    return str.replace(/\\/g, '/');
+}
+exports.formatImportPath = __webpack_exports__.formatImportPath;
+exports.getRealTemporaryDirectory = __webpack_exports__.getRealTemporaryDirectory;
+exports.getTemplatePath = __webpack_exports__.getTemplatePath;
+exports.isPathString = __webpack_exports__.isPathString;
+exports.isRelativePath = __webpack_exports__.isRelativePath;
+exports.normalizeOutputPath = __webpack_exports__.normalizeOutputPath;
+exports.normalizeToPosixPath = __webpack_exports__.normalizeToPosixPath;
+exports.removeLeadingSlash = __webpack_exports__.removeLeadingSlash;
+exports.removeSlash = __webpack_exports__.removeSlash;
+exports.removeTailSlash = __webpack_exports__.removeTailSlash;
+exports.splitPathString = __webpack_exports__.splitPathString;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "formatImportPath",
+    "getRealTemporaryDirectory",
+    "getTemplatePath",
+    "isPathString",
+    "isRelativePath",
+    "normalizeOutputPath",
+    "normalizeToPosixPath",
+    "removeLeadingSlash",
+    "removeSlash",
+    "removeTailSlash",
+    "splitPathString"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});