fulmine.js 5.5.1 → 5.6.0

package/COMPRESSION_LICENSE

@@ -0,0 +1,25 @@
+compression License (only code derived from the compression module).
+
+(The MIT License)
+
+Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
+Copyright (c) 2014-2015 Douglas Christopher Wilson <doug@somethingdoug.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/NOTICE

@@ -43,6 +43,15 @@ every copy:
   IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
   DEALINGS IN THE SOFTWARE.
 
+This product includes test code derived from the compression middleware
+(https://github.com/expressjs/compression), ported in
+tests/unit/compression.test.js and licensed under the MIT License. Its terms
+travel with this repository in COMPRESSION_LICENSE, and the copyright it
+requires to be carried is:
+
+  Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
+  Copyright (c) 2014-2015 Douglas Christopher Wilson <doug@somethingdoug.com>
+
 As required by section 4(b) of the Apache License, the following are the
 significant changes made to the original work:
 

package/README.md

@@ -1,6 +1,6 @@
 <img src="./assets/logo-mark.svg" alt="" width="88" align="right">
 
-# Fulmine
+# Fulmine.js
 
 A drop-in replacement for Express 5, running on [µWebSockets.js](https://github.com/uNetworking/uWebSockets.js) instead of `node:http`. Your existing middleware keeps working.
 
@@ -26,12 +26,6 @@ npx fulmine profile             # what listen() decided about each route
 
 See [Migrating](#migrating) for what it handles and what it deliberately does not.
 
-There is a **[live demo](https://fulmine-demo.fly.dev)**, which is an ordinary Express application:
-real routes, `helmet`, `cors`, `compression`, `express-session` and `morgan` unmodified, and a
-WebSocket chat served by `app.ws()`. It links to [its own source](https://fulmine-demo.fly.dev/source),
-which is [in this repository](./demo). It shows no throughput figure on purpose: it runs on a small
-shared machine, so the number would describe the machine rather than the framework.
-
 [![npm version](https://img.shields.io/npm/v/fulmine.js)](https://www.npmjs.com/package/fulmine.js)
 [![Node.js >= 22.0.0](https://img.shields.io/badge/Node.js-%3E=22.0.0-green)](https://nodejs.org)
 [![Coverage Status](https://coveralls.io/repos/github/nigrosimone/fulmine.js/badge.svg?branch=main)](https://coveralls.io/github/nigrosimone/fulmine.js?branch=main)
@@ -65,7 +59,6 @@ shared machine, so the number would describe the machine rather than the framewo
     - [Router](#router)
 - [Tested middlewares](#tested-middlewares)
 - [Tested view engines](#tested-view-engines)
-- [The demo](https://fulmine-demo.fly.dev)
 - [Working on Fulmine](./CONTRIBUTING.md)
 
 ## Why this exists
@@ -96,7 +89,7 @@ to run it yourself.
 
 Numbers produced by a project about itself deserve suspicion, so Fulmine also stands in public arenas, run by their own rigs under their own rules:
 
-- **[HttpArena](https://www.http-arena.com/#sort=rps:-1&q=Js)** (the link lands filtered on the JavaScript entries): first among the JavaScript entries, across fifteen subscribed profiles. The saved runs measure 24.3 million WebSocket echoes per second pipelined and 3.77 million one-at-a-time (past Bun's own dedicated WebSocket entry), 7.3 million pipelined HTTP requests per second, 1.12 million on the json profile with 1.04 million of that surviving TLS, 457 thousand on compressed json, and 359 thousand on the Postgres CRUD profile, within ten percent of the leading Rust and C# entries there.
+- **[HttpArena](https://www.http-arena.com/#sort=rps:-1&q=Js)**: thirty profiles on 64-core dedicated hardware, same conditions for every entry, rerun whenever one of them changes. The link lands filtered on the JavaScript entries. No figures are copied here on purpose: the board is the current one and this page would not be.
 - **[web-frameworks](https://web-frameworks-benchmark.netlify.app/result?l=javascript)**: entry merged, numbers arrive with their next published round.
 
 More to come as their maintainers take the entries in.
@@ -131,6 +124,10 @@ npx fulmine differences         # print the list below and change nothing
 The command is installed under both `fulmine` and `fulmine.js`. Use `fulmine`: `npx` cannot run a
 command whose name ends in `.js` on Windows, where it exits without a word.
 
+It also names the middlewares it found that have a faster one built in here, `compression`,
+`body-parser` and `serve-static`, and leaves them to you: the replacement is reached through the
+`express` import, and no rewrite can know that it is in scope where they are required.
+
 ### Angular SSR
 
 The `server.ts` that `ng add @angular/ssr` generates is an ordinary Express application, so the same
@@ -202,12 +199,17 @@ Bun is not an option: µWebSockets.js is a native Node addon, and Bun does not l
 
 ## Docker
 
-Two things about µWebSockets.js make a Dockerfile that works for Express fail here, and both have easy answers:
+Three things about µWebSockets.js make a Dockerfile that works for Express fail here, and all three have easy answers:
 
 - **No Alpine, and no Debian bookworm either.** µWebSockets.js ships prebuilt binaries linked against glibc 2.38 or newer. Alpine images use musl, so the binary does not load at all; `node:26` and `node:26-slim` are Debian bookworm, whose glibc 2.36 fails at startup with `GLIBC_2.38' not found`. Use the trixie variants: `node:26-trixie-slim` and up.
 - **`git` must be there when `npm install` runs.** µWebSockets.js is not on npm; it is installed straight from GitHub (`github:uNetworking/uWebSockets.js`), and npm uses git to fetch it. Full images like `node:26-trixie` have git; `-slim` ones do not.
+- **git must be allowed to speak https.** Where the build environment rewrites GitHub URLs to ssh, which some CI images and company-wide git configs do, the fetch asks for a key the image does not have and the install dies on a permission denied that never names µWebSockets.js. One line before `npm ci` puts it back:
 
-The clean way to satisfy both is a multi-stage build: install with the full image, run with the slim one.
+    ```dockerfile
+    RUN git config --global url."https://github.com/".insteadOf "ssh://git@github.com/"
+    ```
+
+The clean way to satisfy the first two is a multi-stage build: install with the full image, run with the slim one.
 
 ```dockerfile
 FROM node:26-trixie AS build
@@ -230,6 +232,7 @@ A single-stage `node:26-trixie-slim` image works too if you `apt-get install -y
 - `app.listen()` returns the app, not an `http.Server`. There is no node server underneath, so `server.close()`, `server.address()` and anything that attaches itself to a real `http.Server` need a look. `app.close()`, `app.address()` and `app.listening` are there and do what you would expect.
 - `x-powered-by` is disabled by default. Express sends `X-Powered-By: Express` unless you turn it off; Fulmine does not send it unless you turn it on with `app.set("x-powered-by", true)`. The header only tells anyone asking which framework is running.
 - request body is only read for POST, PUT, PATCH and QUERY requests by default. You can add additional methods by setting `body methods` to array with uppercased methods.
+- **Informational responses go nowhere.** `res.writeEarlyHints()`, `res.writeContinue()` and `res.writeProcessing()` are all there, take what node's take and throw what node's throw once the head has gone out, but nothing reaches the wire: µWebSockets.js has no API for a `1xx`. They exist so that code written for Express keeps running rather than dying on "is not a function", which is the only thing a drop-in can honestly promise here. `res.addTrailers()` is the same story, and `res.setTimeout()` and `req.setTimeout()` register the listener without changing anything, since µWS runs its own idle timeout through `uwsOptions.idleTimeout`.
 - For HTTPS, instead of doing this:
 
 ```js
@@ -371,17 +374,24 @@ Worth changing, if these are routes that carry traffic
 
 It loads the application with `listen()` replaced by the half that compiles the routes, so nothing binds a port and the listen callback does not run: profiling a running service does not start a second copy of it. There is no score, on purpose. A percentage of routes is not a percentage of traffic, and an application with a thousand cold routes and one hot one that fell back would score well and serve badly.
 
-2. Do not use external `serve-static` module. Instead use built-in `express.static()` middleware, which is optimized for Fulmine.
+2. Do not use external `serve-static` module. Instead use built-in `express.static()` middleware, which is optimized for Fulmine. If your build already writes `.br` and `.gz` files next to the originals, `express.static(dir, { preCompressed: true })` serves those to the clients that accept them, so nothing is compressed at request time. It costs one more `stat` per request and sends a fraction of the bytes: on a 4KB script with a brotli twin, 12 times fewer. `Vary: Accept-Encoding` is sent whether or not a variant is found, the content type stays the one the requested name implies, and each variant carries its own ETag.
 
 3. Do not use `body-parser` module. Instead use built-in `express.text()`, `express.json()` etc.
 
-4. If a route answers with a JSON shape you know in advance, [express-fast-json-stringify](https://www.npmjs.com/package/express-fast-json-stringify) compiles that shape into a serializer and `res.fastJson()` replaces `res.json()`. `JSON.stringify()` has to walk an object it knows nothing about; a compiled serializer does not.
+4. Do not use the `compression` module. `express.compression()` takes the same options and decides the same way, and it served about 50% more requests per second on an 8KB JSON body here, gzip and brotli alike. A response that arrives whole, which is every `res.send()` and `res.json()`, is compressed in one call rather than through a transform stream and goes out with a `Content-Length` instead of chunked; a response written in pieces still streams. The bytes are the same bytes either way.
+
+```js
+// the compression module's options, unchanged: threshold, filter, level, brotli, enforceEncoding
+app.use(express.compression({ threshold: 1024 }));
+```
+
+5. If a route answers with a JSON shape you know in advance, [express-fast-json-stringify](https://www.npmjs.com/package/express-fast-json-stringify) compiles that shape into a serializer and `res.fastJson()` replaces `res.json()`. `JSON.stringify()` has to walk an object it knows nothing about; a compiled serializer does not.
 
-5. Do not set `body methods` to read body of requests with GET method or other methods that don't need a body. Reading body makes endpoint about 15% slower.
+6. Do not set `body methods` to read body of requests with GET method or other methods that don't need a body. Reading body makes endpoint about 15% slower.
 
-6. `app.set("etag", false)` is worth about 8% on small responses, measured on both Fulmine and Express, which pay it almost identically. Know what you are trading: without an ETag a client cannot make a conditional request, so there are no `304 Not Modified` replies and every response is downloaded in full. On anything cacheable the bandwidth a 304 saves is usually worth far more than the 8%. It is left on by default for that reason. Turn it off for an API whose responses are never revalidated.
+7. `app.set("etag", false)` is worth about 8% on small responses, measured on both Fulmine and Express, which pay it almost identically. Know what you are trading: without an ETag a client cannot make a conditional request, so there are no `304 Not Modified` replies and every response is downloaded in full. On anything cacheable the bandwidth a 304 saves is usually worth far more than the 8%. It is left on by default for that reason. Turn it off for an API whose responses are never revalidated.
 
-7. By default, Fulmine creates 1 (or 0 if your CPU has only 1 core) child thread to improve performance of reading files. You can change this number by setting `threads` to a different number in `express()`, or set to 0 to disable thread pool (`express({ threads: 0 })`). Threads are shared between all express() instances, with largest `threads` number being used. Using more threads will not necessarily improve performance. Sometimes not using threads at all is faster, so measure both.
+8. By default, Fulmine creates 1 (or 0 if your CPU has only 1 core) child thread to improve performance of reading files. You can change this number by setting `threads` to a different number in `express()`, or set to 0 to disable thread pool (`express({ threads: 0 })`). Threads are shared between all express() instances, with largest `threads` number being used. Using more threads will not necessarily improve performance. Sometimes not using threads at all is faster, so measure both.
 
 ## WebSockets
 
@@ -511,6 +521,7 @@ In general, basically all features and options are supported. Use the [Express 5
 - ✅ express.static()
 - ✅ express.text()
 - ✅ express.raw()
+- ✅ express.compression(). Fulmine's own, since Express has none: it is the [compression](https://npmjs.com/package/compression) module's options and behaviour built in, described under [Performance tips](#performance-tips).
 - 🚧 express.request (this is not a constructor but a prototype for replacing methods)
 - 🚧 express.response (this is not a constructor but a prototype for replacing methods)
 - 🚧 express.application (likewise: a method added here is on every app)
@@ -569,7 +580,7 @@ Two of these keep a compiled form alongside the value, which you can also set di
 Fulmine adds three of its own:
 
 - `declarative responses`, on by default. Lets a simple enough handler be compiled into a native uWS response, described under [Performance tips](#performance-tips).
-- `file cache`, on by default. Small files served by `res.sendFile` come from a bounded in-process cache, checked against the file's `stat` on every request, so an edited file is never served stale.
+- `file cache`, on by default. Small files served by `res.sendFile` come from a bounded in-process cache, checked against the file's `stat` on every request, so an edited file is never served stale. Turn it off where every request has to reach the disk, which is what a public benchmark asks of a standard entry: it was worth about 4% on a 4KB file here, so the cost of turning it off is small.
 - `trust proxy protocol`, off by default. Takes `req.ip` from a PROXY protocol preamble, described under [Behind a proxy](#behind-a-proxy). Read the warning there before turning it on.
 
 ### Request
@@ -677,7 +688,7 @@ Almost all middlewares that are compatible with Express are compatible with Fulm
 - ✅ [body-parser](https://npmjs.com/package/body-parser) (use `express.text()` etc instead for better performance)
 - ✅ [cookie-parser](https://npmjs.com/package/cookie-parser)
 - ✅ [cookie-session](https://npmjs.com/package/cookie-session)
-- ✅ [compression](https://npmjs.com/package/compression)
+- ✅ [compression](https://npmjs.com/package/compression) (use `express.compression()` instead for better performance)
 - ✅ [serve-static](https://npmjs.com/package/serve-static) (use `express.static()` instead for better performance)
 - ✅ [serve-index](https://npmjs.com/package/serve-index)
 - ✅ [cors](https://npmjs.com/package/cors)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fulmine.js",
-    "version": "5.5.1",
+    "version": "5.6.0",
     "description": "Drop-in Express 5 replacement on uWebSockets.js. Your existing middleware keeps working.",
     "main": "src/index.js",
     "bin": {
@@ -40,7 +40,8 @@
         "src",
         "LICENSE",
         "NOTICE",
-        "EXPRESS_LICENSE"
+        "EXPRESS_LICENSE",
+        "COMPRESSION_LICENSE"
     ],
     "repository": {
         "type": "git",
@@ -72,6 +73,7 @@
         "accepts": "^2.0.0",
         "acorn": "^8.16.0",
         "bytes": "^3.1.2",
+        "compressible": "^2.0.18",
         "content-disposition": "^1.1.0",
         "cookie": "^1.1.1",
         "cookie-signature": "^1.2.2",

package/src/application.js

@@ -500,31 +500,16 @@ class Application extends Router {
      * @param {any} res the uWS response
      * @param {any} req the uWS request
      */
-    async _serveGeneric(res, req) {
+    _serveGeneric(res, req) {
         const request = this.handleRequest(res, req);
         const response = request.res;
-        // armed up front here: this handler awaits, so the response outlives the callback
-        // on every path through it
+        // armed up front here: this handler can outlive the callback on every path through it
         this._armAbort(res, response);
 
-        try {
-            const routed = this._routeRequest(request, response);
-            // dispatch has run its synchronous stretch inside _routeRequest by now, still
-            // under the cork uWS holds for this callback; the await below leaves it
-            response._corkNeeded = true;
-            const matchedRoute = await routed;
-            if (!matchedRoute && !response.headersSent && !response.aborted) {
-                this._endUnmatched(request, response);
-            }
-        } catch (err) {
-            // an internal throw answers 500 as express's final handler would, instead of
-            // dying as an unhandled rejection
-            if (response.aborted || response.finished) {
-                console.error(err);
-            } else {
-                this._handleError(err, null, request, response);
-            }
-        }
+        this._routeRequestDirect(request, response);
+        // the synchronous stretch has run under the cork uWS holds for this callback, and
+        // whatever comes after it is outside
+        response._corkNeeded = true;
     }
 
     /**

package/src/cli.js

@@ -34,6 +34,16 @@ const acorn = require("acorn");
 const FROM = "express";
 const TO = "fulmine.js";
 
+// Modules this has a faster version of, spotted while the files are being read anyway. They are
+// reported and not rewritten: the replacement is reached through the express import, which this
+// command cannot know is in scope in the file that requires them, and body-parser is four
+// functions rather than one.
+const BUILT_IN_INSTEAD = {
+    compression: "express.compression(), which takes the same options",
+    "serve-static": "express.static()",
+    "body-parser": "express.json(), express.urlencoded(), express.text(), express.raw()"
+};
+
 const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "coverage", ".nyc_output", ".next"]);
 const EXTENSIONS = new Set([".js", ".mjs", ".cjs", ".ts", ".mts", ".cts", ".tsx"]);
 const TYPESCRIPT_EXTENSIONS = new Set([".ts", ".mts", ".cts", ".tsx"]);
@@ -139,9 +149,10 @@ function loadTypeScript(target) {
  * @param {string} source
  * @param {string} fileName decides whether JSX is allowed, so a .tsx angle bracket is not a cast
  * @param {any} ts the compiler
+ * @param {Set<string>} [seen] as in findSpecifiers
  * @returns {{start: number, end: number}[]}
  */
-function findSpecifiersTypeScript(source, fileName, ts) {
+function findSpecifiersTypeScript(source, fileName, ts, seen) {
     const sourceFile = ts.createSourceFile(
         fileName,
         source,
@@ -152,7 +163,14 @@ function findSpecifiersTypeScript(source, fileName, ts) {
 
     /** @type {{start: number, end: number}[]} */
     const found = [];
-    const take = (node) => found.push({ start: node.getStart(sourceFile), end: node.getEnd() });
+    /** @param {any} node a string literal naming a module */
+    const take = (node) => {
+        if (node.text === FROM) {
+            found.push({ start: node.getStart(sourceFile), end: node.getEnd() });
+        } else if (seen && BUILT_IN_INSTEAD[node.text]) {
+            seen.add(node.text);
+        }
+    };
 
     const visit = (node) => {
         // import express from "express", import type { Request } from "express", export * from it.
@@ -160,23 +178,21 @@ function findSpecifiersTypeScript(source, fileName, ts) {
         if (
             (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
             node.moduleSpecifier &&
-            ts.isStringLiteral(node.moduleSpecifier) &&
-            node.moduleSpecifier.text === FROM
+            ts.isStringLiteral(node.moduleSpecifier)
         ) {
             take(node.moduleSpecifier);
         } else if (
             // import express = require("express"), which is TypeScript's own spelling
             ts.isImportEqualsDeclaration(node) &&
             ts.isExternalModuleReference(node.moduleReference) &&
-            ts.isStringLiteral(node.moduleReference.expression) &&
-            node.moduleReference.expression.text === FROM
+            ts.isStringLiteral(node.moduleReference.expression)
         ) {
             take(node.moduleReference.expression);
         } else if (ts.isCallExpression(node)) {
             const isRequire = ts.isIdentifier(node.expression) && node.expression.text === "require";
             const isDynamicImport = node.expression.kind === ts.SyntaxKind.ImportKeyword;
             const arg = node.arguments[0];
-            if ((isRequire || isDynamicImport) && arg && ts.isStringLiteral(arg) && arg.text === FROM) {
+            if ((isRequire || isDynamicImport) && arg && ts.isStringLiteral(arg)) {
                 take(arg);
             }
         }
@@ -193,9 +209,11 @@ function findSpecifiersTypeScript(source, fileName, ts) {
  * imports at all, and none of those may be rewritten.
  *
  * @param {string} source
+ * @param {Set<string>} [seen] collects the names of the modules with something built in here,
+ *   which are recognised on the same walk rather than on one of their own
  * @returns {{start: number, end: number}[]|null} null when the file does not parse
  */
-function findSpecifiers(source) {
+function findSpecifiers(source, seen) {
     /** @type {any} */
     let tree;
     // A file is either a module or a script and the parser has to be told which. Try module first,
@@ -220,15 +238,23 @@ function findSpecifiers(source) {
 
     /** @type {{start: number, end: number}[]} */
     const found = [];
+    /** @param {any} node a string literal naming a module */
+    const record = (node) => {
+        if (node.value === FROM) {
+            found.push({ start: node.start, end: node.end });
+        } else if (seen && BUILT_IN_INSTEAD[node.value]) {
+            seen.add(node.value);
+        }
+    };
     walk(tree, (node) => {
         // import express from "express", export * from "express"
         if (
             (node.type === "ImportDeclaration" ||
                 node.type === "ExportNamedDeclaration" ||
                 node.type === "ExportAllDeclaration") &&
-            node.source?.value === FROM
+            typeof node.source?.value === "string"
         ) {
-            found.push({ start: node.source.start, end: node.source.end });
+            record(node.source);
             return;
         }
         // require("express") and import("express"), the second being a node of its own
@@ -237,8 +263,8 @@ function findSpecifiers(source) {
         const isDynamicImport = node.type === "ImportExpression";
         if (isRequire || isDynamicImport) {
             const arg = isDynamicImport ? node.source : node.arguments?.[0];
-            if (arg?.type === "Literal" && arg.value === FROM) {
-                found.push({ start: arg.start, end: arg.end });
+            if (arg?.type === "Literal" && typeof arg.value === "string") {
+                record(arg);
             }
         }
     });
@@ -582,6 +608,8 @@ Options:
     const unparsed = [];
     /** @type {string[]} */
     const needTypeScript = [];
+    /** @type {Set<string>} */
+    const builtInInstead = new Set();
 
     // resolved once, and only if there is anything to use it on
     const hasTypeScriptFiles = files.some((file) => TYPESCRIPT_EXTENSIONS.has(path.extname(file)));
@@ -590,8 +618,8 @@ Options:
     for (const file of files) {
         const source = fs.readFileSync(file, "utf8");
         // reading every file's AST to find nothing is the common case, so skip the ones that
-        // cannot contain the specifier at all
-        if (!source.includes(FROM)) continue;
+        // cannot contain any of the names being looked for
+        if (!source.includes(FROM) && !Object.keys(BUILT_IN_INSTEAD).some((name) => source.includes(name))) continue;
 
         const isTypeScript = TYPESCRIPT_EXTENSIONS.has(path.extname(file));
         if (isTypeScript && !ts) {
@@ -599,7 +627,9 @@ Options:
             continue;
         }
 
-        const specifiers = isTypeScript ? findSpecifiersTypeScript(source, file, ts) : findSpecifiers(source);
+        const specifiers = isTypeScript
+            ? findSpecifiersTypeScript(source, file, ts, builtInInstead)
+            : findSpecifiers(source, builtInInstead);
         if (specifiers === null) {
             unparsed.push(path.relative(target, file));
             continue;
@@ -635,6 +665,18 @@ Options:
     console.log(
         `\n${dryRun ? "would rewrite" : "rewrote"} ${changedImports} import(s) in ${changedFiles} file(s) of ${files.length} scanned`
     );
+
+    // said whether or not anything was rewritten: an application migrated last month still has
+    // these, and they are the difference between running on µWS and running through a middleware
+    // that was written for node streams
+    if (builtInInstead.size) {
+        console.log(`\n${builtInInstead.size} module(s) with a faster one built in here, worth replacing by hand:`);
+        for (const name of builtInInstead) {
+            console.log(`  ${name} -> ${BUILT_IN_INSTEAD[name]}`);
+        }
+        console.log("");
+    }
+
     if (changedFiles) {
         console.log(`Remember to install it: npm install ${TO}`);
         printDifferences();