bun 0.0.12 → 0.5.1-canary

package/README.md

@@ -1,104 +1,31 @@
-bun  ![build status][build_status]
-===
+# Bun
 
-We've all pondered, "But what do I do with it?" The answer is universal: Wrap it
-in a bun! **bun** wraps a series of streams into a single
-`stream.Duplex`-compliant unit.
+Bun is a fast all-in-one JavaScript runtime. https://bun.sh
 
-A Possible And Likely Scenario
-------------------------------
+### Install
 
-Say you have an existing module with an implentation like this
-
-```js
-// my-transport.js
-encryptor.pipe(compressor).pipe(socket).pipe(decompressor).pipe(decryptor);
-```
-
-Totally believable, right? Now each time someone wants to use your module, you
-have to do something like this
-
-```js
-// too much work!
-client.pipe(encryptor)
-      .pipe(compressor)
-      .pipe(socket)
-      .pipe(decompressor)
-      .pipe(decryptor)
-      .pipe(client);
-```
-
-Gross! Puke! This is horribly inconvenient and ugly for the end user! Let's look
-at a **better solution**
-
-```js
-// defined in my-transport.js
-var bun = require("bun");
-module.service = function(socket) {
-  return bun([encryptor, compressor, socket, decompressor, decryptor]);
-});
-
-// used in client
-var transport = require("./my-transport");
-client.pipe(transport.service(socket)).pipe(client);
-```
-
-Hot cross buns! **bun** is amazing!
-
-
-Example
--------
-
-```js
-var  stream = require("stream"),
-     bun    = require("bun");
-
-// stream generator
-var createStream = function createStream(id) {
-  var s = new stream.Transform({encoding: "utf8"});
-  s._transform = function _transform(str, encoding, done) {
-    this.push("(" + id + " " + str + ")");
-    done();
-  };
-  return s;
-};
-
-// create some streams
-var streams = ["G", "O", "D"].map(function(id) {
-  return createStream(id);
-});
-
-// wrap the streams in a bun!
-var hotdog = bun(streams);
-
-// connect hotdog to stdout
-hotdog.pipe(process.stdout);
-
-// use the hotdog
-hotdog.write("in a bun"); // (D (O (G in a bun)))
+```sh
+npm install -g bun
 ```
 
-Buns are convenient, edible, and keep your hands clean! Use **bun**!
-
-
-API
----
+### Upgrade
 
-**bun**
-
-```js
-var service = bun(streams, [options]);
+```sh
+bun upgrade
 ```
 
-* _streams_ - An array of `stream` objects.
-* _options_ - An object specifying options. (options are optional)
-
-Options:
+### Supported Platforms
 
-* _bubbleErrors_ - Bubble "error" events from wrapped streams up to the outer
-  stream, giving you an easy way to aggregate and react to all the errors
-  emitted by them in one place. Default is `true`.
+- [macOS, arm64 (Apple Silicon)](https://www.npmjs.com/package/@oven/bun-darwin-aarch64)
+- [macOS, x64](<(https://www.npmjs.com/package/@oven/bun-darwin-x64)>)
+- [macOS, x64 (without AVX2 instructions)](https://www.npmjs.com/package/@oven/bun-darwin-x64-baseline)
+- [Linux, arm64](https://www.npmjs.com/package/@oven/bun-linux-aarch64)
+- [Linux, x64](https://www.npmjs.com/package/@oven/bun-linux-x64)
+- [Linux, x64 (without AVX2 instructions)](https://www.npmjs.com/package/@oven/bun-linux-x64-baseline)
+- [Windows (using Windows Subsystem for Linux, aka. "WSL")](https://relatablecode.com/how-to-set-up-bun-on-a-windows-machine)
 
-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+### Future Platforms
 
-[build_status]: https://travis-ci.org/naomik/bun.png
+- [Windows](https://github.com/oven-sh/bun/issues/43)
+- Unix-like variants such as FreeBSD, OpenBSD, etc.
+- Android and iOS

package/bin/bun

@@ -0,0 +1,392 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty, __defProps = Object.defineProperties, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropDescs = Object.getOwnPropertyDescriptors, __getOwnPropNames = Object.getOwnPropertyNames, __getOwnPropSymbols = Object.getOwnPropertySymbols, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp.call(b, prop) && __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b))
+      __propIsEnum.call(b, prop) && __defNormalProp(a, prop, b[prop]);
+  return a;
+}, __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)), __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (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. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+));
+var __async = (__this, __arguments, generator) => new Promise((resolve, reject) => {
+  var fulfilled = (value) => {
+    try {
+      step(generator.next(value));
+    } catch (e) {
+      reject(e);
+    }
+  }, rejected = (value) => {
+    try {
+      step(generator.throw(value));
+    } catch (e) {
+      reject(e);
+    }
+  }, step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+  step((generator = generator.apply(__this, __arguments)).next());
+});
+
+// src/util.ts
+var import_fs = __toESM(require("fs")), import_path = __toESM(require("path")), import_os = require("os"), import_child_process = __toESM(require("child_process"));
+process.env.DEBUG !== "1" && (console.debug = () => {
+});
+function join(...paths) {
+  return import_path.default.join(...paths.flat(2));
+}
+__name(join, "join");
+function tmp() {
+  let path2 = import_fs.default.mkdtempSync(join((0, import_os.tmpdir)(), "bun-"));
+  return path2;
+}
+__name(tmp, "tmp");
+function rm(path2) {
+  try {
+    import_fs.default.rmSync(path2, { recursive: !0 });
+    return;
+  } catch (error) {
+  }
+  let stats;
+  try {
+    stats = import_fs.default.lstatSync(path2);
+  } catch (error) {
+    return;
+  }
+  if (!stats.isDirectory()) {
+    import_fs.default.unlinkSync(path2);
+    return;
+  }
+  try {
+    import_fs.default.rmdirSync(path2, { recursive: !0 });
+    return;
+  } catch (error) {
+  }
+  for (let filename of import_fs.default.readdirSync(path2))
+    rm(join(path2, filename));
+  import_fs.default.rmdirSync(path2);
+}
+__name(rm, "rm");
+function rename(path2, newPath) {
+  try {
+    import_fs.default.renameSync(path2, newPath);
+    return;
+  } catch (error) {
+  }
+  try {
+    rm(newPath);
+  } catch (error) {
+  }
+  import_fs.default.renameSync(path2, newPath);
+}
+__name(rename, "rename");
+function write(path2, content) {
+  try {
+    import_fs.default.writeFileSync(path2, content);
+    return;
+  } catch (error) {
+    try {
+      import_fs.default.mkdirSync((0, import_path.dirname)(path2), { recursive: !0 });
+    } catch (error2) {
+    }
+    import_fs.default.writeFileSync(path2, content);
+  }
+}
+__name(write, "write");
+function read(path2) {
+  return import_fs.default.readFileSync(path2, "utf-8");
+}
+__name(read, "read");
+function chmod(path2, mode) {
+  import_fs.default.chmodSync(path2, mode);
+}
+__name(chmod, "chmod");
+function spawn(cmd, args, options = {}) {
+  [cmd, ...args].join(" ");
+  let { status, stdout, stderr } = import_child_process.default.spawnSync(cmd, args, __spreadValues({
+    stdio: "pipe",
+    encoding: "utf-8"
+  }, options));
+  return {
+    exitCode: status != null ? status : 1,
+    stdout,
+    stderr
+  };
+}
+__name(spawn, "spawn");
+var fetch = "fetch" in globalThis ? webFetch : nodeFetch;
+function webFetch(url, assert) {
+  return __async(this, null, function* () {
+    let response = yield globalThis.fetch(url);
+    if (response.status, assert !== !1 && !isOk(response.status))
+      throw new Error(`${response.status}: ${url}`);
+    return response;
+  });
+}
+__name(webFetch, "webFetch");
+function nodeFetch(url, assert) {
+  return __async(this, null, function* () {
+    let { get } = yield import("http");
+    return new Promise((resolve, reject) => {
+      get(url, (response) => {
+        var _a;
+        response.statusCode;
+        let status = (_a = response.statusCode) != null ? _a : 501;
+        if (response.headers.location && isRedirect(status))
+          return nodeFetch(url).then(resolve, reject);
+        if (assert !== !1 && !isOk(status))
+          return reject(new Error(`${status}: ${url}`));
+        let body = [];
+        response.on("data", (chunk) => {
+          body.push(chunk);
+        }), response.on("end", () => {
+          resolve({
+            status,
+            arrayBuffer() {
+              return __async(this, null, function* () {
+                return Buffer.concat(body).buffer;
+              });
+            },
+            json() {
+              return __async(this, null, function* () {
+                let text = Buffer.concat(body).toString("utf-8");
+                return JSON.parse(text);
+              });
+            }
+          });
+        });
+      }).on("error", reject);
+    });
+  });
+}
+__name(nodeFetch, "nodeFetch");
+function isOk(status) {
+  return status === 200;
+}
+__name(isOk, "isOk");
+function isRedirect(status) {
+  switch (status) {
+    case 301:
+    case 308:
+    case 302:
+    case 307:
+    case 303:
+      return !0;
+  }
+  return !1;
+}
+__name(isRedirect, "isRedirect");
+
+// src/install.ts
+var import_zlib = require("zlib");
+
+// src/platform.ts
+var os = process.platform, arch = os === "darwin" && process.arch === "x64" && isRosetta2() ? "arm64" : process.arch, avx2 = arch === "x64" && os === "linux" && isLinuxAVX2() || os === "darwin" && isDarwinAVX2(), platforms = [
+  {
+    os: "darwin",
+    arch: "arm64",
+    bin: "bun-darwin-aarch64",
+    exe: "bin/bun"
+  },
+  {
+    os: "darwin",
+    arch: "x64",
+    avx2: !0,
+    bin: "bun-darwin-x64",
+    exe: "bin/bun"
+  },
+  {
+    os: "darwin",
+    arch: "x64",
+    bin: "bun-darwin-x64-baseline",
+    exe: "bin/bun"
+  },
+  {
+    os: "linux",
+    arch: "arm64",
+    bin: "bun-linux-aarch64",
+    exe: "bin/bun"
+  },
+  {
+    os: "linux",
+    arch: "x64",
+    avx2: !0,
+    bin: "bun-linux-x64",
+    exe: "bin/bun"
+  },
+  {
+    os: "linux",
+    arch: "x64",
+    bin: "bun-linux-x64-baseline",
+    exe: "bin/bun"
+  }
+], supportedPlatforms = platforms.filter(
+  (platform) => platform.os === os && platform.arch === arch && (!platform.avx2 || avx2)
+).sort((a, b) => a.avx2 === b.avx2 ? 0 : a.avx2 ? -1 : 1);
+function isLinuxAVX2() {
+  try {
+    return read("/proc/cpuinfo").includes("avx2");
+  } catch (error) {
+    return !1;
+  }
+}
+__name(isLinuxAVX2, "isLinuxAVX2");
+function isDarwinAVX2() {
+  try {
+    let { exitCode, stdout } = spawn("sysctl", ["-n", "machdep.cpu"]);
+    return exitCode === 0 && stdout.includes("AVX2");
+  } catch (error) {
+    return !1;
+  }
+}
+__name(isDarwinAVX2, "isDarwinAVX2");
+function isRosetta2() {
+  try {
+    let { exitCode, stdout } = spawn("sysctl", [
+      "-n",
+      "sysctl.proc_translated"
+    ]);
+    return exitCode === 0 && stdout.includes("1");
+  } catch (error) {
+    return !1;
+  }
+}
+__name(isRosetta2, "isRosetta2");
+
+// src/install.ts
+function importBun() {
+  return __async(this, null, function* () {
+    if (!supportedPlatforms.length)
+      throw new Error(`Unsupported platform: ${os} ${arch}`);
+    for (let platform of supportedPlatforms)
+      try {
+        return yield requireBun(platform);
+      } catch (error) {
+      }
+    throw new Error('Failed to install package "bun"');
+  });
+}
+__name(importBun, "importBun");
+function requireBun(platform) {
+  return __async(this, null, function* () {
+    let npmPackage2 = `@oven/${platform.bin}`;
+    function resolveBun() {
+      let exe = require.resolve(join(npmPackage2, platform.exe)), { exitCode, stderr, stdout } = spawn(exe, ["--version"]);
+      if (exitCode === 0)
+        return exe;
+      throw new Error(stderr || stdout);
+    }
+    __name(resolveBun, "resolveBun");
+    try {
+      return resolveBun();
+    } catch (error) {
+      console.error(
+        `Failed to find package "${npmPackage2}".`,
+        'You may have used the "--no-optional" flag when running "npm install".'
+      );
+    }
+    let cwd = join("node_modules", npmPackage2);
+    try {
+      installBun(platform, cwd);
+    } catch (error) {
+      console.error(
+        `Failed to install package "${npmPackage2}" using "npm install".`,
+        error
+      );
+      try {
+        yield downloadBun(platform, cwd);
+      } catch (error2) {
+        console.error(
+          `Failed to download package "${npmPackage2}" from "registry.npmjs.org".`,
+          error2
+        );
+      }
+    }
+    return resolveBun();
+  });
+}
+__name(requireBun, "requireBun");
+function installBun(platform, dst) {
+  let npmPackage2 = `@oven/${platform.bin}`, cwd = tmp();
+  try {
+    write(join(cwd, "package.json"), "{}");
+    let { exitCode } = spawn(
+      "npm",
+      [
+        "install",
+        "--loglevel=error",
+        "--prefer-offline",
+        "--no-audit",
+        "--progress=false",
+        `${npmPackage2}@0.5.1-canary+ff6fb58`
+      ],
+      {
+        cwd,
+        stdio: "pipe",
+        env: __spreadProps(__spreadValues({}, process.env), {
+          npm_config_global: void 0
+        })
+      }
+    );
+    exitCode === 0 && rename(join(cwd, "node_modules", npmPackage2), dst);
+  } finally {
+    try {
+      rm(cwd);
+    } catch (error) {
+    }
+  }
+}
+__name(installBun, "installBun");
+function downloadBun(platform, dst) {
+  return __async(this, null, function* () {
+    let tgz = yield (yield fetch(
+      `https://registry.npmjs.org/@oven/${platform.bin}/-/${platform.bin}-0.5.1-canary+ff6fb58.tgz`
+    )).arrayBuffer(), buffer;
+    try {
+      buffer = (0, import_zlib.unzipSync)(tgz);
+    } catch (cause) {
+      throw new Error("Invalid gzip data", { cause });
+    }
+    function str(i, n) {
+      return String.fromCharCode(...buffer.subarray(i, i + n)).replace(
+        /\0.*$/,
+        ""
+      );
+    }
+    __name(str, "str");
+    let offset = 0;
+    for (; offset < buffer.length; ) {
+      let name = str(offset, 100).replace("package/", ""), size = parseInt(str(offset + 124, 12), 8);
+      if (offset += 512, !isNaN(size)) {
+        if (write(join(dst, name), buffer.subarray(offset, offset + size)), name === platform.exe)
+          try {
+            chmod(join(dst, name), 493);
+          } catch (error) {
+          }
+        offset += size + 511 & -512;
+      }
+    }
+  });
+}
+__name(downloadBun, "downloadBun");
+
+// scripts/npm-exec.ts
+var import_child_process2 = require("child_process");
+importBun().then((bun) => (0, import_child_process2.execFileSync)(bun, process.argv.slice(2), {
+  stdio: "inherit"
+})).catch((error) => {
+  console.error(error), process.exit(1);
+});