quickbundle 2.6.0 → 2.8.0

package/README.md

@@ -10,22 +10,27 @@
 
 Quickbundle allows you to bundle a library in a **quick**, **fast** and **easy** way:
 
--   Fast build and watch mode powered by Rollup[^1] and SWC[^2].
--   Zero configuration: define the build artifacts in your `package.json`, and you're all set!
--   Support of `cjs` & `esm` module formats output.
--   Support of several loaders including JavaScript, TypeScript, JSX, JSON, and Images.
--   TypeScript's declaration file (`.d.ts`) bundling.
--   Automatic dependency inclusion (`peerDependencies` and `dependencies` are not bundled in the final output, `devDependencies` are unless they're not imported).
+- Zero configuration: define the build artifacts in your `package.json`, and you're all set!
+- Fast build and watch mode powered by Rollup[^1] and SWC[^2].
+- Compile and cross compile standalone executables for systems that do not have Node.js installed[^3].
+- Support of `cjs` & `esm` module formats output.
+- Support of several loaders including JavaScript, TypeScript, JSX, JSON, and Images.
+- TypeScript's declaration file (`.d.ts`) bundling.
+- Automatic dependency inclusion:
+  - For the build and watch mode, `peerDependencies` and `dependencies` are not bundled in the final output, `devDependencies` are unless they're not imported.
+  - For the compile mode, all dependencies are included to make the code standalone.
 
 [^1]: A [module bundler](https://rollupjs.org/) optimized for better tree-shaking processing and seamless interoperability of CommonJS and ESM formats with minimal code footprint.
 
 [^2]: A [TypeScript / JavaScript transpiler](https://swc.rs/) for quicker code processing including TypeScript transpilation, JavaScript transformation, and, minification.
 
+[^3]: It relies on the [Node.js single executable applications feature](https://nodejs.org/api/single-executable-applications.html).
+
 <br>
 
 ## 🚀 Quick Start
 
-1️⃣ Install by running:
+### 1️⃣ Install
 
 ```bash
 # Npm
@@ -36,9 +41,11 @@ pnpm add quickbundle
 yarn add quickbundle
 ```
 
-2️⃣ Set up your package configuration (`package.json`):
+### 2️⃣ Update your package configuration (`package.json`)
+
+#### For building libraries
 
--   When exporting exclusively ESM format:
+- When exporting exclusively ESM format:
 
 ```jsonc
 {
@@ -53,8 +60,8 @@ yarn add quickbundle
 		},
 		"./otherModulePath": {
 			// ...
-		}
-	}
+		},
+	},
 	"scripts": {
 		"build": "quickbundle build", // Production mode (optimizes bundle)
 		"watch": "quickbundle watch", // Development mode (watches each file change)
@@ -63,7 +70,10 @@ yarn add quickbundle
 }
 ```
 
--   When exporting both CommonJS (CJS) and ECMAScript Modules (ESM) format (please be aware of [dual package hazard risk](https://nodejs.org/api/packages.html#dual-package-hazard)):
+- When exporting both CommonJS (CJS) and ECMAScript Modules (ESM) format:
+
+> [!warning]
+> Please be aware of [dual-package-hazard-related risks](https://github.com/nodejs/package-examples?tab=readme-ov-file#dual-package-hazard) first.
 
 ```jsonc
 {
@@ -80,8 +90,8 @@ yarn add quickbundle
 		},
 		"./otherModulePath": {
 			// ...
-		}
-	}
+		},
+	},
 	"scripts": {
 		"build": "quickbundle build", // Production mode (optimizes bundle)
 		"watch": "quickbundle watch", // Development mode (watches each file change)
@@ -90,7 +100,30 @@ yarn add quickbundle
 }
 ```
 
-3️⃣ Try it by running:
+#### For compiling executables
+
+> [!warning]
+> The `compile` command relies on the [Node.js SEA (Single Executable Applications feature)](https://nodejs.org/api/single-executable-applications.html). This feature comes with some limitations which Quickbundle attempts to address:
+>
+> - The source code must not rely on [external dependencies](https://github.com/nodejs/single-executable/discussions/70) 🛑. To partially address this, Quickbundle bundles all dependencies (whatever their types, as long as they're used) and inline dynamic imports by default ✅.
+> - The bundled code must use the CommonJS module system 🛑. To address this, Quickbundle always outputs CJS modules in compile mode ✅.
+
+```jsonc
+{
+	"name": "lib", // Package name
+	"source": "./src/index.ts", // Source code entry point. Make sure that it starts with `#!/usr/bin/env node` pragme to make the binary portable for consumers who would like to use it by installing the package instead of using the generated standalone executable.
+	"bin": {
+		"your-binary-name": "./dist/index.cjs", // Binary information to get the executable name from the key and, from the value, the bundled file to generate from the source code and inject into the executable. The generated executable will be located in the same folder as the bundled file and, by default, dependending on the current operating system running the `compile` command, the executable will be named either `your-binary-name.exe` on Windows or `your-binary-name` on Linux and macOS. For cross-compilation output, check the `Patterns` section.
+	},
+	// "bin": "./dist/index.cjs", // Or, if the binary name follows the package name, you can define a string-based `bin` value.
+	"scripts": {
+		"build": "quickbundle compile",
+	},
+	// ...
+}
+```
+
+### 3️⃣ Try it
 
 ```bash
 # Npm
@@ -109,14 +142,14 @@ yarn build
 
 By default, Quickbundle does the following built-in optimizations during the bundling process:
 
--   Include, in the build output, only the code that is effectively imported and used in the source code. Setting the `sideEffects` package.json field to `false` marks the package as a side-effect-free one and helps Quickbundle to safely prune unused exports.
--   [Identify and annotate](https://rollupjs.org/configuration-options/#treeshake-annotations) side-effect-free code (functions, ...) to enable a fine-grained dead-code elimination process later consumer side. For example, if a consumer uses only one library API, build output annotations added by Quickbundle allow the consumer's bundler remove all other unused APIs.
+- Include, in the build output, only the code that is effectively imported and used in the source code. Setting the `sideEffects` package.json field to `false` marks the package as a side-effect-free one and helps Quickbundle to safely prune unused exports.
+- [Identify and annotate](https://rollupjs.org/configuration-options/#treeshake-annotations) side-effect-free code (functions, ...) to enable a fine-grained dead-code elimination process later consumer side. For example, if a consumer uses only one library API, build output annotations added by Quickbundle allow the consumer's bundler remove all other unused APIs.
 
 However, Quickbundle doesn't minify the build output. Indeed, in general, **if the build targets a library (the most Quickbundle use case)**, minification is not necessary since enabling it can introduce some challenges:
 
--   Reduce the build output discoverability inside the `node_modules` folder (minified code is an obfuscated code that can be hard to read for code audit/debugging purposes).
--   Generate suboptimal source maps for the bundled library, as the consumer bundler will generate source maps based on the already minified library build (transformed code, mangled variable names, etc.).
--   Risk of side effects with double optimizations (producer side and then consumer side).
+- Reduce the build output discoverability inside the `node_modules` folder (minified code is an obfuscated code that can be hard to read for code audit/debugging purposes).
+- Generate suboptimal source maps for the bundled library, as the consumer bundler will generate source maps based on the already minified library build (transformed code, mangled variable names, etc.).
+- Risk of side effects with double optimizations (producer side and then consumer side).
 
 Popular open source libraries ([Vue](https://unpkg.com/browse/vue@3.4.24/dist/), [SolidJS](https://unpkg.com/browse/solid-js@1.8.17/dist/), [Material UI](https://unpkg.com/browse/@material-ui/core@4.12.4/), ...) do not provide minified builds as the build optimization is sensitive to the consumer context (e.g. environment targets (browser support), ...) and needs to be fully owned upstream (i.e. consumer/application-side).
 
@@ -138,11 +171,29 @@ quickbundle watch --source-maps
 
 Enabling source map generation is needed only if a build is [obfuscated (minified)](#optimize-the-build-output) for debugging-easing purposes. It generally pairs with the [`minification` flag](#optimize-the-build-output).
 
+### Cross compilation to other platforms
+
+By default, the `compile` command embeds the runtime at the origin of its execution which means it generates executables compatible only with machines running the same operating system, processor architecture, and Node.js version.
+
+However, Quickbundle provides the ability to target a different operating system, processor architecture, or Node.js version (also known as cross-compilation):
+
+```bash
+quickbundle compile --target node-v23.1.0-darwin-arm64 # Embeds Node v23 runtime built for macOS ARM64 target
+quickbundle compile --target node-v23.1.0-darwin-x64 # Embeds Node v23 runtime built for macOS X64 target
+quickbundle compile --target node-v23.1.0-linux-arm64 # Embeds Node v23 runtime built for Linux ARM64 target
+quickbundle compile --target node-v23.1.0-linux-x64 # Embeds Node v23 runtime built for Linux X64 target
+quickbundle compile --target node-v23.1.0-win-arm64 # Embeds Node v23 runtime built for Windows ARM64 target
+quickbundle compile --target node-v23.1.0-win-x64 # Embeds Node v23 runtime built for Windows X64 target
+```
+
+> [!note]
+> The target input must follow the `node-vx.y.z-(darwin|linux|win)-(arm64|x64|x86)` format (for an exhaustive view, check available filenames in [https://nodejs.org/download/release/vx.y.z](https://nodejs.org/download/release/latest/)).
+
 <br>
 
 ## 🤩 Used by
 
--   [@adbayb/stack](https://github.com/adbayb/stack) My opinionated toolbox for JavaScript/TypeScript projects.
+- [@adbayb/stack](https://github.com/adbayb/stack) My opinionated toolbox for JavaScript/TypeScript projects.
 
 <br>
 
@@ -154,11 +205,13 @@ We're open to new contributions, you can find more details [here](./CONTRIBUTING
 
 ## 💙 Acknowledgements
 
--   The backend is powered by [Rollup](https://github.com/rollup/rollup) and its plugin ecosystem (including [SWC](https://github.com/swc-project/swc)) to make blazing-fast builds. A special shoutout to all contributors involved.
--   The zero-configuration approach was inspired by [microbundle](https://github.com/developit/microbundle). A special shoutout to its author [Jason Miller](https://github.com/developit) and [all contributors](https://github.com/developit/microbundle/graphs/contributors).
+- The backend is powered by [Rollup](https://github.com/rollup/rollup) and its plugin ecosystem (including [SWC](https://github.com/swc-project/swc)) to make blazing-fast builds. A special shoutout to all contributors involved.
+- The zero-configuration approach was inspired by [microbundle](https://github.com/developit/microbundle). A special shoutout to its author [Jason Miller](https://github.com/developit) and [all contributors](https://github.com/developit/microbundle/graphs/contributors).
 
 <br>
 
 ## 📖 License
 
 [MIT](./LICENSE "License MIT").
+
+<br>

package/bin/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
-import { createRequire } from "node:module";
 import { join } from "node:path";
+import { createRequire } from "node:module";
 
 const pkg = createRequire(import.meta.url)("../package.json");
 

package/dist/index.mjs

@@ -1,17 +1,105 @@
-#!/usr/bin/env node
 import { helpers, termost } from 'termost';
-import { gzipSize } from 'gzip-size';
-import { rollup, watch as watch$1 } from 'rollup';
-import commonjs from '@rollup/plugin-commonjs';
-import json from '@rollup/plugin-json';
-import { nodeResolve } from '@rollup/plugin-node-resolve';
-import url from '@rollup/plugin-url';
+import { finished } from 'node:stream/promises';
+import { Readable } from 'node:stream';
+import process from 'node:process';
+import { resolve, dirname, join, basename } from 'node:path';
+import { copyFile as copyFile$1, rm, writeFile as writeFile$1, rename, mkdir, readFile as readFile$1 } from 'node:fs/promises';
+import { createWriteStream } from 'node:fs';
+import decompress from 'decompress';
+import { watch as watch$1, rollup } from 'rollup';
 import { createRequire } from 'node:module';
-import { join } from 'node:path';
-import dts from 'rollup-plugin-dts';
-import externals from 'rollup-plugin-node-externals';
 import { swc } from 'rollup-plugin-swc3';
-import { readFile as readFile$1 } from 'node:fs/promises';
+import externals from 'rollup-plugin-node-externals';
+import dts from 'rollup-plugin-dts';
+import url from '@rollup/plugin-url';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import json from '@rollup/plugin-json';
+import commonjs from '@rollup/plugin-commonjs';
+import os from 'node:os';
+import { gzipSize } from 'gzip-size';
+
+var name = "quickbundle";
+var version = "2.8.0";
+
+/**
+ * Resolve a relative path from the Quickbundle node modules directory.
+ * @param paths - Relative paths.
+ * @returns The resolved absolute path.
+ * @example
+ * resolveFromInternalDirectory("dist", "node");
+ */ const resolveFromInternalDirectory = (...paths)=>{
+    return resolve(import.meta.dirname, "../", ...paths);
+};
+/**
+ * Resolve a relative path from the current working project directory.
+ * @param paths - Relative paths.
+ * @returns The resolved absolute path.
+ * @example
+ * resolveFromExternalDirectory("package.json");
+ */ const resolveFromExternalDirectory = (...paths)=>{
+    return resolve(process.cwd(), ...paths);
+};
+const createRegExpMatcher = (regex)=>{
+    return (value)=>{
+        return regex.exec(value)?.groups;
+    };
+};
+const createDirectory = async (path)=>{
+    await mkdir(path, {
+        recursive: true
+    });
+};
+const copyFile = async (fromPath, toPath)=>{
+    await createDirectory(dirname(toPath));
+    await copyFile$1(fromPath, toPath);
+};
+const removePath = async (path)=>{
+    await rm(path, {
+        force: true,
+        recursive: true
+    });
+};
+const readFile = async (filePath)=>{
+    return readFile$1(filePath);
+};
+const writeFile = async (filePath, content)=>{
+    await createDirectory(dirname(filePath));
+    await writeFile$1(filePath, content, "utf8");
+};
+const download = async (url, filePath)=>{
+    await createDirectory(dirname(filePath));
+    const { body, ok, status, statusText } = await fetch(url);
+    if (!ok) {
+        throw new Error(`An error ocurred while downloading \`${url}\`. Received \`${status}\` status code with the following message \`${statusText}\`.`);
+    }
+    if (!body) {
+        throw new Error(`Empty body received while downloading \`${url}\`.`);
+    }
+    await finished(Readable.fromWeb(body).pipe(createWriteStream(filePath)));
+};
+const unzip = async (input, output)=>{
+    const { targetedArchivePath } = input;
+    const { directoryPath } = output;
+    await decompress(input.path, directoryPath, {
+        filter (file) {
+            return file.path === targetedArchivePath;
+        }
+    });
+    await rename(join(directoryPath, targetedArchivePath), join(directoryPath, output.filename));
+};
+const createCommand = (program, input)=>{
+    return program.command(input).option({
+        key: "minification",
+        name: "minification",
+        description: "Enable minification",
+        defaultValue: false
+    }).option({
+        key: "sourceMaps",
+        name: "source-maps",
+        description: "Enable source maps generation",
+        defaultValue: false
+    });
+};
 
 const onLog = (_, log)=>{
     if (log.message.includes("Generated an empty chunk")) return;
@@ -20,68 +108,109 @@ const isRecord = (value)=>{
     return typeof value === "object" && value !== null && !Array.isArray(value);
 };
 
-const build = async (configurations)=>{
-    process.env.NODE_ENV ??= "production";
-    const output = [];
-    for (const config of configurations){
-        const initialTime = Date.now();
-        const bundle = await rollup({
-            ...config,
+const watch = (input)=>{
+    process.env.NODE_ENV ??= "development";
+    const watcher = watch$1(input.data.map((configItem)=>({
+            ...configItem,
             onLog
-        });
-        if (config.output) {
-            const outputEntries = Array.isArray(config.output) ? config.output : [
-                config.output
-            ];
-            const promises = [];
-            for (const outputEntry of outputEntries){
-                const outputFilename = outputEntry.file ?? outputEntry.dir;
-                if (!outputFilename) {
-                    throw new Error("Misconfigured file entry point. Make sure to define an `import`, `require`, or `default` field.");
+        })));
+    let startDuration;
+    console.clear();
+    watcher.on("event", async (event)=>{
+        switch(event.code){
+            case "START":
+                {
+                    startDuration = Date.now();
+                    clearLog(`Build in progress...`, {
+                        type: "information"
+                    });
+                    return;
+                }
+            case "BUNDLE_END":
+                await event.result.close();
+                break;
+            case "END":
+                {
+                    const duration = Date.now() - startDuration;
+                    clearLog(`Build done in ${duration}ms (at ${new Date().toLocaleTimeString()})`, {
+                        type: "success"
+                    });
+                    return;
+                }
+            case "ERROR":
+                {
+                    const { error } = event;
+                    clearLog(error.message, {
+                        type: "error"
+                    });
+                    console.error("\n", error);
+                    return;
                 }
-                promises.push(new Promise((resolve, reject)=>{
-                    bundle.write(outputEntry).then(()=>{
-                        resolve({
-                            elapsedTime: Date.now() - initialTime,
-                            filename: outputFilename
-                        });
-                    }).catch(reject);
-                }));
-            }
-            output.push(...await Promise.all(promises));
         }
-    }
-    return output;
+    });
+};
+const clearLog = (...input)=>{
+    console.clear();
+    helpers.message(...input);
 };
-
-const CWD = process.cwd();
 
 const require = createRequire(import.meta.url);
-const PKG = require(join(CWD, "./package.json"));
-const createConfigurations = (options = {
+const PKG = require(resolveFromExternalDirectory("package.json"));
+const createConfiguration = (options = {
     minification: false,
-    sourceMaps: false
+    sourceMaps: false,
+    standalone: false
 })=>{
-    return getBuildableExports().flatMap((buildableExport)=>{
-        return [
-            buildableExport.source && createMainConfig({
-                ...buildableExport,
-                source: buildableExport.source
-            }, options),
-            buildableExport.source && buildableExport.types && createTypesConfig({
-                source: buildableExport.source,
-                types: buildableExport.types
-            })
-        ].filter(Boolean);
-    });
+    const buildableExports = getBuildableExports(options);
+    return {
+        data: buildableExports.flatMap((buildableExport)=>{
+            return [
+                buildableExport.source && createMainConfig({
+                    ...buildableExport,
+                    source: buildableExport.source
+                }, options),
+                buildableExport.source && buildableExport.types && createTypesConfig({
+                    source: buildableExport.source,
+                    types: buildableExport.types
+                }, options)
+            ].filter(Boolean);
+        }),
+        metadata: buildableExports
+    };
 };
-const getBuildableExports = ()=>{
+// eslint-disable-next-line sonarjs/cyclomatic-complexity
+const getBuildableExports = ({ standalone })=>{
+    if (standalone) {
+        /**
+		 * Entry-point resolution invariants for standalone target (mostly binaries).
+		 */ if (!PKG.source || !PKG.bin || !PKG.name) {
+            throw new Error("Invalid package entry points contract. Standalone compilation is enabled but required fields are missing. Make sure to set `name`, `source`, and `bin` fields.");
+        }
+        const bin = PKG.bin;
+        const name = PKG.name;
+        const source = PKG.source;
+        if (isRecord(bin)) {
+            return Object.entries(bin).map((data)=>({
+                    bin: data[0],
+                    require: data[1],
+                    source
+                }));
+        }
+        return [
+            {
+                // For scoped packages and if the `bin` is defined with a string value, the [scope name is discarded](the scope name is discarded when creating a binary) when creating a binary.
+                bin: name.replace(/^(@.*?\/)/, ""),
+                require: bin,
+                source
+            }
+        ];
+    }
     /**
-	 * Entry-point resolution:
+	 * Entry-point resolution invariants for non-standalone target (mostly libraries):
 	 * Following the [package entry-point specification](https://nodejs.org/api/packages.html#package-entry-points),
 	 * whenever an export object is defined, it take precedence over other classical entry-point fields
 	 * (such as main, module, and types defined at the root package.json level).
-	 */ if (PKG.main ?? PKG.module ?? PKG.types ?? !PKG.exports) {
+	 */ if (PKG.main || PKG.module || PKG.types || !PKG.exports) {
         throw new Error("Invalid package entry points contract. Use the recommended [`exports` field](https://nodejs.org/api/packages.html#package-entry-points) instead and, for TypeScript-based projects, update the `tsconfig.json` file to resolve it properly (`moduleResolution` must be set to `Bundler` (or `NodeNext`)).");
     }
     const buildableExportFields = [
@@ -130,15 +259,15 @@ const getBuildableExports = ()=>{
     }
     return output;
 };
-const getPlugins = (...customPlugins)=>{
+const getPlugins = (customPlugins, options)=>{
     return [
-        externals({
+        !options.standalone && externals({
             builtins: true,
             deps: true,
             /**
-			 * As they're not installed consumer side, `devDependencies` are declared as internal dependencies (via the `false` value)
-			 * and bundled into the dist if and only if imported and not listed as `peerDependencies` (otherwise, they're considered external).
-			 */ devDeps: false,
+				 * As they're not installed consumer side, `devDependencies` are declared as internal dependencies (via the `false` value)
+				 * and bundled into the dist if and only if imported and not listed as `peerDependencies` (otherwise, they're considered external).
+				 */ devDeps: false,
             optDeps: true,
             peerDeps: true
         }),
@@ -146,7 +275,7 @@ const getPlugins = (...customPlugins)=>{
         url(),
         json(),
         ...customPlugins
-    ];
+    ].filter(Boolean);
 };
 const createMainConfig = (entryPoints, options)=>{
     const { minification, sourceMaps } = options;
@@ -158,6 +287,7 @@ const createMainConfig = (entryPoints, options)=>{
         entryPoints.require && {
             file: entryPoints.require,
             format: "cjs",
+            inlineDynamicImports: Boolean(options.standalone),
             sourcemap: sourceMaps
         },
         esmInput && {
@@ -169,13 +299,16 @@ const createMainConfig = (entryPoints, options)=>{
     return {
         input: entryPoints.source,
         output,
-        plugins: getPlugins(nodeResolve(), swc({
-            minify: minification,
-            sourceMaps
-        }))
+        plugins: getPlugins([
+            nodeResolve(),
+            swc({
+                minify: minification,
+                sourceMaps
+            })
+        ], options)
     };
 };
-const createTypesConfig = (entryPoints)=>{
+const createTypesConfig = (entryPoints, options)=>{
     return {
         input: entryPoints.source,
         output: [
@@ -183,52 +316,216 @@ const createTypesConfig = (entryPoints)=>{
                 file: entryPoints.types
             }
         ],
-        plugins: getPlugins(nodeResolve({
-            /**
-				 * The `exports` conditional fields definition order is important in the `package.json file`.
-				 * To be resolved first, `types` field must always come first in the package.json exports definition.
-				 * @see https://devblogs.microsoft.com/typescript/announcing-typescript-4-7/#package-json-exports-imports-and-self-referencing.
-				 */ exportConditions: [
-                "types"
-            ]
-        }), dts({
-            compilerOptions: {
-                incremental: false
-            },
-            respectExternal: true
-        }))
+        plugins: getPlugins([
+            nodeResolve({
+                /**
+					 * The `exports` conditional fields definition order is important in the `package.json file`.
+					 * To be resolved first, `types` field must always come first in the package.json exports definition.
+					 * @see https://devblogs.microsoft.com/typescript/announcing-typescript-4-7/#package-json-exports-imports-and-self-referencing.
+					 */ exportConditions: [
+                    "types"
+                ]
+            }),
+            dts({
+                compilerOptions: {
+                    incremental: false
+                },
+                respectExternal: true
+            })
+        ], options)
     };
 };
-// eslint-disable-next-line import/no-default-export
-createConfigurations();
 
-const readFile = readFile$1;
+const createWatchCommand = (program)=>{
+    return createCommand(program, {
+        name: "watch",
+        description: "Watch and rebuild on any code change (development mode)"
+    }).task({
+        handler (context) {
+            watch(createConfiguration({
+                minification: context.minification,
+                sourceMaps: context.sourceMaps,
+                standalone: false
+            }));
+        }
+    });
+};
 
-const createCommand = (program, input)=>{
-    return program.command(input).option({
-        key: "minification",
-        name: "minification",
-        description: "Enable minification",
-        defaultValue: false
+const build = async (input)=>{
+    process.env.NODE_ENV ??= "production";
+    const { data: configurations } = input;
+    const output = [];
+    for (const config of configurations){
+        const initialTime = Date.now();
+        const bundle = await rollup({
+            ...config,
+            onLog
+        });
+        if (config.output) {
+            const outputEntries = Array.isArray(config.output) ? config.output : [
+                config.output
+            ];
+            const promises = [];
+            for (const outputEntry of outputEntries){
+                const outputFilePath = outputEntry.file ?? outputEntry.dir;
+                if (!outputFilePath) {
+                    throw new Error("Misconfigured file entry point. Make sure to define an `import`, `require`, or `default` field.");
+                }
+                promises.push(new Promise((resolve, reject)=>{
+                    bundle.write(outputEntry).then(()=>{
+                        resolve({
+                            elapsedTime: Date.now() - initialTime,
+                            filePath: outputFilePath
+                        });
+                    }).catch((reason)=>{
+                        reject(reason);
+                    });
+                }));
+            }
+            output.push(...await Promise.all(promises));
+        }
+    }
+    return output;
+};
+
+const TEMPORARY_PATH = resolveFromInternalDirectory("dist", "tmp");
+const TEMPORARY_DOWNLOAD_PATH = join(TEMPORARY_PATH, "zip");
+const TEMPORARY_RUNTIME_PATH = join(TEMPORARY_PATH, "runtime");
+const createCompileCommand = (program)=>{
+    return program.command({
+        name: "compile",
+        description: "Compiles the source code into a self-contained executable"
     }).option({
-        key: "sourceMaps",
-        name: "source-maps",
-        description: "Enable source maps generation",
-        defaultValue: false
+        key: "targetInput",
+        name: {
+            long: "target",
+            short: "t"
+        },
+        description: "Set a different cross-compilation target",
+        defaultValue: "local"
+    }).task({
+        key: "config",
+        label: "Create configuration",
+        handler () {
+            return createConfiguration({
+                minification: true,
+                sourceMaps: false,
+                standalone: true
+            });
+        }
+    }).task({
+        key: "osType",
+        label ({ targetInput }) {
+            return `Get \`${targetInput}\` runtime`;
+        },
+        async handler ({ targetInput }) {
+            if (targetInput === "local") {
+                await copyFile(process.execPath, TEMPORARY_RUNTIME_PATH);
+                return getOsType(os.type());
+            }
+            const matchedRuntimeParts = matchRuntimeParts(targetInput);
+            if (!matchedRuntimeParts) {
+                throw new Error("Invalid `runtime` flag input. The accepted targets are the one listed in https://nodejs.org/download/release/ with the following format `node-vx.y.z-(darwin|linux|win)-(arm64|x64|x86)`.");
+            }
+            const osType = getOsType(matchedRuntimeParts.os);
+            const extension = osType === "windows" ? "zip" : "tar.gz";
+            await download(`https://nodejs.org/download/release/${matchedRuntimeParts.version}/${targetInput}.${extension}`, TEMPORARY_DOWNLOAD_PATH);
+            await unzip({
+                path: TEMPORARY_DOWNLOAD_PATH,
+                targetedArchivePath: osType === "windows" ? join(targetInput, "node.exe") : join(targetInput, "bin", "node")
+            }, {
+                directoryPath: dirname(TEMPORARY_RUNTIME_PATH),
+                filename: basename(TEMPORARY_RUNTIME_PATH)
+            });
+            return osType;
+        }
+    }).task({
+        label: "Build",
+        async handler ({ config }) {
+            await build(config);
+        }
+    }).task({
+        label ({ config }) {
+            const binaries = config.metadata.map(({ bin })=>{
+                if (!bin) return undefined;
+                return `\`${bin}\``;
+            }).filter(Boolean).join(", ");
+            return `Compile ${binaries}`;
+        },
+        async handler ({ config, osType }) {
+            await Promise.all(config.metadata.map(async ({ bin, require })=>{
+                if (!require || !bin) return;
+                return compile({
+                    bin,
+                    input: require,
+                    osType
+                });
+            }));
+        }
     });
 };
+const getOsType = (input)=>{
+    switch(input){
+        case "Windows_NT":
+        case "win":
+            return "windows";
+        case "Darwin":
+        case "darwin":
+            return "macos";
+        case "Linux":
+        case "linux":
+            return "linux";
+        default:
+            throw new Error(`Unsupported operating system \`${input}\``);
+    }
+};
+const matchRuntimeParts = createRegExpMatcher(/^node-(?<version>v\d+\.\d+\.\d+)-(?<os>darwin|linux|win)-(?<architecture>arm64|x64|x86)$/);
+const compile = async ({ bin, input, osType })=>{
+    const inputFileName = basename(input);
+    const inputDirectory = dirname(input);
+    const resolveFromInputDirectory = (...paths)=>{
+        return resolve(inputDirectory, ...paths);
+    };
+    const blobFileName = resolveFromInputDirectory(`${inputFileName}.blob`);
+    const executableFileName = resolveFromInputDirectory(`${bin}${osType === "windows" ? ".exe" : ""}`);
+    const seaConfigFileName = resolveFromInputDirectory(`${inputFileName}.sea-config.json`);
+    await writeFile(seaConfigFileName, JSON.stringify({
+        disableExperimentalSEAWarning: true,
+        main: input,
+        output: blobFileName,
+        useCodeCache: false,
+        useSnapshot: false
+    }));
+    await Promise.all([
+        helpers.exec(`node --experimental-sea-config ${seaConfigFileName}`),
+        copyFile(TEMPORARY_RUNTIME_PATH, executableFileName)
+    ]);
+    if (osType === "macos") {
+        await helpers.exec(`codesign --remove-signature ${executableFileName}`);
+    }
+    await helpers.exec(`npx postject ${executableFileName} NODE_SEA_BLOB ${blobFileName} --sentinel-fuse NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2 ${osType === "macos" ? "--macho-segment-name NODE_SEA" : ""}`);
+    if (osType === "macos") {
+        await helpers.exec(`codesign --sign - ${executableFileName}`);
+    }
+    await Promise.all([
+        blobFileName,
+        seaConfigFileName,
+        TEMPORARY_PATH
+    ].map(async (path)=>removePath(path)));
+};
 
 const createBuildCommand = (program)=>{
-    createCommand(program, {
+    return createCommand(program, {
         name: "build",
         description: "Build the source code (production mode)"
     }).task({
         key: "buildOutput",
         label: "Bundle assets 📦",
         async handler (context) {
-            return build(createConfigurations({
+            return build(createConfiguration({
                 minification: context.minification,
-                sourceMaps: context.sourceMaps
+                sourceMaps: context.sourceMaps,
+                standalone: false
             }));
         }
     }).task({
@@ -249,7 +546,7 @@ const createBuildCommand = (program)=>{
                 ].map((message, index)=>{
                     return index === 0 ? message : `   ${message}`;
                 }).join("\n"), {
-                    label: `${item.filename} (took ${item.elapsedTime}ms)`,
+                    label: `${item.filePath} (took ${item.elapsedTime}ms)`,
                     type: "information"
                 });
             });
@@ -261,7 +558,7 @@ const createBuildCommand = (program)=>{
 };
 const computeBundleSize = async (buildOutput)=>{
     const computeFileSize = async (buildItemOutput)=>{
-        const content = await readFile(buildItemOutput.filename);
+        const content = await readFile(buildItemOutput.filePath);
         const gzSize = await gzipSize(content);
         return {
             ...buildItemOutput,
@@ -276,70 +573,14 @@ const formatSize = (bytes)=>{
     return kiloBytes < 1 ? `${bytes} B` : `${kiloBytes.toFixed(2)} kB`;
 };
 
-const watch = (configurations)=>{
-    process.env.NODE_ENV ??= "development";
-    const watcher = watch$1(configurations.map((config)=>({
-            ...config,
-            onLog
-        })));
-    let startDuration;
-    console.clear();
-    watcher.on("event", async (event)=>{
-        switch(event.code){
-            case "START":
-                {
-                    startDuration = Date.now();
-                    clearLog(`Build in progress...`, {
-                        type: "information"
-                    });
-                    return;
-                }
-            case "BUNDLE_END":
-                await event.result.close();
-                break;
-            case "END":
-                {
-                    const duration = Date.now() - startDuration;
-                    clearLog(`Build done in ${duration}ms (at ${new Date().toLocaleTimeString()})`, {
-                        type: "success"
-                    });
-                    return;
-                }
-            case "ERROR":
-                {
-                    const { error } = event;
-                    clearLog(`${String(error)}`, {
-                        type: "error"
-                    });
-                    console.error("\n", error);
-                    return;
-                }
-        }
-    });
-};
-const clearLog = (...input)=>{
-    console.clear();
-    helpers.message(...input);
-};
-
-const createWatchCommand = (program)=>{
-    createCommand(program, {
-        name: "watch",
-        description: "Watch and rebuild on any code change (development mode)"
-    }).task({
-        handler (context) {
-            watch(createConfigurations({
-                minification: context.minification,
-                sourceMaps: context.sourceMaps
-            }));
-        }
-    });
-};
-
 const createProgram = (...commandBuilders)=>{
-    const program = termost("The zero-configuration transpiler and bundler for the web");
+    const program = termost({
+        name,
+        description: "The zero-configuration transpiler and bundler for the web",
+        version
+    });
     for (const commandBuilder of commandBuilders){
         commandBuilder(program);
     }
 };
-createProgram(createBuildCommand, createWatchCommand);
+createProgram(createBuildCommand, createWatchCommand, createCompileCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quickbundle",
-  "version": "2.6.0",
+  "version": "2.8.0",
   "description": "The zero-configuration transpiler and bundler for the web",
   "author": {
     "name": "Ayoub Adib",
@@ -40,7 +40,7 @@
     }
   },
   "peerDependencies": {
-    "typescript": ">=4.7.0"
+    "typescript": "^4.7.0 || ^5.0.0"
   },
   "peerDependenciesMeta": {
     "typescript": {
@@ -52,19 +52,21 @@
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.3.0",
     "@rollup/plugin-url": "^8.0.2",
-    "@swc/core": "^1.7.42",
+    "@swc/core": "^1.9.1",
+    "decompress": "^4.2.1",
     "gzip-size": "^7.0.0",
-    "rollup": "^4.24.3",
+    "rollup": "^4.24.4",
     "rollup-plugin-dts": "^6.1.1",
     "rollup-plugin-node-externals": "^7.1.3",
     "rollup-plugin-swc3": "^0.12.1",
-    "termost": "^0.18.0"
+    "termost": "^1.2.0"
   },
   "devDependencies": {
-    "@types/node": "22.8.5"
+    "@types/decompress": "4.2.7",
+    "@types/node": "22.9.0"
   },
   "scripts": {
-    "build": "rollup --config ./src/bundler/config.ts --configPlugin rollup-plugin-swc3",
-    "watch": "rollup --watch --config ./src/bundler/config.ts --configPlugin rollup-plugin-swc3"
+    "build": "rollup --config ./bundler.config.ts --configPlugin rollup-plugin-swc3",
+    "watch": "rollup --watch --config ./bundler.config.ts --configPlugin rollup-plugin-swc3"
   }
 }