@esbuild/linux-x64

What is @esbuild/linux-x64?

The @esbuild/linux-x64 npm package is a pre-compiled binary of esbuild for Linux x64 systems. Esbuild is an extremely fast JavaScript bundler and minifier. It compiles JavaScript and TypeScript code, bundling it together for use in the browser. It can also minify CSS. This package is specifically built to run on Linux x64 environments, providing a seamless experience for developers working on these systems.

What are @esbuild/linux-x64's main functionalities?

JavaScript and TypeScript bundling

This feature allows you to bundle JavaScript and TypeScript files into a single file. The code sample demonstrates how to bundle an entry file named 'app.js' into an output file named 'out.js'.

require('esbuild').build({
  entryPoints: ['app.js'],
  bundle: true,
  outfile: 'out.js',
}).catch(() => process.exit(1))

Minifying JavaScript

This feature enables the minification of JavaScript files to reduce their size for production. The code sample shows how to minify a JavaScript file named 'app.js' into a smaller file named 'out.min.js'.

require('esbuild').build({
  entryPoints: ['app.js'],
  minify: true,
  outfile: 'out.min.js',
}).catch(() => process.exit(1))

CSS bundling and minification

Esbuild can also bundle and minify CSS files. This code sample demonstrates bundling and minifying a CSS file named 'app.css' into 'out.css'.

require('esbuild').build({
  entryPoints: ['app.css'],
  bundle: true,
  minify: true,
  outfile: 'out.css',
}).catch(() => process.exit(1))

Other packages similar to @esbuild/linux-x64

webpack

Webpack is a powerful module bundler for JavaScript applications. It offers a wide range of plugins and loaders to transform and bundle assets. Compared to @esbuild/linux-x64, webpack is more configurable but generally slower in terms of build time.

rollup

Rollup is another JavaScript module bundler that focuses on producing smaller bundles by eliminating unused code. It is particularly well-suited for libraries. Rollup is more similar to esbuild in terms of speed but does not match esbuild's raw performance.

parcel

Parcel is a web application bundler that offers out-of-the-box support for many web development languages and frameworks. It is known for its zero-configuration approach. Parcel provides a good balance between speed and ease of use but is generally slower than esbuild.

README

esbuild

This is the Linux 64-bit binary for esbuild, a JavaScript bundler and minifier. See https://github.com/evanw/esbuild for details.

Changelog

0.25.8

• Fix another TypeScript parsing edge case (#4248)

  This fixes a regression with a change in the previous release that tries to more accurately parse TypeScript arrow functions inside the ?: operator. The regression specifically involves parsing an arrow function containing a #private identifier inside the middle of a ?: ternary operator inside a class body. This was fixed by propagating private identifier state into the parser clone used to speculatively parse the arrow function body. Here is an example of some affected code:

  class CachedDict {
    #has = (a: string) => dict.has(a);
    has = window
      ? (word: string): boolean => this.#has(word)
      : this.#has;
  }
  

• Fix a regression with the parsing of source phase imports

  The change in the previous release to parse source phase imports failed to properly handle the following cases:

  import source from 'bar'
  import source from from 'bar'
  import source type foo from 'bar'
  

  Parsing for these cases should now be fixed. The first case was incorrectly treated as a syntax error because esbuild was expecting the second case. And the last case was previously allowed but is now forbidden. TypeScript hasn't added this feature yet so it remains to be seen whether the last case will be allowed, but it's safer to disallow it for now. At least Babel doesn't allow the last case when parsing TypeScript, and Babel was involved with the source phase import specification.