Bun v1.0.15

Benchmark 1: bun --bun ./node_modules/.bin/tsc --help
  Time (mean ± σ):      82.2 ms ±   2.6 ms    [User: 70.1 ms, System: 14.3 ms]
  Range (min … max):    78.4 ms …  87.1 ms    37 runs

Benchmark 2: bun-1.0.14 --bun ./node_modules/.bin/tsc --help
  Time (mean ± σ):     197.0 ms ±   3.6 ms    [User: 172.0 ms, System: 27.2 ms]
  Range (min … max):   192.4 ms … 204.4 ms    14 runs

Benchmark 3: node ./node_modules/.bin/tsc --help
  Time (mean ± σ):     113.8 ms ±   3.2 ms    [User: 103.6 ms, System: 16.0 ms]
  Range (min … max):   110.0 ms … 123.4 ms    23 runs

Summary
  bun --bun ./node_modules/.bin/tsc --help ran
    1.38 ± 0.06 times faster than node ./node_modules/.bin/tsc --help
    2.40 ± 0.09 times faster than bun-1.0.14 --bun ./node_modules/.bin/tsc --help

Benchmark 1: bun --bun ./node_modules/.bin/prettier --write ./examples/hashing.js
  Time (mean ± σ):     124.5 ms ±   3.2 ms    [User: 144.5 ms, System: 23.4 ms]
  Range (min … max):   119.9 ms … 131.8 ms    23 runs

Benchmark 2: bun-1.0.14 --bun ./node_modules/.bin/prettier --write ./examples/hashing.js
  Time (mean ± σ):     184.4 ms ±   4.1 ms    [User: 202.7 ms, System: 28.6 ms]
  Range (min … max):   175.2 ms … 192.9 ms    15 runs

Benchmark 3: node ./node_modules/.bin/prettier --write ./examples/hashing.js
  Time (mean ± σ):     162.9 ms ±   3.7 ms    [User: 161.8 ms, System: 42.5 ms]
  Range (min … max):   158.2 ms … 170.7 ms    17 runs

Summary
  bun --bun ./node_modules/.bin/prettier --write ./examples/hashing.js ran
    1.31 ± 0.04 times faster than node ./node_modules/.bin/prettier --write ./examples/hashing.js
    1.48 ± 0.05 times faster than bun-1.0.14 --bun ./node_modules/.bin/prettier --write ./examples/hashing.js

const ws = new WebSocket("wss://echo.websocket.org/");

ws.addEventListener("message", ({ data }) => {
  console.log("Received:", data);
});

ws.addEventListener("open", () => {
  ws.send("Hello!");
});

import { test, expect } from "bun:test";

expect.extend({
  toBeWithinRange(received, floor, ceiling) {
    const pass = received >= floor && received <= ceiling;
    if (pass) {
      return {
        message: () =>
          `expected ${received} not to be within range ${floor} - ${ceiling}`,
        pass: true,
      };
    } else {
      return {
        message: () =>
          `expected ${received} to be within range ${floor} - ${ceiling}`,
        pass: false,
      };
    }
  },
});

test("toBeWithinRange()", () => {
  expect(1).toBeWithinRange(1, 99); // ✅
  expect(100).toBeWithinRange(1, 99); // ❌ expected 100 to be within range 1 - 99
});

import { test, expect } from "bun:test";
import { getTempurature, getForecast } from "./weather";

test("expect.resolvedTo", async () => {
  const weather = {
    tempurature: getTempurature(),
    forecast: getForecast(),
  };

  await expect(weather).toMatchObject({
    tempurature: expect.resolvedTo.closeTo(10, 5),
    forecast: expect.resolvedTo.stringMatching(/rain|snow|sleet/),
  });
});

import { test, mock, expect } from "bun:test";

test("toHaveBeenCalledWith()", () => {
  const fn = mock(() => {});
  sum(1, 2, 3);

  expect(fn).toHaveBeenCalledWith(1, 2, 3); // ✅
  expect(fn).toHaveBeenCalledWith(1, 2); // ❌
});

1 | throw new Error("Oops");
          ^
error: Oops
    at /Users/jarred/Desktop/oops.js:1:7
-   at globalThis (/Users/jarred/Desktop/oops.js:3:14)
-   at overridableRequire (:1:20)
    at /Users/jarred/Desktop/index.js:3:8
-   at globalThis (/Users/jarred/Desktop/index.js:3:8)

const err = new Error("Oops 1");
err.stack += "\n" + new Error("Oops 2").stack;
throw err;

import { readdir } from "fs/promises";
const results = await readdir(__dirname, { recursive: true });
console.log(results); // ["a.js", "b/c.js" ...

import * as tf from "@tensorflow/tfjs-node";

const model = tf.sequential({
  layers: [
    tf.layers.dense({ units: 128, activation: "relu", inputShape: [1] }),
    tf.layers.dense({ units: 3 }),
    tf.layers.softmax(),
  ],
});

model.compile({
  optimizer: "adam",
  loss: "categoricalCrossentropy",
  metrics: ["categoricalAccuracy"],
});

const result = model.predict(tf.tensor([0]));
if (Array.isArray(result)) throw new Error("Expected a single tensor");
const prediction = await result.data();

console.log(prediction); // Float32Array(3) [...]

import { sign, generateKeyPairSync } from "node:crypto";

const { privateKey } = generateKeyPairSync("ed25519");
const signature = sign(undefined, Buffer.from("foo"), privateKey);

console.log(signature); // Buffer(64) [ ... ]

❯ cat package-lock.json | jq .lockfileVersion
2

❯ bun install
bun install v1.0.15
[3.57ms] migrated lockfile from package-lock.json
 + svelte@4.0.0 (v4.2.8 available)

 21 packages installed [265.00ms]

console.log({ a: 1, b: 2, c: "3" });
{
   a: 1,
   b: 2,
-  c: "3"
+  c: "3",
}

const { exited, stdout } = Bun.spawn(["echo", "hello"], {
  stdout: "pipe",
});

await exited;

// Since the process has exited, the `stdout` ReadableStream is detached.
console.log(await Bun.readableStreamToText(stdout));

// Before: error: undefined is not an object
// After: "hello\n"

import { test, expect } from "bun:test";
import { opendir } from "fs/promises";

test("opendir() has `path` property", () => {
  const result = await opendir(".");
  expect(result).toHaveProperty("path", ".");
});

const file = Bun.file("video.mp4");
const start = 0;
const end = 1000;
const range = file.slice(start, end);

return new Response(range, {
  status: 206,
  headers: {
    "Content-Range": `bytes ${start}-${end}/${file.size}`,
  },
});

content-range: bytes 0-1000/10000
- content-range: bytes 0-1000/*

{
  "key-with-hyphens": "value"
}

const a = <h1>{...[123]}</h1>;

- error: Unexpected ...
+ var a = jsx_dev_runtime.jsxDEV("h1", {
+  children: [...[123]]
+ }, undefined, true, undefined, this);

const chain =
  `globalThis.a = {};` +
  "\n" +
  `globalThis.a + globalThis.a +`.repeat(1000000) +
  `globalThis.a` +
  "\n";

await Bun.write("stack-overflow.js", chain);

class Foo {}
class Bar extends Foo {}

class Fizz {
  constructor(readonly foo: Foo) {}
}

class Buzz extends Fizz {
  constructor(override bar: Bar) {
    super(foo);
  }
}

new Buzz(new Bar());

- 10 |    constructor(override foo: FooChild) {
-                             ^
- error: Expected ")" but found "foo"
-    at example.ts:10:23

const dynamic = (name) => require(name);

console.log(dynamic("some-package"));