@rsbuild/core 1.4.1 → 1.4.2

package/dist/index.js

@@ -1,5 +1,5 @@
 /*! For license information please see index.js.LICENSE.txt */
-let swcHelpersPath, pluginHelper_htmlPlugin, cssExtractPlugin;
+let swcHelpersPath, pluginHelper_htmlPlugin, cssExtractPlugin, isDockerCached, cachedResult;
 import { rspack } from "@rspack/core";
 import { logger } from "../compiled/rslog/index.js";
 import node_path, { dirname, isAbsolute as external_node_path_isAbsolute, join, posix, relative, sep } from "node:path";
@@ -12,9 +12,12 @@ import node_os, { constants } from "node:os";
 import node_process from "node:process";
 import rspack_chain from "../compiled/rspack-chain/index.js";
 import { isPromise, isRegExp } from "node:util/types";
-import { promisify as external_node_util_promisify } from "node:util";
+import node_util, { promisify as external_node_util_promisify } from "node:util";
 import { lookup } from "../compiled/mrmime/index.js";
 import node_zlib from "node:zlib";
+import { Buffer as external_node_buffer_Buffer } from "node:buffer";
+import node_child_process, { execFile } from "node:child_process";
+import promises, { constants as promises_constants } from "node:fs/promises";
 var EsmMode, __webpack_modules__ = {
     "../../node_modules/.pnpm/clone-deep@4.0.1/node_modules/clone-deep/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
         let clone = __webpack_require__("../../node_modules/.pnpm/shallow-clone@3.0.1/node_modules/shallow-clone/index.js"), typeOf = __webpack_require__("../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js"), isPlainObject = __webpack_require__("../../node_modules/.pnpm/is-plain-object@2.0.4/node_modules/is-plain-object/index.js");
@@ -2059,7 +2062,7 @@ async function updateEnvironmentContext(context, configs) {
 async function createContext(options, userConfig) {
     let { cwd } = options, rootPath = userConfig.root ? ensureAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = join(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0, bundlerType = userConfig.provider ? 'webpack' : 'rspack';
     return {
-        version: "1.4.1",
+        version: "1.4.2",
         rootPath,
         distPath: '',
         cachePath,
@@ -3227,7 +3230,322 @@ let getInlineTests = (config)=>{
         scriptTests,
         styleTests
     };
-}, normalizeUrl = (url)=>url.replace(/([^:]\/)\/+/g, '$1'), joinUrlSegments = (s1, s2)=>s1 && s2 ? addTrailingSlash(s1) + removeLeadingSlash(s2) : s1 || s2 || '', stripBase = (path, base)=>{
+};
+function isInsideContainer() {
+    return void 0 === cachedResult && (cachedResult = (()=>{
+        try {
+            return node_fs.statSync('/run/.containerenv'), !0;
+        } catch  {
+            return !1;
+        }
+    })() || (void 0 === isDockerCached && (isDockerCached = function() {
+        try {
+            return node_fs.statSync('/.dockerenv'), !0;
+        } catch  {
+            return !1;
+        }
+    }() || function() {
+        try {
+            return node_fs.readFileSync('/proc/self/cgroup', 'utf8').includes('docker');
+        } catch  {
+            return !1;
+        }
+    }()), isDockerCached)), cachedResult;
+}
+let isWsl = ()=>{
+    if ('linux' !== node_process.platform) return !1;
+    if (node_os.release().toLowerCase().includes('microsoft')) return !isInsideContainer();
+    try {
+        return !!node_fs.readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft') && !isInsideContainer();
+    } catch  {
+        return !1;
+    }
+}, is_wsl = node_process.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+function defineLazyProperty(object, propertyName, valueGetter) {
+    let define = (value)=>Object.defineProperty(object, propertyName, {
+            value,
+            enumerable: !0,
+            writable: !0
+        });
+    return Object.defineProperty(object, propertyName, {
+        configurable: !0,
+        enumerable: !0,
+        get () {
+            let result = valueGetter();
+            return define(result), result;
+        },
+        set (value) {
+            define(value);
+        }
+    }), object;
+}
+let execFileAsync = external_node_util_promisify(execFile);
+async function defaultBrowserId() {
+    if ('darwin' !== node_process.platform) throw Error('macOS only');
+    let { stdout } = await execFileAsync('defaults', [
+        'read',
+        'com.apple.LaunchServices/com.apple.launchservices.secure',
+        'LSHandlers'
+    ]), match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+    return match?.groups.id ?? 'com.apple.Safari';
+}
+let run_applescript_execFileAsync = external_node_util_promisify(execFile);
+async function runAppleScript(script, { humanReadableOutput = !0 } = {}) {
+    if ('darwin' !== node_process.platform) throw Error('macOS only');
+    let { stdout } = await run_applescript_execFileAsync("osascript", [
+        '-e',
+        script,
+        humanReadableOutput ? [] : [
+            '-ss'
+        ]
+    ]);
+    return stdout.trim();
+}
+async function bundleName(bundleId) {
+    return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string\ntell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+let windows_execFileAsync = external_node_util_promisify(execFile), windowsBrowserProgIds = {
+    AppXq0fevzme2pys62n3e0fbqa7peapykr8v: {
+        name: 'Edge',
+        id: 'com.microsoft.edge.old'
+    },
+    MSEdgeDHTML: {
+        name: 'Edge',
+        id: 'com.microsoft.edge'
+    },
+    MSEdgeHTM: {
+        name: 'Edge',
+        id: 'com.microsoft.edge'
+    },
+    'IE.HTTP': {
+        name: 'Internet Explorer',
+        id: 'com.microsoft.ie'
+    },
+    FirefoxURL: {
+        name: 'Firefox',
+        id: 'org.mozilla.firefox'
+    },
+    ChromeHTML: {
+        name: 'Chrome',
+        id: 'com.google.chrome'
+    },
+    BraveHTML: {
+        name: 'Brave',
+        id: 'com.brave.Browser'
+    },
+    BraveBHTML: {
+        name: 'Brave Beta',
+        id: 'com.brave.Browser.beta'
+    },
+    BraveSSHTM: {
+        name: 'Brave Nightly',
+        id: 'com.brave.Browser.nightly'
+    }
+};
+class UnknownBrowserError extends Error {
+}
+async function defaultBrowser(_execFileAsync = windows_execFileAsync) {
+    let { stdout } = await _execFileAsync('reg', [
+        'QUERY',
+        ' HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice',
+        '/v',
+        'ProgId'
+    ]), match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+    if (!match) throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+    let { id } = match.groups, browser = windowsBrowserProgIds[id];
+    if (!browser) throw new UnknownBrowserError(`Unknown browser ID: ${id}`);
+    return browser;
+}
+let default_browser_execFileAsync = external_node_util_promisify(execFile);
+async function default_browser_defaultBrowser() {
+    if ('darwin' === node_process.platform) {
+        let id = await defaultBrowserId();
+        return {
+            name: await bundleName(id),
+            id
+        };
+    }
+    if ('linux' === node_process.platform) {
+        let { stdout } = await default_browser_execFileAsync('xdg-mime', [
+            'query',
+            'default',
+            'x-scheme-handler/http'
+        ]), id = stdout.trim();
+        return {
+            name: id.replace(/.desktop$/, '').replace('-', ' ').toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x)=>x.toUpperCase()),
+            id
+        };
+    }
+    if ('win32' === node_process.platform) return defaultBrowser();
+    throw Error('Only macOS, Linux, and Windows are supported');
+}
+let open_execFile = node_util.promisify(node_child_process.execFile), open_dirname = node_path.dirname(fileURLToPath(import.meta.url)), localXdgOpenPath = node_path.join(open_dirname, 'xdg-open'), { platform, arch } = node_process, getWslDrivesMountPoint = (()=>{
+    let mountPoint, defaultMountPoint = '/mnt/';
+    return async function() {
+        if (mountPoint) return mountPoint;
+        let configFilePath = '/etc/wsl.conf', isConfigFileExists = !1;
+        try {
+            await promises.access(configFilePath, promises_constants.F_OK), isConfigFileExists = !0;
+        } catch  {}
+        if (!isConfigFileExists) return defaultMountPoint;
+        let configContent = await promises.readFile(configFilePath, {
+            encoding: 'utf8'
+        }), configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+        return configMountPoint ? mountPoint = (mountPoint = configMountPoint.groups.mountPoint.trim()).endsWith('/') ? mountPoint : `${mountPoint}/` : defaultMountPoint;
+    };
+})(), getPowershellPathFromWsl = async ()=>{
+    let mountPoint = await getWslDrivesMountPoint();
+    return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+};
+async function getWindowsDefaultBrowserFromWsl() {
+    let powershellPath = await getPowershellPathFromWsl(), encodedCommand = external_node_buffer_Buffer.from('(Get-ItemProperty -Path "HKCU:\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice").ProgId', 'utf16le').toString('base64'), { stdout } = await open_execFile(powershellPath, [
+        '-NoProfile',
+        '-NonInteractive',
+        '-ExecutionPolicy',
+        'Bypass',
+        '-EncodedCommand',
+        encodedCommand
+    ], {
+        encoding: 'utf8'
+    }), progId = stdout.trim(), browserMap = {
+        ChromeHTML: 'com.google.chrome',
+        MSEdgeHTM: 'com.microsoft.edge',
+        FirefoxURL: 'org.mozilla.firefox'
+    };
+    return browserMap[progId] ? {
+        id: browserMap[progId]
+    } : {};
+}
+let pTryEach = async (array, mapper)=>{
+    let latestError;
+    for (let item of array)try {
+        return await mapper(item);
+    } catch (error) {
+        latestError = error;
+    }
+    throw latestError;
+}, baseOpen = async (options)=>{
+    let command;
+    if (Array.isArray((options = {
+        wait: !1,
+        background: !1,
+        newInstance: !1,
+        allowNonzeroExitCode: !1,
+        ...options
+    }).app)) return pTryEach(options.app, (singleApp)=>baseOpen({
+            ...options,
+            app: singleApp
+        }));
+    let { name: app, arguments: appArguments = [] } = options.app ?? {};
+    if (appArguments = [
+        ...appArguments
+    ], Array.isArray(app)) return pTryEach(app, (appName)=>baseOpen({
+            ...options,
+            app: {
+                name: appName,
+                arguments: appArguments
+            }
+        }));
+    if ('browser' === app || 'browserPrivate' === app) {
+        let ids = {
+            'com.google.chrome': 'chrome',
+            'google-chrome.desktop': 'chrome',
+            'org.mozilla.firefox': 'firefox',
+            'firefox.desktop': 'firefox',
+            'com.microsoft.msedge': 'edge',
+            'com.microsoft.edge': 'edge',
+            'com.microsoft.edgemac': 'edge',
+            'microsoft-edge.desktop': 'edge'
+        }, browser = is_wsl ? await getWindowsDefaultBrowserFromWsl() : await default_browser_defaultBrowser();
+        if (browser.id in ids) {
+            let browserName = ids[browser.id];
+            return 'browserPrivate' === app && appArguments.push({
+                chrome: '--incognito',
+                firefox: '--private-window',
+                edge: '--inPrivate'
+            }[browserName]), baseOpen({
+                ...options,
+                app: {
+                    name: apps[browserName],
+                    arguments: appArguments
+                }
+            });
+        }
+        throw Error(`${browser.name} is not supported as a default browser`);
+    }
+    let cliArguments = [], childProcessOptions = {};
+    if ('darwin' === platform) command = 'open', options.wait && cliArguments.push('--wait-apps'), options.background && cliArguments.push('--background'), options.newInstance && cliArguments.push('--new'), app && cliArguments.push('-a', app);
+    else if ('win32' !== platform && (!is_wsl || isInsideContainer() || app)) {
+        if (app) command = app;
+        else {
+            let exeLocalXdgOpen = !1;
+            try {
+                await promises.access(localXdgOpenPath, promises_constants.X_OK), exeLocalXdgOpen = !0;
+            } catch  {}
+            command = node_process.versions.electron ?? ('android' === platform || !open_dirname || '/' === open_dirname || !exeLocalXdgOpen) ? 'xdg-open' : localXdgOpenPath;
+        }
+        appArguments.length > 0 && cliArguments.push(...appArguments), options.wait || (childProcessOptions.stdio = 'ignore', childProcessOptions.detached = !0);
+    } else {
+        command = is_wsl ? await getPowershellPathFromWsl() : `${node_process.env.SYSTEMROOT || node_process.env.windir || 'C:\\Windows'}\\System32\\WindowsPowerShell\\v1.0\\powershell`, cliArguments.push('-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand'), is_wsl || (childProcessOptions.windowsVerbatimArguments = !0);
+        let encodedArguments = [
+            'Start'
+        ];
+        options.wait && encodedArguments.push('-Wait'), app ? (encodedArguments.push(`"\`"${app}\`""`), options.target && appArguments.push(options.target)) : options.target && encodedArguments.push(`"${options.target}"`), appArguments.length > 0 && encodedArguments.push('-ArgumentList', (appArguments = appArguments.map((argument)=>`"\`"${argument}\`""`)).join(',')), options.target = external_node_buffer_Buffer.from(encodedArguments.join(' '), 'utf16le').toString('base64');
+    }
+    'darwin' === platform && appArguments.length > 0 && cliArguments.push('--args', ...appArguments), options.target && cliArguments.push(options.target);
+    let subprocess = node_child_process.spawn(command, cliArguments, childProcessOptions);
+    return options.wait ? new Promise((resolve, reject)=>{
+        subprocess.once('error', reject), subprocess.once('close', (exitCode)=>{
+            if (!options.allowNonzeroExitCode && exitCode > 0) return void reject(Error(`Exited with code ${exitCode}`));
+            resolve(subprocess);
+        });
+    }) : (subprocess.unref(), subprocess);
+};
+function detectArchBinary(binary) {
+    if ('string' == typeof binary || Array.isArray(binary)) return binary;
+    let { [arch]: archBinary } = binary;
+    if (!archBinary) throw Error(`${arch} is not supported`);
+    return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+    if (wsl && is_wsl) return detectArchBinary(wsl);
+    if (!platformBinary) throw Error(`${platform} is not supported`);
+    return detectArchBinary(platformBinary);
+}
+let apps = {};
+defineLazyProperty(apps, 'chrome', ()=>detectPlatformBinary({
+        darwin: 'google chrome',
+        win32: 'chrome',
+        linux: [
+            'google-chrome',
+            'google-chrome-stable',
+            'chromium'
+        ]
+    }, {
+        wsl: {
+            ia32: '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe',
+            x64: [
+                '/mnt/c/Program Files/Google/Chrome/Application/chrome.exe',
+                '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe'
+            ]
+        }
+    })), defineLazyProperty(apps, 'firefox', ()=>detectPlatformBinary({
+        darwin: 'firefox',
+        win32: 'C:\\Program Files\\Mozilla Firefox\\firefox.exe',
+        linux: 'firefox'
+    }, {
+        wsl: '/mnt/c/Program Files/Mozilla Firefox/firefox.exe'
+    })), defineLazyProperty(apps, 'edge', ()=>detectPlatformBinary({
+        darwin: 'microsoft edge',
+        win32: 'msedge',
+        linux: [
+            'microsoft-edge',
+            'microsoft-edge-dev'
+        ]
+    }, {
+        wsl: '/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe'
+    })), defineLazyProperty(apps, 'browser', ()=>'browser'), defineLazyProperty(apps, 'browserPrivate', ()=>'browserPrivate');
+let normalizeUrl = (url)=>url.replace(/([^:]\/)\/+/g, '$1'), joinUrlSegments = (s1, s2)=>s1 && s2 ? addTrailingSlash(s1) + removeLeadingSlash(s2) : s1 || s2 || '', stripBase = (path, base)=>{
     if (path === base) return '/';
     let trailingSlashBase = addTrailingSlash(base);
     return path.startsWith(trailingSlashBase) ? path.slice(trailingSlashBase.length - 1) : path;
@@ -3412,19 +3730,27 @@ async function openBrowser(url) {
         }
     }
     try {
-        let { default: open } = await import("../compiled/open/index.js"), { apps } = open, options = browser ? {
+        let options = browser ? {
             app: {
                 name: apps[browser] ?? browser,
                 arguments: null == browserArgs ? void 0 : browserArgs.split(' ')
             }
         } : {};
-        return await open(url, options), !0;
+        return (await ((target, options)=>{
+            if ('string' != typeof target) throw TypeError('Expected a `target`');
+            return baseOpen({
+                ...options,
+                target
+            });
+        })(url, options)).on('error', (err)=>{
+            logger.error('Failed to launch browser in child process', err);
+        }), !0;
     } catch (err) {
-        return logger.error('Failed to open start URL.'), logger.error(err), !1;
+        return logger.error('Failed to launch browser.'), logger.error(err), !1;
     }
 }
 let openedURLs = [], replacePortPlaceholder = (url, port)=>url.replace(/<port>/g, String(port));
-async function open_open({ https, port, routes, config, clearCache }) {
+async function server_open_open({ https, port, routes, config, clearCache }) {
     let { targets, before } = ((config)=>{
         let { open } = config.server;
         return 'boolean' == typeof open ? {
@@ -3440,7 +3766,6 @@ async function open_open({ https, port, routes, config, clearCache }) {
             before: open.before
         };
     })(config);
-    if ('true' === process.env.CSB) return;
     clearCache && (openedURLs = []);
     let urls = [], host = await getHostInUrl(config.server.host), baseUrl = `${https ? 'https' : 'http'}://${host}:${port}`;
     for (let url of (targets.length ? urls.push(...targets.map((target)=>(function(str, base) {
@@ -4959,7 +5284,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
             protocol,
             printUrls: config.server.printUrls,
             trailingLineBreak: !cliShortcutsEnabled
-        }), openPage = async ()=>open_open({
+        }), openPage = async ()=>server_open_open({
             https,
             port,
             routes,
@@ -5238,7 +5563,7 @@ async function startProdServer(context, config, { getPortSilently } = {}) {
                     protocol,
                     printUrls: serverConfig.printUrls,
                     trailingLineBreak: !cliShortcutsEnabled
-                }), openPage = async ()=>open_open({
+                }), openPage = async ()=>server_open_open({
                     https,
                     port,
                     routes,
@@ -5296,7 +5621,7 @@ async function applyDefaultPlugins(pluginManager, context) {
                         ...chain.get('experiments'),
                         rspackFuture: {
                             bundlerInfo: {
-                                force: !!config.security.sri.enable
+                                force: !1
                             }
                         }
                     }), process.env.RSPACK_CONFIG_VALIDATE ||= 'loose-silent';
@@ -6133,7 +6458,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         let { config, browserslist } = environment, cacheRoot = node_path.join(api.context.cachePath, '.swc'), rule = chain.module.rule(CHAIN_ID.RULE.JS).test(SCRIPT_REGEX).type("javascript/auto").dependency({
                             not: 'url'
                         }).resourceQuery({
-                            not: /raw|inline/
+                            not: /raw/
                         });
                         chain.module.rule(CHAIN_ID.RULE.JS_RAW).test(SCRIPT_REGEX).type('asset/source').resourceQuery(/raw/);
                         let dataUriRule = chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).mimetype({
@@ -6500,7 +6825,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     let config = api.getNormalizedConfig();
                     if (config.server.open) {
                         var _api_context_devServer;
-                        open_open({
+                        server_open_open({
                             https: null == (_api_context_devServer = api.context.devServer) ? void 0 : _api_context_devServer.https,
                             port,
                             routes,
@@ -7308,11 +7633,11 @@ async function runCLI() {
         ].includes(level) && (logger.level = level);
     }
     let { npm_execpath } = process.env;
-    (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && logger.log(), logger.greet(`  Rsbuild v1.4.1\n`);
+    (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && logger.log(), logger.greet(`  Rsbuild v1.4.2\n`);
     try {
         !function() {
             let cli = ((name = "")=>new CAC(name))('rsbuild');
-            cli.help(), cli.version("1.4.1"), cli.option('--base <base>', 'specify the base path of the server').option('-c, --config <config>', 'specify the configuration file, can be a relative or absolute path').option('--config-loader <loader>', 'specify the loader to load the config file, can be `jiti` or `native`', {
+            cli.help(), cli.version("1.4.2"), cli.option('--base <base>', 'specify the base path of the server').option('-c, --config <config>', 'specify the configuration file, can be a relative or absolute path').option('--config-loader <loader>', 'specify the loader to load the config file, can be `jiti` or `native`', {
                 default: 'jiti'
             }).option('-r, --root <root>', 'specify the project root directory, can be an absolute path or a path relative to cwd').option('-m, --mode <mode>', 'specify the build mode, can be `development`, `production` or `none`').option('--log-level <level>', 'specify the log level, can be `info`, `warn`, `error` or `silent`').option('--env-mode <mode>', 'specify the env mode to load the `.env.[mode]` file').option('--environment <name>', 'specify the name of environment to build', {
                 type: [
@@ -7370,5 +7695,5 @@ async function runCLI() {
         logger.error('Failed to start Rsbuild CLI.'), logger.error(err);
     }
 }
-let src_version = "1.4.1";
+let src_version = "1.4.2";
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, loadConfig_loadConfig as loadConfig, loadEnv, logger, mergeRsbuildConfig, rspack, runCLI, src_version as version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "The Rspack-based build tool.",
   "homepage": "https://rsbuild.rs",
   "bugs": {
@@ -74,12 +74,12 @@
     "launch-editor-middleware": "^2.10.0",
     "mrmime": "^2.0.1",
     "on-finished": "2.4.1",
-    "open": "^8.4.0",
+    "open": "^10.1.2",
     "picocolors": "^1.1.1",
     "postcss": "^8.5.6",
     "postcss-load-config": "6.0.1",
     "postcss-loader": "8.1.1",
-    "prebundle": "1.3.3",
+    "prebundle": "1.3.4",
     "reduce-configs": "^1.1.0",
     "rsbuild-dev-middleware": "0.3.0",
     "rslog": "^1.2.8",

package/compiled/open/index.d.ts

@@ -1,153 +0,0 @@
-import { ChildProcess } from 'child_process';
-
-declare namespace open {
-	interface Options {
-		/**
-		Wait for the opened app to exit before fulfilling the promise. If `false` it's fulfilled immediately when opening the app.
-
-		Note that it waits for the app to exit, not just for the window to close.
-
-		On Windows, you have to explicitly specify an app for it to be able to wait.
-
-		@default false
-		*/
-		readonly wait?: boolean;
-
-		/**
-		__macOS only__
-
-		Do not bring the app to the foreground.
-
-		@default false
-		*/
-		readonly background?: boolean;
-
-		/**
-		__macOS only__
-
-		Open a new instance of the app even it's already running.
-
-		A new instance is always opened on other platforms.
-
-		@default false
-		*/
-		readonly newInstance?: boolean;
-
-		/**
-		Specify the `name` of the app to open the `target` with, and optionally, app `arguments`. `app` can be an array of apps to try to open and `name` can be an array of app names to try. If each app fails, the last error will be thrown.
-
-		The app name is platform dependent. Don't hard code it in reusable modules. For example, Chrome is `google chrome` on macOS, `google-chrome` on Linux and `chrome` on Windows. If possible, use [`open.apps`](#openapps) which auto-detects the correct binary to use.
-
-		You may also pass in the app's full path. For example on WSL, this can be `/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe` for the Windows installation of Chrome.
-
-		The app `arguments` are app dependent. Check the app's documentation for what arguments it accepts.
-		*/
-		readonly app?: App | readonly App[];
-
-		/**
-		Allow the opened app to exit with nonzero exit code when the `wait` option is `true`.
-
-		We do not recommend setting this option. The convention for success is exit code zero.
-
-		@default false
-		*/
-		readonly allowNonzeroExitCode?: boolean;
-	}
-
-	interface OpenAppOptions extends Omit<Options, 'app'> {
-		/**
-		Arguments passed to the app.
-
-		These arguments are app dependent. Check the app's documentation for what arguments it accepts.
-		*/
-		readonly arguments?: readonly string[];
-	}
-
-	type AppName =
-		| 'chrome'
-		| 'firefox'
-		| 'edge';
-
-	type App = {
-		name: string | readonly string[];
-		arguments?: readonly string[];
-	};
-}
-
-// eslint-disable-next-line no-redeclare
-declare const open: {
-	/**
-	Open stuff like URLs, files, executables. Cross-platform.
-
-	Uses the command `open` on macOS, `start` on Windows and `xdg-open` on other platforms.
-
-	There is a caveat for [double-quotes on Windows](https://github.com/sindresorhus/open#double-quotes-on-windows) where all double-quotes are stripped from the `target`.
-
-	@param target - The thing you want to open. Can be a URL, file, or executable. Opens in the default app for the file type. For example, URLs open in your default browser.
-	@returns The [spawned child process](https://nodejs.org/api/child_process.html#child_process_class_childprocess). You would normally not need to use this for anything, but it can be useful if you'd like to attach custom event listeners or perform other operations directly on the spawned process.
-
-	@example
-	```
-	import open = require('open');
-
-	// Opens the image in the default image viewer
-	await open('unicorn.png', {wait: true});
-	console.log('The image viewer app closed');
-
-	// Opens the url in the default browser
-	await open('https://sindresorhus.com');
-
-	// Opens the URL in a specified browser.
-	await open('https://sindresorhus.com', {app: {name: 'firefox'}});
-
-	// Specify app arguments.
-	await open('https://sindresorhus.com', {app: {name: 'google chrome', arguments: ['--incognito']}});
-	```
-	*/
-	(
-		target: string,
-		options?: open.Options
-	): Promise<ChildProcess>;
-
-	/**
-	An object containing auto-detected binary names for common apps. Useful to work around cross-platform differences.
-
-	@example
-	```
-	import open = require('open');
-
-	await open('https://google.com', {
-		app: {
-			name: open.apps.chrome
-		}
-	});
-	```
-	*/
-	apps: Record<open.AppName, string | readonly string[]>;
-
-	/**
-	Open an app. Cross-platform.
-
-	Uses the command `open` on macOS, `start` on Windows and `xdg-open` on other platforms.
-
-	@param name - The app you want to open. Can be either builtin supported `open.apps` names or other name supported in platform.
-	@returns The [spawned child process](https://nodejs.org/api/child_process.html#child_process_class_childprocess). You would normally not need to use this for anything, but it can be useful if you'd like to attach custom event listeners or perform other operations directly on the spawned process.
-
-	@example
-	```
-	const {apps, openApp} = require('open');
-
-	// Open Firefox
-	await openApp(apps.firefox);
-
-	// Open Chrome incognito mode
-	await openApp(apps.chrome, {arguments: ['--incognito']});
-
-	// Open Xcode
-	await openApp('xcode');
-	```
-	*/
-	openApp: (name: open.App['name'], options?: open.OpenAppOptions) => Promise<ChildProcess>;
-};
-
-export { open as default };