bun-types 1.3.2-canary.20251105T140650 → 1.3.2-canary.20251106T140813

package/docs/api/cc.md

@@ -1,197 +0,0 @@
-`bun:ffi` has experimental support for compiling and running C from JavaScript with low overhead.
-
-## Usage (cc in `bun:ffi`)
-
-See the [introduction blog post](https://bun.com/blog/compile-and-run-c-in-js) for more information.
-
-JavaScript:
-
-```ts#hello.js
-import { cc } from "bun:ffi";
-import source from "./hello.c" with { type: "file" };
-
-const {
-  symbols: { hello },
-} = cc({
-  source,
-  symbols: {
-    hello: {
-      args: [],
-      returns: "int",
-    },
-  },
-});
-
-console.log("What is the answer to the universe?", hello());
-```
-
-C source:
-
-```c#hello.c
-int hello() {
-  return 42;
-}
-```
-
-When you run `hello.js`, it will print:
-
-```sh
-$ bun hello.js
-What is the answer to the universe? 42
-```
-
-Under the hood, `cc` uses [TinyCC](https://bellard.org/tcc/) to compile the C code and then link it with the JavaScript runtime, efficiently converting types in-place.
-
-### Primitive types
-
-The same `FFIType` values in [`dlopen`](/docs/api/ffi) are supported in `cc`.
-
-| `FFIType`  | C Type         | Aliases                     |
-| ---------- | -------------- | --------------------------- |
-| cstring    | `char*`        |                             |
-| function   | `(void*)(*)()` | `fn`, `callback`            |
-| ptr        | `void*`        | `pointer`, `void*`, `char*` |
-| i8         | `int8_t`       | `int8_t`                    |
-| i16        | `int16_t`      | `int16_t`                   |
-| i32        | `int32_t`      | `int32_t`, `int`            |
-| i64        | `int64_t`      | `int64_t`                   |
-| i64_fast   | `int64_t`      |                             |
-| u8         | `uint8_t`      | `uint8_t`                   |
-| u16        | `uint16_t`     | `uint16_t`                  |
-| u32        | `uint32_t`     | `uint32_t`                  |
-| u64        | `uint64_t`     | `uint64_t`                  |
-| u64_fast   | `uint64_t`     |                             |
-| f32        | `float`        | `float`                     |
-| f64        | `double`       | `double`                    |
-| bool       | `bool`         |                             |
-| char       | `char`         |                             |
-| napi_env   | `napi_env`     |                             |
-| napi_value | `napi_value`   |                             |
-
-### Strings, objects, and non-primitive types
-
-To make it easier to work with strings, objects, and other non-primitive types that don't map 1:1 to C types, `cc` supports N-API.
-
-To pass or receive a JavaScript values without any type conversions from a C function, you can use `napi_value`.
-
-You can also pass a `napi_env` to receive the N-API environment used to call the JavaScript function.
-
-#### Returning a C string to JavaScript
-
-For example, if you have a string in C, you can return it to JavaScript like this:
-
-```ts#hello.js
-import { cc } from "bun:ffi";
-import source from "./hello.c" with { type: "file" };
-
-const {
-  symbols: { hello },
-} = cc({
-  source,
-  symbols: {
-    hello: {
-      args: ["napi_env"],
-      returns: "napi_value",
-    },
-  },
-});
-
-const result = hello();
-```
-
-And in C:
-
-```c#hello.c
-#include <node/node_api.h>
-
-napi_value hello(napi_env env) {
-  napi_value result;
-  napi_create_string_utf8(env, "Hello, Napi!", NAPI_AUTO_LENGTH, &result);
-  return result;
-}
-```
-
-You can also use this to return other types like objects and arrays:
-
-```c#hello.c
-#include <node/node_api.h>
-
-napi_value hello(napi_env env) {
-  napi_value result;
-  napi_create_object(env, &result);
-  return result;
-}
-```
-
-### `cc` Reference
-
-#### `library: string[]`
-
-The `library` array is used to specify the libraries that should be linked with the C code.
-
-```ts
-type Library = string[];
-
-cc({
-  source: "hello.c",
-  library: ["sqlite3"],
-});
-```
-
-#### `symbols`
-
-The `symbols` object is used to specify the functions and variables that should be exposed to JavaScript.
-
-```ts
-type Symbols = {
-  [key: string]: {
-    args: FFIType[];
-    returns: FFIType;
-  };
-};
-```
-
-#### `source`
-
-The `source` is a file path to the C code that should be compiled and linked with the JavaScript runtime.
-
-```ts
-type Source = string | URL | BunFile;
-
-cc({
-  source: "hello.c",
-  symbols: {
-    hello: {
-      args: [],
-      returns: "int",
-    },
-  },
-});
-```
-
-#### `flags: string | string[]`
-
-The `flags` is an optional array of strings that should be passed to the TinyCC compiler.
-
-```ts
-type Flags = string | string[];
-```
-
-These are flags like `-I` for include directories and `-D` for preprocessor definitions.
-
-#### `define: Record<string, string>`
-
-The `define` is an optional object that should be passed to the TinyCC compiler.
-
-```ts
-type Defines = Record<string, string>;
-
-cc({
-  source: "hello.c",
-  define: {
-    "NDEBUG": "1",
-  },
-});
-```
-
-These are preprocessor definitions passed to the TinyCC compiler.

package/docs/api/color.md

@@ -1,262 +0,0 @@
-`Bun.color(input, outputFormat?)` leverages Bun's CSS parser to parse, normalize, and convert colors from user input to a variety of output formats, including:
-
-| Format       | Example                          |
-| ------------ | -------------------------------- |
-| `"css"`      | `"red"`                          |
-| `"ansi"`     | `"\x1b[38;2;255;0;0m"`           |
-| `"ansi-16"`  | `"\x1b[38;5;\tm"`                |
-| `"ansi-256"` | `"\x1b[38;5;196m"`               |
-| `"ansi-16m"` | `"\x1b[38;2;255;0;0m"`           |
-| `"number"`   | `0x1a2b3c`                       |
-| `"rgb"`      | `"rgb(255, 99, 71)"`             |
-| `"rgba"`     | `"rgba(255, 99, 71, 0.5)"`       |
-| `"hsl"`      | `"hsl(120, 50%, 50%)"`           |
-| `"hex"`      | `"#1a2b3c"`                      |
-| `"HEX"`      | `"#1A2B3C"`                      |
-| `"{rgb}"`    | `{ r: 255, g: 99, b: 71 }`       |
-| `"{rgba}"`   | `{ r: 255, g: 99, b: 71, a: 1 }` |
-| `"[rgb]"`    | `[ 255, 99, 71 ]`                |
-| `"[rgba]"`   | `[ 255, 99, 71, 255]`            |
-
-There are many different ways to use this API:
-
-- Validate and normalize colors to persist in a database (`number` is the most database-friendly)
-- Convert colors to different formats
-- Colorful logging beyond the 16 colors many use today (use `ansi` if you don't want to figure out what the user's terminal supports, otherwise use `ansi-16`, `ansi-256`, or `ansi-16m` for how many colors the terminal supports)
-- Format colors for use in CSS injected into HTML
-- Get the `r`, `g`, `b`, and `a` color components as JavaScript objects or numbers from a CSS color string
-
-You can think of this as an alternative to the popular npm packages [`color`](https://github.com/Qix-/color) and [`tinycolor2`](https://github.com/bgrins/TinyColor) except with full support for parsing CSS color strings and zero dependencies built directly into Bun.
-
-### Flexible input
-
-You can pass in any of the following:
-
-- Standard CSS color names like `"red"`
-- Numbers like `0xff0000`
-- Hex strings like `"#f00"`
-- RGB strings like `"rgb(255, 0, 0)"`
-- RGBA strings like `"rgba(255, 0, 0, 1)"`
-- HSL strings like `"hsl(0, 100%, 50%)"`
-- HSLA strings like `"hsla(0, 100%, 50%, 1)"`
-- RGB objects like `{ r: 255, g: 0, b: 0 }`
-- RGBA objects like `{ r: 255, g: 0, b: 0, a: 1 }`
-- RGB arrays like `[255, 0, 0]`
-- RGBA arrays like `[255, 0, 0, 255]`
-- LAB strings like `"lab(50% 50% 50%)"`
-- ... anything else that CSS can parse as a single color value
-
-### Format colors as CSS
-
-The `"css"` format outputs valid CSS for use in stylesheets, inline styles, CSS variables, css-in-js, etc. It returns the most compact representation of the color as a string.
-
-```ts
-Bun.color("red", "css"); // "red"
-Bun.color(0xff0000, "css"); // "#f000"
-Bun.color("#f00", "css"); // "red"
-Bun.color("#ff0000", "css"); // "red"
-Bun.color("rgb(255, 0, 0)", "css"); // "red"
-Bun.color("rgba(255, 0, 0, 1)", "css"); // "red"
-Bun.color("hsl(0, 100%, 50%)", "css"); // "red"
-Bun.color("hsla(0, 100%, 50%, 1)", "css"); // "red"
-Bun.color({ r: 255, g: 0, b: 0 }, "css"); // "red"
-Bun.color({ r: 255, g: 0, b: 0, a: 1 }, "css"); // "red"
-Bun.color([255, 0, 0], "css"); // "red"
-Bun.color([255, 0, 0, 255], "css"); // "red"
-```
-
-If the input is unknown or fails to parse, `Bun.color` returns `null`.
-
-### Format colors as ANSI (for terminals)
-
-The `"ansi"` format outputs ANSI escape codes for use in terminals to make text colorful.
-
-```ts
-Bun.color("red", "ansi"); // "\u001b[38;2;255;0;0m"
-Bun.color(0xff0000, "ansi"); // "\u001b[38;2;255;0;0m"
-Bun.color("#f00", "ansi"); // "\u001b[38;2;255;0;0m"
-Bun.color("#ff0000", "ansi"); // "\u001b[38;2;255;0;0m"
-Bun.color("rgb(255, 0, 0)", "ansi"); // "\u001b[38;2;255;0;0m"
-Bun.color("rgba(255, 0, 0, 1)", "ansi"); // "\u001b[38;2;255;0;0m"
-Bun.color("hsl(0, 100%, 50%)", "ansi"); // "\u001b[38;2;255;0;0m"
-Bun.color("hsla(0, 100%, 50%, 1)", "ansi"); // "\u001b[38;2;255;0;0m"
-Bun.color({ r: 255, g: 0, b: 0 }, "ansi"); // "\u001b[38;2;255;0;0m"
-Bun.color({ r: 255, g: 0, b: 0, a: 1 }, "ansi"); // "\u001b[38;2;255;0;0m"
-Bun.color([255, 0, 0], "ansi"); // "\u001b[38;2;255;0;0m"
-Bun.color([255, 0, 0, 255], "ansi"); // "\u001b[38;2;255;0;0m"
-```
-
-This gets the color depth of stdout and automatically chooses one of `"ansi-16m"`, `"ansi-256"`, `"ansi-16"` based on the environment variables. If stdout doesn't support any form of ANSI color, it returns an empty string. As with the rest of Bun's color API, if the input is unknown or fails to parse, it returns `null`.
-
-#### 24-bit ANSI colors (`ansi-16m`)
-
-The `"ansi-16m"` format outputs 24-bit ANSI colors for use in terminals to make text colorful. 24-bit color means you can display 16 million colors on supported terminals, and requires a modern terminal that supports it.
-
-This converts the input color to RGBA, and then outputs that as an ANSI color.
-
-```ts
-Bun.color("red", "ansi-16m"); // "\x1b[38;2;255;0;0m"
-Bun.color(0xff0000, "ansi-16m"); // "\x1b[38;2;255;0;0m"
-Bun.color("#f00", "ansi-16m"); // "\x1b[38;2;255;0;0m"
-Bun.color("#ff0000", "ansi-16m"); // "\x1b[38;2;255;0;0m"
-```
-
-#### 256 ANSI colors (`ansi-256`)
-
-The `"ansi-256"` format approximates the input color to the nearest of the 256 ANSI colors supported by some terminals.
-
-```ts
-Bun.color("red", "ansi-256"); // "\u001b[38;5;196m"
-Bun.color(0xff0000, "ansi-256"); // "\u001b[38;5;196m"
-Bun.color("#f00", "ansi-256"); // "\u001b[38;5;196m"
-Bun.color("#ff0000", "ansi-256"); // "\u001b[38;5;196m"
-```
-
-To convert from RGBA to one of the 256 ANSI colors, we ported the algorithm that [`tmux` uses](https://github.com/tmux/tmux/blob/dae2868d1227b95fd076fb4a5efa6256c7245943/colour.c#L44-L55).
-
-#### 16 ANSI colors (`ansi-16`)
-
-The `"ansi-16"` format approximates the input color to the nearest of the 16 ANSI colors supported by most terminals.
-
-```ts
-Bun.color("red", "ansi-16"); // "\u001b[38;5;\tm"
-Bun.color(0xff0000, "ansi-16"); // "\u001b[38;5;\tm"
-Bun.color("#f00", "ansi-16"); // "\u001b[38;5;\tm"
-Bun.color("#ff0000", "ansi-16"); // "\u001b[38;5;\tm"
-```
-
-This works by first converting the input to a 24-bit RGB color space, then to `ansi-256`, and then we convert that to the nearest 16 ANSI color.
-
-### Format colors as numbers
-
-The `"number"` format outputs a 24-bit number for use in databases, configuration, or any other use case where a compact representation of the color is desired.
-
-```ts
-Bun.color("red", "number"); // 16711680
-Bun.color(0xff0000, "number"); // 16711680
-Bun.color({ r: 255, g: 0, b: 0 }, "number"); // 16711680
-Bun.color([255, 0, 0], "number"); // 16711680
-Bun.color("rgb(255, 0, 0)", "number"); // 16711680
-Bun.color("rgba(255, 0, 0, 1)", "number"); // 16711680
-Bun.color("hsl(0, 100%, 50%)", "number"); // 16711680
-Bun.color("hsla(0, 100%, 50%, 1)", "number"); // 16711680
-```
-
-### Get the red, green, blue, and alpha channels
-
-You can use the `"{rgba}"`, `"{rgb}"`, `"[rgba]"` and `"[rgb]"` formats to get the red, green, blue, and alpha channels as objects or arrays.
-
-#### `{rgba}` object
-
-The `"{rgba}"` format outputs an object with the red, green, blue, and alpha channels.
-
-```ts
-type RGBAObject = {
-  // 0 - 255
-  r: number;
-  // 0 - 255
-  g: number;
-  // 0 - 255
-  b: number;
-  // 0 - 1
-  a: number;
-};
-```
-
-Example:
-
-```ts
-Bun.color("hsl(0, 0%, 50%)", "{rgba}"); // { r: 128, g: 128, b: 128, a: 1 }
-Bun.color("red", "{rgba}"); // { r: 255, g: 0, b: 0, a: 1 }
-Bun.color(0xff0000, "{rgba}"); // { r: 255, g: 0, b: 0, a: 1 }
-Bun.color({ r: 255, g: 0, b: 0 }, "{rgba}"); // { r: 255, g: 0, b: 0, a: 1 }
-Bun.color([255, 0, 0], "{rgba}"); // { r: 255, g: 0, b: 0, a: 1 }
-```
-
-To behave similarly to CSS, the `a` channel is a decimal number between `0` and `1`.
-
-The `"{rgb}"` format is similar, but it doesn't include the alpha channel.
-
-```ts
-Bun.color("hsl(0, 0%, 50%)", "{rgb}"); // { r: 128, g: 128, b: 128 }
-Bun.color("red", "{rgb}"); // { r: 255, g: 0, b: 0 }
-Bun.color(0xff0000, "{rgb}"); // { r: 255, g: 0, b: 0 }
-Bun.color({ r: 255, g: 0, b: 0 }, "{rgb}"); // { r: 255, g: 0, b: 0 }
-Bun.color([255, 0, 0], "{rgb}"); // { r: 255, g: 0, b: 0 }
-```
-
-#### `[rgba]` array
-
-The `"[rgba]"` format outputs an array with the red, green, blue, and alpha channels.
-
-```ts
-// All values are 0 - 255
-type RGBAArray = [number, number, number, number];
-```
-
-Example:
-
-```ts
-Bun.color("hsl(0, 0%, 50%)", "[rgba]"); // [128, 128, 128, 255]
-Bun.color("red", "[rgba]"); // [255, 0, 0, 255]
-Bun.color(0xff0000, "[rgba]"); // [255, 0, 0, 255]
-Bun.color({ r: 255, g: 0, b: 0 }, "[rgba]"); // [255, 0, 0, 255]
-Bun.color([255, 0, 0], "[rgba]"); // [255, 0, 0, 255]
-```
-
-Unlike the `"{rgba}"` format, the alpha channel is an integer between `0` and `255`. This is useful for typed arrays where each channel must be the same underlying type.
-
-The `"[rgb]"` format is similar, but it doesn't include the alpha channel.
-
-```ts
-Bun.color("hsl(0, 0%, 50%)", "[rgb]"); // [128, 128, 128]
-Bun.color("red", "[rgb]"); // [255, 0, 0]
-Bun.color(0xff0000, "[rgb]"); // [255, 0, 0]
-Bun.color({ r: 255, g: 0, b: 0 }, "[rgb]"); // [255, 0, 0]
-Bun.color([255, 0, 0], "[rgb]"); // [255, 0, 0]
-```
-
-### Format colors as hex strings
-
-The `"hex"` format outputs a lowercase hex string for use in CSS or other contexts.
-
-```ts
-Bun.color("hsl(0, 0%, 50%)", "hex"); // "#808080"
-Bun.color("red", "hex"); // "#ff0000"
-Bun.color(0xff0000, "hex"); // "#ff0000"
-Bun.color({ r: 255, g: 0, b: 0 }, "hex"); // "#ff0000"
-Bun.color([255, 0, 0], "hex"); // "#ff0000"
-```
-
-The `"HEX"` format is similar, but it outputs a hex string with uppercase letters instead of lowercase letters.
-
-```ts
-Bun.color("hsl(0, 0%, 50%)", "HEX"); // "#808080"
-Bun.color("red", "HEX"); // "#FF0000"
-Bun.color(0xff0000, "HEX"); // "#FF0000"
-Bun.color({ r: 255, g: 0, b: 0 }, "HEX"); // "#FF0000"
-Bun.color([255, 0, 0], "HEX"); // "#FF0000"
-```
-
-### Bundle-time client-side color formatting
-
-Like many of Bun's APIs, you can use macros to invoke `Bun.color` at bundle-time for use in client-side JavaScript builds:
-
-```ts#client-side.ts
-import { color } from "bun" with { type: "macro" };
-
-console.log(color("#f00", "css"));
-```
-
-Then, build the client-side code:
-
-```sh
-bun build ./client-side.ts
-```
-
-This will output the following to `client-side.js`:
-
-```js
-// client-side.ts
-console.log("red");
-```

package/docs/api/console.md

@@ -1,57 +0,0 @@
-{% callout %}
-**Note** — Bun provides a browser- and Node.js-compatible [console](https://developer.mozilla.org/en-US/docs/Web/API/console) global. This page only documents Bun-native APIs.
-{% /callout %}
-
-## Object inspection depth
-
-Bun allows you to configure how deeply nested objects are displayed in `console.log()` output:
-
-- **CLI flag**: Use `--console-depth <number>` to set the depth for a single run
-- **Configuration**: Set `console.depth` in your `bunfig.toml` for persistent configuration
-- **Default**: Objects are inspected to a depth of `2` levels
-
-```js
-const nested = { a: { b: { c: { d: "deep" } } } };
-console.log(nested);
-// Default (depth 2): { a: { b: [Object] } }
-// With depth 4: { a: { b: { c: { d: 'deep' } } } }
-```
-
-The CLI flag takes precedence over the configuration file setting.
-
-## Reading from stdin
-
-In Bun, the `console` object can be used as an `AsyncIterable` to sequentially read lines from `process.stdin`.
-
-```ts
-for await (const line of console) {
-  console.log(line);
-}
-```
-
-This is useful for implementing interactive programs, like the following addition calculator.
-
-```ts#adder.ts
-console.log(`Let's add some numbers!`);
-console.write(`Count: 0\n> `);
-
-let count = 0;
-for await (const line of console) {
-  count += Number(line);
-  console.write(`Count: ${count}\n> `);
-}
-```
-
-To run the file:
-
-```bash
-$ bun adder.ts
-Let's add some numbers!
-Count: 0
-> 5
-Count: 5
-> 5
-Count: 10
-> 5
-Count: 15
-```