closure-compiler VS minification-benchmarks

The most well-known tools that rely on JSDoc are Closure Compiler (not to be confused with the Closure programming language) and TypeScript. Both of these tools can help make your JavaScript typed, but they approach it differently. Closure Compiler primarily focuses on enhancing your .js files by adding typing through JSDoc annotations (after all, they are just comments), while TypeScript is designed for .ts files, introducing its own well-known TypeScript constructs such as type, interface, enum, namespace, and so on.

Closure Compiler follows the same line of thinking:

https://github.com/google/closure-compiler/wiki/FAQ#closure-...

I think only Google Closure Compiler did some optimizations based on its JSDoc-style annotations (see docs). If I remember correctly, types mostly allowed renaming objects' properties across modules, but most other advanced optimizations (like dead code elimination or functions inlining) didn't rely on types. In my experience properties renaming resulted in subtle, hard to discover bugs and I'd say they didn't bring much benefit.

The @template tag is supported by Google Closure Compiler

i'm not sure you want them to write back https://github.com/google/closure-compiler/pull/3958

time to fork

I just came across the Google Closure Compiler. As the documentation says, it does not create machine code, but rather, "compiles JavaScript to better JavaScript".

Minifiers are used to reduce the size of the bundle. They can remove unused code, shorten expressions, and so on. And Now there are already several popular minifiers, and they continue to appear: more familiar ones - written in JavaScript - Terser and UglifyJS, even Babel has its own version of the minifier, there are also more modern SWC (written in Rust) and ESBuild (written in Go), and a bunch of other lesser-known minifiers. And I recommend you to look at this repository. It contains up-to-date test results of various popular minifiers.

This minify/gzip size effect is a well known quirk to developers of javascript minifiers. The minifier's symbol mangling algorithm often has a more pronounced effect than does advanced AST optimization.

This website has real life data on the matter for popular libraries:

* https://github.com/privatenumber/minification-benchmarks

Compare the trophies indicating smallest size for Minified versus Minzipped (gzip). Generally the smallest minified size yields the smallest minified+gzip size, but there are some notable anomolies outside the range of statistical noise. It is not practical for a javascript minifier to take a compression algorithm into account - it would blow up the minify timings exponentially.

It would be helpful to see how Bun's minifier compares to the others with popular libraries:

https://github.com/privatenumber/minification-benchmarks

JavaScript

There are many minifiers such as terser and uglify. But, because minifying also require to parse the JS, it is actually possible to use esbuild and SWC to minify the code. Here's a benchmark of the main minifiers.

Here's a comparison showing the major players with comparable stats at first glance. https://github.com/privatenumber/minification-benchmarks

https://esbuild.github.io/ https://github.com/privatenumber/minification-benchmarks

privatenumber/minification-benchmarks – JS minification benchmarks: babel-minify, esbuild, terser, uglify-js