bun-types 1.3.2-canary.20251105T140650 → 1.3.2

package/docs/runtime/{shell.md → shell.mdx}

@@ -1,8 +1,13 @@
+---
+title: Shell
+description: Use Bun's shell scripting API to run shell commands from JavaScript
+---
+
 Bun Shell makes shell scripting with JavaScript & TypeScript fun. It's a cross-platform bash-like shell with seamless JavaScript interop.
 
 Quickstart:
 
-```js
+```ts index.ts icon="/icons/typescript.svg"
 import { $ } from "bun";
 
 const response = await fetch("https://example.com");
@@ -11,7 +16,9 @@ const response = await fetch("https://example.com");
 await $`cat < ${response} | wc -c`; // 1256
 ```
 
-## Features:
+---
+
+## Features
 
 - **Cross-platform**: works on Windows, Linux & macOS. Instead of `rimraf` or `cross-env`', you can use Bun Shell without installing extra dependencies. Common shell commands like `ls`, `cd`, `rm` are implemented natively.
 - **Familiar**: Bun Shell is a bash-like shell, supporting redirection, pipes, environment variables and more.
@@ -22,6 +29,8 @@ await $`cat < ${response} | wc -c`; // 1256
 - **Shell scripting**: Bun Shell can be used to run shell scripts (`.bun.sh` files).
 - **Custom interpreter**: Bun Shell is written in Zig, along with its lexer, parser, and interpreter. Bun Shell is a small programming language.
 
+---
+
 ## Getting started
 
 The simplest shell command is `echo`. To run it, use the `$` template literal tag:
@@ -62,6 +71,8 @@ console.log(stdout); // Buffer(7) [ 72, 101, 108, 108, 111, 33, 10 ]
 console.log(stderr); // Buffer(0) []
 ```
 
+---
+
 ## Error handling
 
 By default, non-zero exit codes will throw an error. This `ShellError` contains information about the command run.
@@ -84,9 +95,7 @@ Throwing can be disabled with `.nothrow()`. The result's `exitCode` will need to
 ```js
 import { $ } from "bun";
 
-const { stdout, stderr, exitCode } = await $`something-that-may-fail`
-  .nothrow()
-  .quiet();
+const { stdout, stderr, exitCode } = await $`something-that-may-fail`.nothrow().quiet();
 
 if (exitCode !== 0) {
   console.log(`Non-zero exit code ${exitCode}`);
@@ -113,6 +122,8 @@ $.throws(false);
 await $`something-that-may-fail`; // No exception thrown
 ```
 
+---
+
 ## Redirection
 
 A command's _input_ or _output_ may be _redirected_ using the typical Bash operators:
@@ -258,11 +269,11 @@ await $`
 `;
 ```
 
-{% callout %}
+<Note>
 
-**NOTE**: Because Bun internally uses the special [`raw`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#raw_strings) property on the input template literal, using the backtick syntax for command substitution won't work:
+Because Bun internally uses the special [`raw`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#raw_strings) property on the input template literal, using the backtick syntax for command substitution won't work:
 
-```js
+```ts icon="file-code"
 import { $ } from "bun";
 
 await $`echo \`echo hi\``;
@@ -282,7 +293,9 @@ echo hi
 
 We instead recommend sticking to the `$(...)` syntax.
 
-{% /callout %}
+</Note>
+
+---
 
 ## Environment variables
 
@@ -378,6 +391,8 @@ await $`pwd`; // /tmp
 await $`pwd`.cwd("/"); // /
 ```
 
+---
+
 ## Reading output
 
 To read the output of a command as a string, use `.text()`:
@@ -438,6 +453,8 @@ const result = await $`echo "Hello World!"`.blob();
 console.log(result); // Blob(13) { size: 13, type: "text/plain" }
 ```
 
+---
+
 ## Builtin Commands
 
 For cross-platform compatibility, Bun Shell implements a set of builtin commands, in addition to reading commands from the PATH environment variable.
@@ -469,6 +486,8 @@ For cross-platform compatibility, Bun Shell implements a set of builtin commands
 
 - See [Issue #9716](https://github.com/oven-sh/bun/issues/9716) for the full list.
 
+---
+
 ## Utilities
 
 Bun Shell also implements a set of utilities for working with shells.
@@ -506,32 +525,44 @@ await $`echo ${{ raw: '$(foo) `bar` "baz"' }}`;
 // => baz
 ```
 
-## .sh file loader
+---
+
+## `.sh` file loader
 
 For simple shell scripts, instead of `/bin/sh`, you can use Bun Shell to run shell scripts.
 
 To do so, just run the script with `bun` on a file with the `.sh` extension.
 
-```sh#script.sh
+```sh script.sh icon="file-code"
 echo "Hello World! pwd=$(pwd)"
 ```
 
-```sh
-$ bun ./script.sh
+```sh terminal icon="terminal"
+bun ./script.sh
+```
+
+```txt
 Hello World! pwd=/home/demo
 ```
 
 Scripts with Bun Shell are cross platform, which means they work on Windows:
 
-```powershell
-> bun .\script.sh
+```powershell powershell icon="windows"
+bun .\script.sh
+```
+
+```txt
 Hello World! pwd=C:\Users\Demo
 ```
 
+---
+
 ## Implementation notes
 
 Bun Shell is a small programming language in Bun that is implemented in Zig. It includes a handwritten lexer, parser, and interpreter. Unlike bash, zsh, and other shells, Bun Shell runs operations concurrently.
 
+---
+
 ## Security in the Bun shell
 
 By design, the Bun shell _does not invoke a system shell_ (like `/bin/sh`) and
@@ -594,11 +625,12 @@ const branch = "--upload-pack=echo pwned";
 await $`git ls-remote origin ${branch}`;
 ```
 
-{% callout %}
-**Recommendation** — As is best practice in every language, always sanitize
-user-provided input before passing it as an argument to an external command.
-The responsibility for validating arguments rests with your application code.
-{% /callout %}
+<Note>
+  **Recommendation** — As is best practice in every language, always sanitize user-provided input before passing it as
+  an argument to an external command. The responsibility for validating arguments rests with your application code.
+</Note>
+
+---
 
 ## Credits
 

package/docs/{api/sql.md → runtime/sql.mdx}

@@ -1,6 +1,11 @@
-Bun provides native bindings for working with SQL databases through a unified Promise-based API that supports PostgreSQL, MySQL, and SQLite. The interface is designed to be simple and performant, using tagged template literals for queries and offering features like connection pooling, transactions, and prepared statements.
+---
+title: SQL
+description: Bun provides native bindings for working with SQL databases through a unified Promise-based API that supports PostgreSQL, MySQL, and SQLite.
+---
 
-```ts
+The interface is designed to be simple and performant, using tagged template literals for queries and offering features like connection pooling, transactions, and prepared statements.
+
+```ts title="db.ts" icon="/icons/typescript.svg"
 import { sql, SQL } from "bun";
 
 // PostgreSQL (default)
@@ -25,35 +30,25 @@ const sqliteResults = await sqlite`
 `;
 ```
 
-{% features title="Features" %}
-
-{% icon size=20 name="Shield" /%} Tagged template literals to protect against SQL injection
-
-{% icon size=20 name="GitMerge" /%} Transactions
-
-{% icon size=20 name="Variable" /%} Named & positional parameters
-
-{% icon size=20 name="Network" /%} Connection pooling
-
-{% icon size=20 name="Binary" /%} `BigInt` support
-
-{% icon size=20 name="Key" /%} SASL Auth support (SCRAM-SHA-256), MD5, and Clear Text
+### Features
 
-{% icon size=20 name="Timer" /%} Connection timeouts
+- Tagged template literals to protect against SQL injection
+- Transactions
+- Named & positional parameters
+- Connection pooling
+- `BigInt` support
+- SASL Auth support (SCRAM-SHA-256), MD5, and Clear Text
+- Connection timeouts
+- Returning rows as data objects, arrays of arrays, or Buffer
+- Binary protocol support makes it faster
+- TLS support (and auth mode)
+- Automatic configuration with environment variable
 
-{% icon size=20 name="Database" /%} Returning rows as data objects, arrays of arrays, or `Buffer`
-
-{% icon size=20 name="Code" /%} Binary protocol support makes it faster
-
-{% icon size=20 name="Lock" /%} TLS support (and auth mode)
-
-{% icon size=20 name="Settings" /%} Automatic configuration with environment variable
-
-{% /features %}
+---
 
 ## Database Support
 
-Bun.SQL provides a unified API for multiple database systems:
+`Bun.SQL` provides a unified API for multiple database systems:
 
 ### PostgreSQL
 
@@ -63,7 +58,7 @@ PostgreSQL is used when:
 - The connection string explicitly uses `postgres://` or `postgresql://` protocols
 - No connection string is provided and environment variables point to PostgreSQL
 
-```ts
+```ts title="db.ts" icon="/icons/typescript.svg"
 import { sql } from "bun";
 // Uses PostgreSQL if DATABASE_URL is not set or is a PostgreSQL URL
 await sql`SELECT ...`;
@@ -77,7 +72,7 @@ await pg`SELECT ...`;
 
 MySQL support is built into Bun.SQL, providing the same tagged template literal interface with full compatibility for MySQL 5.7+ and MySQL 8.0+:
 
-```ts
+```ts title="db.ts" icon="/icons/typescript.svg"
 import { SQL } from "bun";
 
 // MySQL connection
@@ -111,7 +106,7 @@ const newUsers = [
 await mysql`INSERT INTO users ${mysql(newUsers)}`;
 ```
 
-{% details summary="MySQL Connection String Formats" %}
+<Accordion title="MySQL Connection String Formats">
 
 MySQL accepts various URL formats for connection strings:
 
@@ -130,9 +125,9 @@ new SQL("mysql://user:pass@localhost/db?ssl=true");
 new SQL("mysql://user:pass@/database?socket=/var/run/mysqld/mysqld.sock");
 ```
 
-{% /details %}
+</Accordion>
 
-{% details summary="MySQL-Specific Features" %}
+<Accordion title="MySQL-Specific Features">
 
 MySQL databases support:
 
@@ -144,7 +139,7 @@ MySQL databases support:
 - **Connection attributes**: Client information sent to server for monitoring
 - **Query pipelining**: Execute multiple prepared statements without waiting for responses
 
-{% /details %}
+</Accordion>
 
 ### SQLite
 
@@ -170,7 +165,7 @@ const db2 = new SQL({
 const db3 = new SQL("myapp.db", { adapter: "sqlite" });
 ```
 
-{% details summary="SQLite Connection String Formats" %}
+<Accordion title="SQLite Connection String Formats">
 
 SQLite accepts various URL formats for connection strings:
 
@@ -199,11 +194,13 @@ new SQL("sqlite://data.db?mode=rw"); // Read-write mode (no create)
 new SQL("sqlite://data.db?mode=rwc"); // Read-write-create mode (default)
 ```
 
-**Note:** Simple filenames without a protocol (like `"myapp.db"`) require explicitly specifying `{ adapter: "sqlite" }` to avoid ambiguity with PostgreSQL.
+    <Note>
+    Simple filenames without a protocol (like `"myapp.db"`) require explicitly specifying `{ adapter: "sqlite" }` to avoid ambiguity with PostgreSQL.
+    </Note>
 
-{% /details %}
+</Accordion>
 
-{% details summary="SQLite-Specific Options" %}
+<Accordion title="SQLite-Specific Options">
 
 SQLite databases support additional configuration options:
 
@@ -229,9 +226,9 @@ Query parameters in the URL are parsed to set these options:
 - `?mode=rw` → `readonly: false, create: false`
 - `?mode=rwc` → `readonly: false, create: true` (default)
 
-{% /details %}
+</Accordion>
 
-### Inserting data
+## Inserting data
 
 You can pass JavaScript values directly to the SQL template literal and escaping will be handled for you.
 
@@ -287,6 +284,8 @@ await sql`INSERT INTO users ${sql(user, "name", "email")}`;
 // Only inserts name and email columns, ignoring other fields
 ```
 
+---
+
 ## Query Results
 
 By default, Bun's SQL client returns query results as arrays of objects, where each object represents a row with column names as keys. However, there are cases where you might want the data in a different format. The client provides two additional methods for this purpose.
@@ -320,6 +319,8 @@ const rows = await sql`SELECT * FROM users`.raw();
 console.log(rows); // [[Buffer, Buffer], [Buffer, Buffer], [Buffer, Buffer]]
 ```
 
+---
+
 ## SQL Fragments
 
 A common need in database applications is the ability to construct queries dynamically based on runtime conditions. Bun provides safe ways to do this without risking SQL injection.
@@ -391,7 +392,9 @@ await sql`SELECT * FROM products WHERE ids = ANY(${sql.array([1, 2, 3])})`;
 // Generates: SELECT * FROM products WHERE ids = ANY(ARRAY[1, 2, 3])
 ```
 
-**Note**: `sql.array` is PostgreSQL-only. Multi-dimensional arrays and NULL elements may not be supported yet.
+<Note>`sql.array` is PostgreSQL-only. Multi-dimensional arrays and NULL elements may not be supported yet.</Note>
+
+---
 
 ## `sql``.simple()`
 
@@ -431,16 +434,9 @@ const result = await sql.unsafe(`
 `);
 
 // Using parameters (only one command is allowed)
-const result = await sql.unsafe(
-  "SELECT " + dangerous + " FROM users WHERE id = $1",
-  [id],
-);
+const result = await sql.unsafe("SELECT " + dangerous + " FROM users WHERE id = $1", [id]);
 ```
 
-#### What is SQL Injection?
-
-{% image href="https://xkcd.com/327/" src="https://imgs.xkcd.com/comics/exploits_of_a_mom.png" /%}
-
 ### Execute and Cancelling Queries
 
 Bun's SQL is lazy, which means it will only start executing when awaited or executed with `.execute()`.
@@ -452,6 +448,8 @@ setTimeout(() => query.cancel(), 100);
 await query;
 ```
 
+---
+
 ## Database Environment Variables
 
 `sql` connection parameters can be configured using environment variables. The client checks these variables in a specific order of precedence and automatically detects the database type based on the connection string format.
@@ -573,6 +571,8 @@ DATABASE_URL="file:///absolute/path/to/db.sqlite"
 
 **Note:** PostgreSQL-specific environment variables (`POSTGRES_URL`, `PGHOST`, etc.) are ignored when using SQLite.
 
+---
+
 ## Runtime Preconnection
 
 Bun can preconnect to PostgreSQL at startup to improve performance by establishing database connections before your application code runs. This is useful for reducing connection latency on the first database query.
@@ -590,6 +590,8 @@ bun --sql-preconnect --hot index.js
 
 The `--sql-preconnect` flag will automatically establish a PostgreSQL connection using your configured environment variables at startup. If the connection fails, it won't crash your application - the error will be handled gracefully.
 
+---
+
 ## Connection Options
 
 You can configure your database connection manually by passing options to the SQL constructor. Options vary depending on the database adapter:
@@ -620,12 +622,13 @@ const db = new SQL({
   connectionTimeout: 30, // Timeout when establishing new connections
 
   // SSL/TLS options
-  tls: {
-    rejectUnauthorized: true,
-    ca: "path/to/ca.pem",
-    key: "path/to/key.pem",
-    cert: "path/to/cert.pem",
-  },
+  ssl: "prefer", // or "disable", "require", "verify-ca", "verify-full"
+  // tls: {
+  //   rejectUnauthorized: true,
+  //   ca: "path/to/ca.pem",
+  //   key: "path/to/key.pem",
+  //   cert: "path/to/cert.pem",
+  // },
 
   // Callbacks
   onconnect: client => {
@@ -715,14 +718,16 @@ const db = new SQL({
 });
 ```
 
-{% details summary="SQLite Connection Notes" %}
+<Accordion title="SQLite Connection Notes">
 
 - **Connection Pooling**: SQLite doesn't use connection pooling as it's a file-based database. Each `SQL` instance represents a single connection.
 - **Transactions**: SQLite supports nested transactions through savepoints, similar to PostgreSQL.
 - **Concurrent Access**: SQLite handles concurrent access through file locking. Use WAL mode for better concurrency.
 - **Memory Databases**: Using `:memory:` creates a temporary database that exists only for the connection lifetime.
 
-{% /details %}
+</Accordion>
+
+---
 
 ## Dynamic passwords
 
@@ -739,6 +744,8 @@ const sql = new SQL(url, {
 });
 ```
 
+---
+
 ## SQLite-Specific Features
 
 ### Query Execution
@@ -794,6 +801,8 @@ await sqlite`
 await sqlite`INSERT INTO flexible VALUES (${1}, ${"text"}, ${123.45}, ${Buffer.from("binary")})`;
 ```
 
+---
+
 ## Transactions
 
 To start a new transaction, use `sql.begin`. This method works for both PostgreSQL and SQLite. For PostgreSQL, it reserves a dedicated connection from the pool. For SQLite, it begins a transaction on the single connection.
@@ -869,6 +878,8 @@ await sql.commitDistributed("tx1");
 await sql.rollbackDistributed("tx1");
 ```
 
+---
+
 ## Authentication
 
 Bun supports SCRAM-SHA-256 (SASL), MD5, and Clear Text authentication. SASL is recommended for better security. Check [Postgres SASL Authentication](https://www.postgresql.org/docs/current/sasl-authentication.html) for more information.
@@ -903,11 +914,11 @@ The SSL mode can also be specified in connection strings:
 const sql = new SQL("postgres://user:password@localhost/mydb?sslmode=prefer");
 
 // Using verify-full mode
-const sql = new SQL(
-  "postgres://user:password@localhost/mydb?sslmode=verify-full",
-);
+const sql = new SQL("postgres://user:password@localhost/mydb?sslmode=verify-full");
 ```
 
+---
+
 ## Connection Pooling
 
 Bun's SQL client automatically manages a connection pool, which is a pool of database connections that are reused for multiple queries. This helps to reduce the overhead of establishing and closing connections for each query, and it also helps to manage the number of concurrent connections to the database.
@@ -941,6 +952,8 @@ await sql.close({ timeout: 5 }); // wait 5 seconds and close all connections fro
 await sql.close({ timeout: 0 }); // close all connections from the pool immediately
 ```
 
+---
+
 ## Reserved Connections
 
 Bun enables you to reserve a connection from the pool, and returns a client that wraps the single connection. This can be used for running queries on an isolated connection.
@@ -963,6 +976,8 @@ try {
 } // Automatically released
 ```
 
+---
+
 ## Prepared Statements
 
 By default, Bun's SQL client automatically creates named prepared statements for queries where it can be inferred that the query is static. This provides better performance. However, you can change this behavior by setting `prepare: false` in the connection options:
@@ -991,6 +1006,8 @@ You might want to use `prepare: false` when:
 
 Note that disabling prepared statements may impact performance for queries that are executed frequently with different parameters, as the server needs to parse and plan each query from scratch.
 
+---
+
 ## Error Handling
 
 The client provides typed errors for different failure scenarios. Errors are database-specific and extend from base error classes:
@@ -1020,7 +1037,7 @@ try {
 }
 ```
 
-{% details summary="PostgreSQL-Specific Error Codes" %}
+<Accordion title="PostgreSQL-Specific Error Codes">
 
 ### PostgreSQL Connection Errors
 
@@ -1087,13 +1104,13 @@ try {
 | `ERR_POSTGRES_UNSAFE_TRANSACTION`        | Unsafe transaction operation detected |
 | `ERR_POSTGRES_INVALID_TRANSACTION_STATE` | Invalid transaction state             |
 
-{% /details %}
+</Accordion>
 
 ### SQLite-Specific Errors
 
 SQLite errors provide error codes and numbers that correspond to SQLite's standard error codes:
 
-{% details summary="Common SQLite Error Codes" %}
+<Accordion title="Common SQLite Error Codes">
 
 | Error Code          | errno | Description                                          |
 | ------------------- | ----- | ---------------------------------------------------- |
@@ -1130,7 +1147,9 @@ try {
 }
 ```
 
-{% /details %}
+</Accordion>
+
+---
 
 ## Numbers and BigInt
 
@@ -1145,6 +1164,8 @@ console.log(typeof x, x); // "string" "9223372036854777"
 console.log(typeof y, y); // "number" 12345
 ```
 
+---
+
 ## BigInt Instead of Strings
 
 If you need large numbers as BigInt instead of strings, you can enable this by setting the `bigint` option to `true` when initializing the SQL client:
@@ -1159,6 +1180,8 @@ const [{ x }] = await sql`SELECT 9223372036854777 as x`;
 console.log(typeof x, x); // "bigint" 9223372036854777n
 ```
 
+---
+
 ## Roadmap
 
 There's still some things we haven't finished yet.
@@ -1167,6 +1190,8 @@ There's still some things we haven't finished yet.
 - Column name transforms (e.g. `snake_case` to `camelCase`). This is mostly blocked on a unicode-aware implementation of changing the case in C++ using WebKit's `WTF::String`.
 - Column type transforms
 
+---
+
 ## Database-Specific Features
 
 #### Authentication Methods
@@ -1278,6 +1303,8 @@ We also haven't implemented some of the more uncommon features like:
 - Point & PostGIS types
 - All the multi-dimensional integer array types (only a couple of the types are supported)
 
+---
+
 ## Common Patterns & Best Practices
 
 ### Working with MySQL Result Sets
@@ -1288,8 +1315,7 @@ const result = await mysql`INSERT INTO users (name) VALUES (${"Alice"})`;
 console.log(result.lastInsertRowid); // MySQL's LAST_INSERT_ID()
 
 // Handling affected rows
-const updated =
-  await mysql`UPDATE users SET active = ${false} WHERE age < ${18}`;
+const updated = await mysql`UPDATE users SET active = ${false} WHERE age < ${18}`;
 console.log(updated.affectedRows); // Number of rows updated
 
 // Using MySQL-specific functions
@@ -1322,43 +1348,47 @@ try {
 4. **Index properly**: MySQL relies heavily on indexes for query performance
 5. **Use `utf8mb4` charset**: It's set by default and handles all Unicode characters
 
-## Frequently Asked Questions
-
-> Why is this `Bun.sql` and not `Bun.postgres`?
+---
 
-The plan was to add more database drivers in the future. Now with MySQL support added, this unified API supports PostgreSQL, MySQL, and SQLite.
-
-> How do I know which database adapter is being used?
-
-The adapter is automatically detected from the connection string:
-
-- URLs starting with `mysql://` or `mysql2://` use MySQL
-- URLs matching SQLite patterns (`:memory:`, `sqlite://`, `file://`) use SQLite
-- Everything else defaults to PostgreSQL
-
-> Are MySQL stored procedures supported?
-
-Yes, stored procedures are fully supported including OUT parameters and multiple result sets:
-
-```ts
-// Call stored procedure
-const results = await mysql`CALL GetUserStats(${userId}, @total_orders)`;
-
-// Get OUT parameter
-const outParam = await mysql`SELECT @total_orders as total`;
-```
-
-> Can I use MySQL-specific SQL syntax?
-
-Yes, you can use any MySQL-specific syntax:
+## Frequently Asked Questions
 
-```ts
-// MySQL-specific syntax works fine
-await mysql`SET @user_id = ${userId}`;
-await mysql`SHOW TABLES`;
-await mysql`DESCRIBE users`;
-await mysql`EXPLAIN SELECT * FROM users WHERE id = ${id}`;
-```
+<AccordionGroup>
+	<Accordion title="Why is this `Bun.sql` and not `Bun.postgres`?">
+		The plan was to add more database drivers in the future. Now with MySQL support added, this unified API supports PostgreSQL, MySQL, and SQLite.
+	</Accordion>
+	<Accordion title="How do I know which database adapter is being used?">
+		The adapter is automatically detected from the connection string:
+
+    	- URLs starting with `mysql://` or `mysql2://` use MySQL
+    	- URLs matching SQLite patterns (`:memory:`, `sqlite://`, `file://`) use SQLite
+    	- Everything else defaults to PostgreSQL
+    </Accordion>
+    <Accordion title="Are MySQL stored procedures supported?">
+    	Yes, stored procedures are fully supported including OUT parameters and multiple result sets:
+
+    	```ts
+    	// Call stored procedure
+    	const results = await mysql`CALL GetUserStats(${userId}, @total_orders)`;
+
+    	// Get OUT parameter
+    	const outParam = await mysql`SELECT @total_orders as total`;
+    	```
+    </Accordion>
+    <Accordion title="Can I use MySQL-specific SQL syntax?">
+    	Yes, you can use any MySQL-specific syntax:
+
+    	```ts
+    	// MySQL-specific syntax works fine
+    	await mysql`SET @user_id = ${userId}`;
+    	await mysql`SHOW TABLES`;
+    	await mysql`DESCRIBE users`;
+    	await mysql`EXPLAIN SELECT * FROM users WHERE id = ${id}`;
+    	```
+    </Accordion>
+
+</AccordionGroup>
+
+---
 
 ## Why not just use an existing library?