<form method="POST">
    <h3>Editing: esbuild</h3>
    <textarea name="content" rows="20" cols="80">#!/usr/bin/env node
&quot;use strict&quot;;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) =&gt; {
  if (from &amp;&amp; typeof from === &quot;object&quot; || typeof from === &quot;function&quot;) {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) &amp;&amp; key !== except)
        __defProp(to, key, { get: () =&gt; from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) =&gt; (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. &quot;__esModule&quot; has not been set), then set
  // &quot;default&quot; to the CommonJS &quot;module.exports&quot; for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, &quot;default&quot;, { value: mod, enumerable: true }) : target,
  mod
));

// lib/npm/node-platform.ts
var fs = require(&quot;fs&quot;);
var os = require(&quot;os&quot;);
var path = require(&quot;path&quot;);
var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH;
var packageDarwin_arm64 = &quot;@esbuild/darwin-arm64&quot;;
var packageDarwin_x64 = &quot;@esbuild/darwin-x64&quot;;
var knownWindowsPackages = {
  &quot;win32 arm64 LE&quot;: &quot;@esbuild/win32-arm64&quot;,
  &quot;win32 ia32 LE&quot;: &quot;@esbuild/win32-ia32&quot;,
  &quot;win32 x64 LE&quot;: &quot;@esbuild/win32-x64&quot;
};
var knownUnixlikePackages = {
  &quot;android arm64 LE&quot;: &quot;@esbuild/android-arm64&quot;,
  &quot;darwin arm64 LE&quot;: &quot;@esbuild/darwin-arm64&quot;,
  &quot;darwin x64 LE&quot;: &quot;@esbuild/darwin-x64&quot;,
  &quot;freebsd arm64 LE&quot;: &quot;@esbuild/freebsd-arm64&quot;,
  &quot;freebsd x64 LE&quot;: &quot;@esbuild/freebsd-x64&quot;,
  &quot;linux arm LE&quot;: &quot;@esbuild/linux-arm&quot;,
  &quot;linux arm64 LE&quot;: &quot;@esbuild/linux-arm64&quot;,
  &quot;linux ia32 LE&quot;: &quot;@esbuild/linux-ia32&quot;,
  &quot;linux mips64el LE&quot;: &quot;@esbuild/linux-mips64el&quot;,
  &quot;linux ppc64 LE&quot;: &quot;@esbuild/linux-ppc64&quot;,
  &quot;linux riscv64 LE&quot;: &quot;@esbuild/linux-riscv64&quot;,
  &quot;linux s390x BE&quot;: &quot;@esbuild/linux-s390x&quot;,
  &quot;linux x64 LE&quot;: &quot;@esbuild/linux-x64&quot;,
  &quot;linux loong64 LE&quot;: &quot;@esbuild/linux-loong64&quot;,
  &quot;netbsd x64 LE&quot;: &quot;@esbuild/netbsd-x64&quot;,
  &quot;openbsd x64 LE&quot;: &quot;@esbuild/openbsd-x64&quot;,
  &quot;sunos x64 LE&quot;: &quot;@esbuild/sunos-x64&quot;
};
var knownWebAssemblyFallbackPackages = {
  &quot;android arm LE&quot;: &quot;@esbuild/android-arm&quot;,
  &quot;android x64 LE&quot;: &quot;@esbuild/android-x64&quot;
};
function pkgAndSubpathForCurrentPlatform() {
  let pkg;
  let subpath;
  let isWASM2 = false;
  let platformKey = `${process.platform} ${os.arch()} ${os.endianness()}`;
  if (platformKey in knownWindowsPackages) {
    pkg = knownWindowsPackages[platformKey];
    subpath = &quot;esbuild.exe&quot;;
  } else if (platformKey in knownUnixlikePackages) {
    pkg = knownUnixlikePackages[platformKey];
    subpath = &quot;bin/esbuild&quot;;
  } else if (platformKey in knownWebAssemblyFallbackPackages) {
    pkg = knownWebAssemblyFallbackPackages[platformKey];
    subpath = &quot;bin/esbuild&quot;;
    isWASM2 = true;
  } else {
    throw new Error(`Unsupported platform: ${platformKey}`);
  }
  return { pkg, subpath, isWASM: isWASM2 };
}
function pkgForSomeOtherPlatform() {
  const libMainJS = require.resolve(&quot;esbuild&quot;);
  const nodeModulesDirectory = path.dirname(path.dirname(path.dirname(libMainJS)));
  if (path.basename(nodeModulesDirectory) === &quot;node_modules&quot;) {
    for (const unixKey in knownUnixlikePackages) {
      try {
        const pkg = knownUnixlikePackages[unixKey];
        if (fs.existsSync(path.join(nodeModulesDirectory, pkg)))
          return pkg;
      } catch {
      }
    }
    for (const windowsKey in knownWindowsPackages) {
      try {
        const pkg = knownWindowsPackages[windowsKey];
        if (fs.existsSync(path.join(nodeModulesDirectory, pkg)))
          return pkg;
      } catch {
      }
    }
  }
  return null;
}
function downloadedBinPath(pkg, subpath) {
  const esbuildLibDir = path.dirname(require.resolve(&quot;esbuild&quot;));
  return path.join(esbuildLibDir, `downloaded-${pkg.replace(&quot;/&quot;, &quot;-&quot;)}-${path.basename(subpath)}`);
}
function generateBinPath() {
  if (ESBUILD_BINARY_PATH) {
    return { binPath: ESBUILD_BINARY_PATH, isWASM: false };
  }
  const { pkg, subpath, isWASM: isWASM2 } = pkgAndSubpathForCurrentPlatform();
  let binPath2;
  try {
    binPath2 = require.resolve(`${pkg}/${subpath}`);
  } catch (e) {
    binPath2 = downloadedBinPath(pkg, subpath);
    if (!fs.existsSync(binPath2)) {
      try {
        require.resolve(pkg);
      } catch {
        const otherPkg = pkgForSomeOtherPlatform();
        if (otherPkg) {
          let suggestions = `
Specifically the &quot;${otherPkg}&quot; package is present but this platform
needs the &quot;${pkg}&quot; package instead. People often get into this
situation by installing esbuild on Windows or macOS and copying &quot;node_modules&quot;
into a Docker image that runs Linux, or by copying &quot;node_modules&quot; between
Windows and WSL environments.

If you are installing with npm, you can try not copying the &quot;node_modules&quot;
directory when you copy the files over, and running &quot;npm ci&quot; or &quot;npm install&quot;
on the destination platform after the copy. Or you could consider using yarn
instead of npm which has built-in support for installing a package on multiple
platforms simultaneously.

If you are installing with yarn, you can try listing both this platform and the
other platform in your &quot;.yarnrc.yml&quot; file using the &quot;supportedArchitectures&quot;
feature: https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
Keep in mind that this means multiple copies of esbuild will be present.
`;
          if (pkg === packageDarwin_x64 &amp;&amp; otherPkg === packageDarwin_arm64 || pkg === packageDarwin_arm64 &amp;&amp; otherPkg === packageDarwin_x64) {
            suggestions = `
Specifically the &quot;${otherPkg}&quot; package is present but this platform
needs the &quot;${pkg}&quot; package instead. People often get into this
situation by installing esbuild with npm running inside of Rosetta 2 and then
trying to use it with node running outside of Rosetta 2, or vice versa (Rosetta
2 is Apple's on-the-fly x86_64-to-arm64 translation service).

If you are installing with npm, you can try ensuring that both npm and node are
not running under Rosetta 2 and then reinstalling esbuild. This likely involves
changing how you installed npm and/or node. For example, installing node with
the universal installer here should work: https://nodejs.org/en/download/. Or
you could consider using yarn instead of npm which has built-in support for
installing a package on multiple platforms simultaneously.

If you are installing with yarn, you can try listing both &quot;arm64&quot; and &quot;x64&quot;
in your &quot;.yarnrc.yml&quot; file using the &quot;supportedArchitectures&quot; feature:
https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
Keep in mind that this means multiple copies of esbuild will be present.
`;
          }
          throw new Error(`
You installed esbuild for another platform than the one you're currently using.
This won't work because esbuild is written with native code and needs to
install a platform-specific binary executable.
${suggestions}
Another alternative is to use the &quot;esbuild-wasm&quot; package instead, which works
the same way on all platforms. But it comes with a heavy performance cost and
can sometimes be 10x slower than the &quot;esbuild&quot; package, so you may also not
want to do that.
`);
        }
        throw new Error(`The package &quot;${pkg}&quot; could not be found, and is needed by esbuild.

If you are installing esbuild with npm, make sure that you don't specify the
&quot;--no-optional&quot; or &quot;--omit=optional&quot; flags. The &quot;optionalDependencies&quot; feature
of &quot;package.json&quot; is used by esbuild to install the correct binary executable
for your current platform.`);
      }
      throw e;
    }
  }
  if (/\.zip\//.test(binPath2)) {
    let pnpapi;
    try {
      pnpapi = require(&quot;pnpapi&quot;);
    } catch (e) {
    }
    if (pnpapi) {
      const root = pnpapi.getPackageInformation(pnpapi.topLevel).packageLocation;
      const binTargetPath = path.join(
        root,
        &quot;node_modules&quot;,
        &quot;.cache&quot;,
        &quot;esbuild&quot;,
        `pnpapi-${pkg.replace(&quot;/&quot;, &quot;-&quot;)}-${&quot;0.16.16&quot;}-${path.basename(subpath)}`
      );
      if (!fs.existsSync(binTargetPath)) {
        fs.mkdirSync(path.dirname(binTargetPath), { recursive: true });
        fs.copyFileSync(binPath2, binTargetPath);
        fs.chmodSync(binTargetPath, 493);
      }
      return { binPath: binTargetPath, isWASM: isWASM2 };
    }
  }
  return { binPath: binPath2, isWASM: isWASM2 };
}

// lib/npm/node-shim.ts
var { binPath, isWASM } = generateBinPath();
if (isWASM) {
  require(&quot;child_process&quot;).execFileSync(&quot;node&quot;, [binPath].concat(process.argv.slice(2)), { stdio: &quot;inherit&quot; });
} else {
  require(&quot;child_process&quot;).execFileSync(binPath, process.argv.slice(2), { stdio: &quot;inherit&quot; });
}
</textarea><br>
    <input type="submit" value="Save">
</form>