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

package/dist/cjs/cli/port.js

@@ -0,0 +1,79 @@
+"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__, {
+    getPort: ()=>getPort
+});
+const external_net_namespaceObject = require("net");
+var external_net_default = /*#__PURE__*/ __webpack_require__.n(external_net_namespaceObject);
+const external_compiled_js_namespaceObject = require("../compiled.js");
+const external_logger_js_namespaceObject = require("./logger.js");
+const getPort = async (expectPort, { tryLimits = 20, strictPort = false, slient = false } = {})=>{
+    let port = expectPort;
+    if ('string' == typeof port) port = parseInt(port, 10);
+    if (strictPort) tryLimits = 1;
+    const original = port;
+    let found = false;
+    let attempts = 0;
+    while(!found && attempts <= tryLimits)try {
+        await new Promise((resolve, reject)=>{
+            const server = external_net_default().createServer();
+            server.unref();
+            server.on('error', reject);
+            server.listen({
+                port,
+                host: '0.0.0.0'
+            }, ()=>{
+                found = true;
+                server.close(resolve);
+            });
+        });
+    } catch (e) {
+        if ('EADDRINUSE' !== e.code) throw e;
+        port++;
+        attempts++;
+    }
+    if (port !== original) {
+        if (strictPort) throw new Error(`Port "${original}" is occupied, please choose another one.`);
+        else if (!slient) external_logger_js_namespaceObject.logger.info(`Port ${original} is in use. ${external_compiled_js_namespaceObject.chalk.yellow(`using port ${port}.`)}`);
+    }
+    return port;
+};
+exports.getPort = __webpack_exports__.getPort;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getPort"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/prettyInstructions.js

@@ -0,0 +1,117 @@
+"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__, {
+    getAddressUrls: ()=>getAddressUrls,
+    prettyInstructions: ()=>prettyInstructions
+});
+const external_net_namespaceObject = require("net");
+const external_os_namespaceObject = require("os");
+var external_os_default = /*#__PURE__*/ __webpack_require__.n(external_os_namespaceObject);
+const external_compiled_js_namespaceObject = require("../compiled.js");
+const external_constants_js_namespaceObject = require("./constants.js");
+const index_js_namespaceObject = require("./is/index.js");
+const normalizeUrl = (url)=>url.replace(/([^:]\/)\/+/g, '$1');
+const getIpv4Interfaces = ()=>{
+    const interfaces = external_os_default().networkInterfaces();
+    const ipv4Interfaces = [];
+    Object.keys(interfaces).forEach((key)=>{
+        interfaces[key].forEach((detail)=>{
+            const familyV4Value = 'string' == typeof detail.family ? 'IPv4' : 4;
+            if (detail.family === familyV4Value) ipv4Interfaces.push(detail);
+        });
+    });
+    return ipv4Interfaces;
+};
+const getHostInUrl = (host)=>{
+    if ((0, external_net_namespaceObject.isIPv6)(host)) return '::' === host ? '[::1]' : `[${host}]`;
+    return host;
+};
+const getAddressUrls = (protocol = 'http', port, host)=>{
+    const LOCAL_LABEL = 'Local:  ';
+    const NETWORK_LABEL = 'Network:  ';
+    const isLocalhost = (url)=>url?.includes('localhost');
+    if (host && host !== external_constants_js_namespaceObject.DEFAULT_DEV_HOST) return [
+        {
+            label: isLocalhost(host) ? LOCAL_LABEL : NETWORK_LABEL,
+            url: `${protocol}://${getHostInUrl(host)}:${port}`
+        }
+    ];
+    const ipv4Interfaces = getIpv4Interfaces();
+    return ipv4Interfaces.reduce((memo, detail)=>{
+        if (isLocalhost(detail.address) || detail.internal) memo.push({
+            label: LOCAL_LABEL,
+            url: `${protocol}://localhost:${port}`
+        });
+        else memo.push({
+            label: NETWORK_LABEL,
+            url: `${protocol}://${detail.address}:${port}`
+        });
+        return memo;
+    }, []);
+};
+const prettyInstructions = (appContext, config)=>{
+    const { entrypoints, serverRoutes, port, apiOnly, checkedEntries } = appContext;
+    const isHttps = (0, index_js_namespaceObject.isDev)() && (config?.dev?.https || config?.tools?.devServer?.https);
+    const urls = getAddressUrls(isHttps ? 'https' : 'http', port, config.dev?.host);
+    const routes = apiOnly ? serverRoutes : serverRoutes.filter((route)=>route.entryName);
+    let message = '\n';
+    if ((0, index_js_namespaceObject.isSingleEntry)(entrypoints, config.source?.mainEntryName) || apiOnly) {
+        const defaultRoutePath = routes[0]?.urlPath ?? '';
+        message += urls.map(({ label, url })=>`  ${external_compiled_js_namespaceObject.chalk.bold(`> ${label.padEnd(10)}`)}${external_compiled_js_namespaceObject.chalk.cyanBright(normalizeUrl(`${url}/${defaultRoutePath}`))}\n`).join('');
+    } else {
+        const maxNameLength = Math.max(...routes.map((r)=>r.entryName.length));
+        urls.forEach(({ label, url })=>{
+            message += `  ${external_compiled_js_namespaceObject.chalk.bold(`> ${label}`)}${0 === routes.length ? external_compiled_js_namespaceObject.chalk.cyanBright(url) : ''}\n`;
+            routes.forEach(({ entryName, urlPath, isSSR })=>{
+                if (!checkedEntries.includes(entryName)) return;
+                message += `    ${external_compiled_js_namespaceObject.chalk.yellowBright(isSSR ? 'λ' : '○')}  ${external_compiled_js_namespaceObject.chalk.yellowBright(entryName.padEnd(maxNameLength + 8))}${external_compiled_js_namespaceObject.chalk.cyanBright(normalizeUrl(`${url}/${urlPath}`))}\n`;
+            });
+        });
+        message += '\n';
+        message += external_compiled_js_namespaceObject.chalk.cyanBright('  λ (Server) server-side renders at runtime\n');
+        message += external_compiled_js_namespaceObject.chalk.cyanBright('  ○ (Static) client-side renders as static HTML\n');
+    }
+    if (config.dev?.cliShortcuts) message += `  ${external_compiled_js_namespaceObject.chalk.dim('> press')} ${external_compiled_js_namespaceObject.chalk.bold('h + enter')} ${external_compiled_js_namespaceObject.chalk.dim('to show shortcuts')}\n`;
+    return message;
+};
+exports.getAddressUrls = __webpack_exports__.getAddressUrls;
+exports.prettyInstructions = __webpack_exports__.prettyInstructions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getAddressUrls",
+    "prettyInstructions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/require.js

@@ -0,0 +1,127 @@
+"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__, {
+    cleanRequireCache: ()=>cleanRequireCache,
+    compatibleRequire: ()=>compatibleRequire,
+    dynamicImport: ()=>dynamicImport,
+    loadFromProject: ()=>loadFromProject,
+    requireExistModule: ()=>requireExistModule,
+    tryResolve: ()=>tryResolve
+});
+const promises_namespaceObject = require("node:fs/promises");
+const external_node_path_namespaceObject = require("node:path");
+const external_node_url_namespaceObject = require("node:url");
+const external_fs_js_namespaceObject = require("./fs.js");
+async function importPath(path) {
+    const modulePath = (0, external_node_path_namespaceObject.isAbsolute)(path) ? (0, external_node_url_namespaceObject.pathToFileURL)(path).href : path;
+    if ('development' !== process.env.NODE_ENV) return await import(modulePath);
+    {
+        const timestamp = Date.now();
+        return await import(`${modulePath}?t=${timestamp}`);
+    }
+}
+async function compatibleRequireESM(path, interop = true) {
+    if (path.endsWith('.json')) return JSON.parse(await (0, promises_namespaceObject.readFile)(path, 'utf8'));
+    const requiredModule = await importPath(path);
+    return interop ? requiredModule.default : requiredModule;
+}
+async function compatibleRequireCJS(path, interop = true) {
+    if (path.endsWith('.json')) return require(path);
+    try {
+        const requiredModule = require(path);
+        return interop && requiredModule?.__esModule ? requiredModule.default : requiredModule;
+    } catch (err) {
+        if ('ERR_REQUIRE_ESM' === err.code) return await compatibleRequireESM(path, interop);
+        throw err;
+    }
+}
+async function compatibleRequire(path, interop = true) {
+    return await compatibleRequireCJS(path, interop);
+}
+async function loadFromProject(moduleName, appDir) {
+    let requiredModule;
+    const paths = [
+        appDir,
+        process.cwd()
+    ];
+    try {
+        const modulePath = tryResolve(moduleName, ...paths);
+        requiredModule = require(modulePath);
+        return requiredModule.default || requiredModule;
+    } catch (error) {
+        if ('MODULE_NOT_FOUND' === error.code) throw new Error(`Cannot find module ${moduleName}.`);
+        throw error;
+    }
+}
+const dynamicImport = new Function('modulePath', 'return import(modulePath)');
+const requireExistModule = async (filename, opt)=>{
+    const final = {
+        extensions: [
+            '.ts',
+            '.js'
+        ],
+        interop: true,
+        ...opt
+    };
+    const exist = (0, external_fs_js_namespaceObject.findExists)(final.extensions.map((ext)=>`${filename}${ext}`));
+    if (!exist) return null;
+    return compatibleRequire(exist, final.interop);
+};
+const cleanRequireCache = (filelist)=>{
+    filelist.forEach((filepath)=>{
+        if (require.cache) delete require.cache[filepath];
+    });
+};
+const tryResolve = (name, ...resolvePath)=>{
+    let filePath = '';
+    try {
+        filePath = require.resolve(name, {
+            paths: resolvePath
+        });
+        delete require.cache[filePath];
+    } catch (err) {
+        if ('MODULE_NOT_FOUND' === err.code) throw new Error(`Can not find module ${name}.`);
+        throw err;
+    }
+    return filePath;
+};
+exports.cleanRequireCache = __webpack_exports__.cleanRequireCache;
+exports.compatibleRequire = __webpack_exports__.compatibleRequire;
+exports.dynamicImport = __webpack_exports__.dynamicImport;
+exports.loadFromProject = __webpack_exports__.loadFromProject;
+exports.requireExistModule = __webpack_exports__.requireExistModule;
+exports.tryResolve = __webpack_exports__.tryResolve;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "cleanRequireCache",
+    "compatibleRequire",
+    "dynamicImport",
+    "loadFromProject",
+    "requireExistModule",
+    "tryResolve"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/route.js

@@ -0,0 +1,76 @@
+"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__, {
+    filterRoutesForServer: ()=>filterRoutesForServer,
+    filterRoutesLoader: ()=>filterRoutesLoader,
+    markRoutes: ()=>markRoutes
+});
+const external_compiled_js_namespaceObject = require("../compiled.js");
+const { cloneDeep } = external_compiled_js_namespaceObject.lodash;
+function filterRoutesForServer(routes) {
+    const clonedRoutes = cloneDeep(routes);
+    const newRoutes = clonedRoutes.map((route)=>{
+        if ('nested' !== route.type) return route;
+        if (route.children && route.children.length > 0) route.children = filterRoutesForServer(route.children);
+        if (route.inValidSSRRoute) return null;
+        return route;
+    }).filter((route)=>null !== route);
+    return newRoutes;
+}
+function filterRoutesLoader(routes) {
+    const clonedRoutes = cloneDeep(routes);
+    const newRoutes = clonedRoutes.map((route)=>{
+        if ('nested' !== route.type) return route;
+        if (route.children && route.children.length > 0) route.children = filterRoutesLoader(route.children);
+        if (route.inValidSSRRoute) {
+            delete route.loader;
+            delete route.data;
+            delete route.action;
+        }
+        return route;
+    }).filter((route)=>null !== route);
+    return newRoutes;
+}
+function markRoutes(routes, routeIds) {
+    return routes.map((route)=>{
+        if ('nested' !== route.type) return route;
+        if (route.children && route.children.length > 0) route.children = markRoutes(route.children, routeIds);
+        if (route.children && route.children.length > 0) route.inValidSSRRoute = route.children.every((child)=>child.inValidSSRRoute ?? false);
+        else if (route.id) route.inValidSSRRoute = !routeIds.includes(route.id);
+        return route;
+    });
+}
+exports.filterRoutesForServer = __webpack_exports__.filterRoutesForServer;
+exports.filterRoutesLoader = __webpack_exports__.filterRoutesLoader;
+exports.markRoutes = __webpack_exports__.markRoutes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "filterRoutesForServer",
+    "filterRoutesLoader",
+    "markRoutes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/runtimeExports.js

@@ -0,0 +1,86 @@
+"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__, {
+    createRuntimeExportsUtils: ()=>createRuntimeExportsUtils
+});
+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 external_path_js_namespaceObject = require("./path.js");
+const memo = (fn)=>{
+    const cache = new Map();
+    return (...params)=>{
+        const stringifiedParams = JSON.stringify(params);
+        const cachedResult = cache.get(stringifiedParams);
+        if (cachedResult) return cachedResult;
+        const res = fn(...params);
+        cache.set(stringifiedParams, res);
+        return res;
+    };
+};
+const ensureRuntimeExportsFile = (filepath)=>{
+    external_compiled_js_namespaceObject.fs.ensureDirSync(external_path_default().dirname(filepath));
+    if (!external_compiled_js_namespaceObject.fs.existsSync(filepath)) external_compiled_js_namespaceObject.fs.writeFileSync(filepath, 'export {};\n');
+};
+const formatRuntimeExports = (exportsList)=>{
+    if (0 === exportsList.length) return 'export {};\n';
+    return `${exportsList.join('\n')}\n`;
+};
+const flushRuntimeExports = (filepath, exportsSet)=>{
+    external_compiled_js_namespaceObject.fs.writeFileSync(filepath, formatRuntimeExports(Array.from(exportsSet)));
+};
+const createRuntimeExportsUtils = memo((internalDirectory, filename)=>{
+    const filepath = external_path_default().resolve(internalDirectory, `${filename}.ts`);
+    const exportsSet = new Set();
+    ensureRuntimeExportsFile(filepath);
+    return {
+        addExport (exportStatement) {
+            const normalized = exportStatement?.trim();
+            if (!normalized) return;
+            exportsSet.add(normalized);
+            flushRuntimeExports(filepath, exportsSet);
+        },
+        getPath () {
+            return (0, external_path_js_namespaceObject.normalizeOutputPath)(filepath);
+        }
+    };
+});
+exports.createRuntimeExportsUtils = __webpack_exports__.createRuntimeExportsUtils;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRuntimeExportsUtils"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/tsconfig.js

@@ -0,0 +1,51 @@
+"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__, {
+    resolveServerTsconfig: ()=>resolveServerTsconfig
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_constants_js_namespaceObject = require("./constants.js");
+const resolveServerTsconfig = (appDirectory, configuredPath)=>{
+    if (configuredPath) return external_path_default().isAbsolute(configuredPath) ? configuredPath : external_path_default().resolve(appDirectory, configuredPath);
+    return external_path_default().resolve(appDirectory, external_constants_js_namespaceObject.TS_CONFIG_FILENAME);
+};
+exports.resolveServerTsconfig = __webpack_exports__.resolveServerTsconfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveServerTsconfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/version.js

@@ -0,0 +1,67 @@
+"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__, {
+    isVersionAtLeast18: ()=>isVersionAtLeast18,
+    isVersionAtLeast1819: ()=>isVersionAtLeast1819,
+    isVersionAtLeast20: ()=>isVersionAtLeast20,
+    isVersionAtLeast22: ()=>isVersionAtLeast22
+});
+const parseNodeVersion = ()=>{
+    const [major = 0, minor = 0] = process.versions.node.split('.').map(Number);
+    return {
+        major,
+        minor
+    };
+};
+function isVersionAtLeast1819() {
+    const { major, minor } = parseNodeVersion();
+    return major > 18 || 18 === major && minor >= 19;
+}
+function isVersionAtLeast18() {
+    const { major } = parseNodeVersion();
+    return major >= 18;
+}
+function isVersionAtLeast22() {
+    const { major } = parseNodeVersion();
+    return major >= 22;
+}
+function isVersionAtLeast20() {
+    const { major } = parseNodeVersion();
+    return major >= 20;
+}
+exports.isVersionAtLeast18 = __webpack_exports__.isVersionAtLeast18;
+exports.isVersionAtLeast1819 = __webpack_exports__.isVersionAtLeast1819;
+exports.isVersionAtLeast20 = __webpack_exports__.isVersionAtLeast20;
+exports.isVersionAtLeast22 = __webpack_exports__.isVersionAtLeast22;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isVersionAtLeast18",
+    "isVersionAtLeast1819",
+    "isVersionAtLeast20",
+    "isVersionAtLeast22"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});