npm - @hasna/connectors - Versions diffs - 1.3.1 → 1.3.2 - Mend

@hasna/connectors 1.3.1 → 1.3.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (717) hide show

package/connectors/connect-yousign/node_modules/bun-types/docs/bundler/standalone-html.mdx ADDED Viewed

@@ -0,0 +1,314 @@
+---
+title: Standalone HTML
+description: Bundle a single-page app into a single self-contained .html file with no external dependencies
+---
+Bun can bundle your entire frontend into a **single `.html` file** with zero external dependencies. JavaScript, TypeScript, JSX, CSS, images, fonts, videos, WASM — everything gets inlined into one file.
+```bash terminal icon="terminal"
+bun build --compile --target=browser ./index.html --outdir=dist
+```
+The output is a completely self-contained HTML document. No relative paths. No external files. No server required. Just one `.html` file that works anywhere a browser can open it.
+## One file. Upload anywhere. It just works.
+The output is a single `.html` file you can put anywhere:
+- **Upload it to S3** or any static file host — no directory structure to maintain, just one file
+- **Double-click it from your desktop** — it opens in the browser and works offline, no localhost server needed
+- **Embed it in your webview** — No need to deal with relative files
+- **Insert it in an `<iframe>`** — embed interactive content in another page with a single file URL
+- **Serve it from anywhere** — any HTTP server, CDN, or file share. One file, zero configuration.
+There's nothing to install, no `node_modules` to deploy, no build artifacts to coordinate, no relative paths to think about. The entire app — framework code, stylesheets, images, everything — lives in that one file.
+## Truly one file
+Normally, distributing a web page means managing a folder of assets — the HTML, the JavaScript bundles, the CSS files, the images. Move the HTML without the rest and everything breaks. Browsers have tried to solve this before: Safari's `.webarchive` and `.mhtml` are supposed to save a page as a single file, but in practice they unpack into a folder of loose files on your computer — defeating the purpose.
+Standalone HTML is different. The output is a plain `.html` file. Not an archive. Not a folder. One file, with everything inside it. Every image, every font, every line of CSS and JavaScript is embedded directly in the HTML using standard `<style>` tags, `<script>` tags, and `data:` URIs. Any browser can open it. Any server can host it. Any file host can store it.
+This makes it practical to distribute web pages the same way you'd distribute a PDF — as a single file you can move, copy, upload, or share without worrying about broken paths or missing assets.
+## Quick start
+<CodeGroup>
+```html index.html icon="file-code"
+<!doctype html>
+<html>
+  <head>
+    <link rel="stylesheet" href="./styles.css" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script src="./app.tsx"></script>
+  </body>
+</html>
+```
+```tsx app.tsx icon="/icons/typescript.svg"
+import React from "react";
+import { createRoot } from "react-dom/client";
+function App() {
+  return <h1>Hello from a single HTML file!</h1>;
+}
+createRoot(document.getElementById("root")!).render(<App />);
+```
+```css styles.css icon="file-code"
+body {
+  margin: 0;
+  font-family: system-ui, sans-serif;
+  background: #f5f5f5;
+}
+```
+</CodeGroup>
+```bash terminal icon="terminal"
+bun build --compile --target=browser ./index.html --outdir=dist
+```
+Open `dist/index.html` — the React app works with no server.
+## Everything gets inlined
+Bun inlines every local asset it finds in your HTML. If it has a relative path, it gets embedded into the output file. This isn't limited to images and stylesheets — it works with any file type.
+### What gets inlined
+| In your source                                   | In the output                                                            |
+| ------------------------------------------------ | ------------------------------------------------------------------------ |
+| `<script src="./app.tsx">`                       | `<script type="module">...bundled code...</script>`                      |
+| `<link rel="stylesheet" href="./styles.css">`    | `<style>...bundled CSS...</style>`                                       |
+| `<img src="./logo.png">`                         | `<img src="data:image/png;base64,...">`                                  |
+| `<img src="./icon.svg">`                         | `<img src="data:image/svg+xml;base64,...">`                              |
+| `<video src="./demo.mp4">`                       | `<video src="data:video/mp4;base64,...">`                                |
+| `<audio src="./click.wav">`                      | `<audio src="data:audio/wav;base64,...">`                                |
+| `<source src="./clip.webm">`                     | `<source src="data:video/webm;base64,...">`                              |
+| `<video poster="./thumb.jpg">`                   | `<video poster="data:image/jpeg;base64,...">`                            |
+| `<link rel="icon" href="./favicon.ico">`         | `<link rel="icon" href="data:image/x-icon;base64,...">`                  |
+| `<link rel="manifest" href="./app.webmanifest">` | `<link rel="manifest" href="data:application/manifest+json;base64,...">` |
+| CSS `url("./bg.png")`                            | CSS `url(data:image/png;base64,...)`                                     |
+| CSS `@import "./reset.css"`                      | Flattened into the `<style>` tag                                         |
+| CSS `url("./font.woff2")`                        | CSS `url(data:font/woff2;base64,...)`                                    |
+| JS `import "./styles.css"`                       | Merged into the `<style>` tag                                            |
+Images, fonts, WASM binaries, videos, audio files, SVGs — any file referenced by a relative path gets base64-encoded into a `data:` URI and embedded directly in the HTML. The MIME type is automatically detected from the file extension.
+External URLs (like CDN links or absolute URLs) are left untouched.
+## Using with React
+React apps work out of the box. Bun handles JSX transpilation and npm package resolution automatically.
+```bash terminal icon="terminal"
+bun install react react-dom
+```
+<CodeGroup>
+```html index.html icon="file-code"
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>My App</title>
+    <link rel="stylesheet" href="./styles.css" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script src="./app.tsx"></script>
+  </body>
+</html>
+```
+```tsx app.tsx icon="/icons/typescript.svg"
+import React, { useState } from "react";
+import { createRoot } from "react-dom/client";
+import { Counter } from "./components/Counter.tsx";
+function App() {
+  return (
+    <main>
+      <h1>Single-file React App</h1>
+      <Counter />
+    </main>
+  );
+}
+createRoot(document.getElementById("root")!).render(<App />);
+```
+```tsx components/Counter.tsx icon="/icons/typescript.svg"
+import React, { useState } from "react";
+export function Counter() {
+  const [count, setCount] = useState(0);
+  return <button onClick={() => setCount(count + 1)}>Count: {count}</button>;
+}
+```
+</CodeGroup>
+```bash terminal icon="terminal"
+bun build --compile --target=browser ./index.html --outdir=dist
+```
+All of React, your components, and your CSS are bundled into `dist/index.html`. Upload that one file anywhere and it works.
+## Using with Tailwind CSS
+Install the plugin and reference Tailwind in your HTML or CSS:
+```bash terminal icon="terminal"
+bun install --dev bun-plugin-tailwind
+```
+<CodeGroup>
+```html index.html icon="file-code"
+<!doctype html>
+<html>
+  <head>
+    <link rel="stylesheet" href="tailwindcss" />
+  </head>
+  <body class="bg-gray-100 flex items-center justify-center min-h-screen">
+    <div id="root"></div>
+    <script src="./app.tsx"></script>
+  </body>
+</html>
+```
+```tsx app.tsx icon="/icons/typescript.svg"
+import React from "react";
+import { createRoot } from "react-dom/client";
+function App() {
+  return (
+    <div className="bg-white rounded-lg shadow-lg p-8 max-w-md">
+      <h1 className="text-2xl font-bold text-gray-800">Hello Tailwind</h1>
+      <p className="text-gray-600 mt-2">This is a single HTML file.</p>
+    </div>
+  );
+}
+createRoot(document.getElementById("root")!).render(<App />);
+```
+</CodeGroup>
+Build with the plugin using the JavaScript API:
+```ts build.ts icon="/icons/typescript.svg"
+await Bun.build({
+  entrypoints: ["./index.html"],
+  compile: true,
+  target: "browser",
+  outdir: "./dist",
+  plugins: [require("bun-plugin-tailwind")],
+});
+```
+```bash terminal icon="terminal"
+bun run build.ts
+```
+The generated Tailwind CSS is inlined directly into the HTML file as a `<style>` tag.
+## How it works
+When you pass `--compile --target=browser` with an HTML entrypoint, Bun:
+1. Parses the HTML and discovers all `<script>`, `<link>`, `<img>`, `<video>`, `<audio>`, `<source>`, and other asset references
+2. Bundles all JavaScript/TypeScript/JSX into a single module
+3. Bundles all CSS (including `@import` chains and CSS imported from JS) into a single stylesheet
+4. Converts every relative asset reference into a base64 `data:` URI
+5. Inlines the bundled JS as `<script type="module">` before `</body>`
+6. Inlines the bundled CSS as `<style>` in `<head>`
+7. Outputs a single `.html` file with no external dependencies
+## Minification
+Add `--minify` to minify the JavaScript and CSS:
+```bash terminal icon="terminal"
+bun build --compile --target=browser --minify ./index.html --outdir=dist
+```
+Or via the API:
+```ts build.ts icon="/icons/typescript.svg"
+await Bun.build({
+  entrypoints: ["./index.html"],
+  compile: true,
+  target: "browser",
+  outdir: "./dist",
+  minify: true,
+});
+```
+## JavaScript API
+You can use `Bun.build()` to produce standalone HTML programmatically:
+```ts build.ts icon="/icons/typescript.svg"
+const result = await Bun.build({
+  entrypoints: ["./index.html"],
+  compile: true,
+  target: "browser",
+  outdir: "./dist", // optional — omit to get output as BuildArtifact
+  minify: true,
+});
+if (!result.success) {
+  console.error("Build failed:");
+  for (const log of result.logs) {
+    console.error(log);
+  }
+} else {
+  console.log("Built:", result.outputs[0].path);
+}
+```
+When `outdir` is omitted, the output is available as a `BuildArtifact` in `result.outputs`:
+```ts icon="/icons/typescript.svg"
+const result = await Bun.build({
+  entrypoints: ["./index.html"],
+  compile: true,
+  target: "browser",
+});
+const html = await result.outputs[0].text();
+await Bun.write("output.html", html);
+```
+## Multiple HTML files
+You can pass multiple HTML files as entrypoints. Each produces its own standalone HTML file:
+```bash terminal icon="terminal"
+bun build --compile --target=browser ./index.html ./about.html --outdir=dist
+```
+## Environment variables
+Use `--env` to inline environment variables into the bundled JavaScript:
+```bash terminal icon="terminal"
+API_URL=https://api.example.com bun build --compile --target=browser --env=inline ./index.html --outdir=dist
+```
+References to `process.env.API_URL` in your JavaScript are replaced with the literal value at build time.
+## Limitations
+- **Code splitting** is not supported — `--splitting` cannot be used with `--compile --target=browser`
+- **Large assets** increase file size since they're base64-encoded (33% overhead vs the raw binary)
+- **External URLs** (CDN links, absolute URLs) are left as-is — only relative paths are inlined

package/connectors/connect-yousign/node_modules/bun-types/docs/feedback.mdx ADDED Viewed

@@ -0,0 +1,75 @@
+---
+title: Feedback
+description: Share feedback, bug reports, and feature requests
+mode: center
+---
+Whether you've found a bug, have a performance issue, or just want to suggest an improvement, here's how you can open a helpful issue:
+<Callout icon="discord">For general questions, please join our [Discord](https://bun.com/discord).</Callout>
+## Reporting Issues
+<Steps>
+	<Step title="Upgrade Bun">
+		Try upgrading Bun to the latest version with `bun upgrade`. This might fix your problem without having to open an issue.
+    	```bash terminal icon="terminal"
+    	bun upgrade
+    	```
+    	You can also try the latest canary release, which includes the most recent changes and bug fixes that haven't been released in a stable version yet.
+    	```bash terminal icon="terminal"
+    	bun upgrade --canary
+    	# To revert back to the stable
+    	bun upgrade --stable
+    	```
+    	If the issue still persists after upgrading, continue to the next step.
+    </Step>
+    <Step title="Review Existing Issues">
+    	First take a minute to check if the issue has already been reported. Don't open a new issue if it has already been reported, it saves time for everyone and helps us focus on fixing things faster.
+    	- 🔍 [**Search existing issues**](https://github.com/oven-sh/bun/issues)
+    	- 💬 [**Check discussions**](https://github.com/oven-sh/bun/discussions)
+    	If you find a related issue, add a 👍 reaction or comment with extra details instead of opening a new one.
+    </Step>
+    <Step title="Report the Issue">
+    	If no one has reported the issue, please open a new issue or suggest an improvement.
+    	- 🐞 [**Report a Bug**](https://github.com/oven-sh/bun/issues/new?template=2-bug-report.yml)
+    	- ⚡ [**Suggest an Improvement**](https://github.com/oven-sh/bun/issues/new?template=4-feature-request.yml)
+    	Please provide as much detail as possible, including:
+    	- A clear and concise title
+    	- A code example or steps to reproduce the issue
+    	- The version of Bun you are using (run `bun --version`)
+    	- A detailed description of the issue (what happened, what you expected to happen, and what actually happened)
+    	- The operating system and version you are using
+    		<Note>
+    			- For MacOS and Linux: copy the output of `uname -mprs`
+    		  - For Windows: copy the output of this command in the powershell console:
+    				`"$([Environment]::OSVersion | ForEach-Object VersionString) $(if ([Environment]::Is64BitOperatingSystem) { "x64" } else { "x86" })"`
+    		</Note>
+    </Step>
+</Steps>
+The Bun team will review the issue and get back to you as soon as possible!
+---
+## Use `bun feedback`
+Alternatively, you can use `bun feedback` to share feedback, bug reports, and feature requests directly with the Bun team.
+```bash terminal icon="terminal"
+bun feedback "Love the new release!"
+bun feedback report.txt details.log
+echo "please document X" | bun feedback --email you@example.com
+```
+You can provide feedback as text arguments, file paths, or piped input.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/binary/arraybuffer-to-array.mdx ADDED Viewed

@@ -0,0 +1,29 @@
+---
+title: Convert an ArrayBuffer to an array of numbers
+sidebarTitle: "ArrayBuffer to Array"
+mode: center
+---
+To retrieve the contents of an `ArrayBuffer` as an array of numbers, create a [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) over of the buffer. and use the [`Array.from()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from) method to convert it to an array.
+```ts
+const buf = new ArrayBuffer(64);
+const arr = new Uint8Array(buf);
+arr.length; // 64
+arr[0]; // 0 (instantiated with all zeros)
+```
+---
+The `Uint8Array` class supports array indexing and iteration. However if you wish to convert the instance to a regular `Array`, use `Array.from()`. (This will likely be slower than using the `Uint8Array` directly.)
+```ts
+const buf = new ArrayBuffer(64);
+const uintArr = new Uint8Array(buf);
+const regularArr = Array.from(uintArr);
+// number[]
+```
+---
+See [Docs > API > Binary Data](/docs/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/binary/arraybuffer-to-blob.mdx ADDED Viewed

@@ -0,0 +1,26 @@
+---
+title: Convert an ArrayBuffer to a Blob
+sidebarTitle: "ArrayBuffer to Blob"
+mode: center
+---
+A [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) can be constructed from an array of "chunks", where each chunk is a string, binary data structure, or another `Blob`.
+```ts
+const buf = new ArrayBuffer(64);
+const blob = new Blob([buf]);
+```
+---
+By default the `type` of the resulting `Blob` will be unset. This can be set manually.
+```ts
+const buf = new ArrayBuffer(64);
+const blob = new Blob([buf], { type: "application/octet-stream" });
+blob.type; // => "application/octet-stream"
+```
+---
+See [Docs > API > Binary Data](/docs/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/binary/arraybuffer-to-buffer.mdx ADDED Viewed

@@ -0,0 +1,27 @@
+---
+title: Convert an ArrayBuffer to a Buffer
+sidebarTitle: "ArrayBuffer to Buffer"
+mode: center
+---
+The Node.js [`Buffer`](https://nodejs.org/api/buffer.html) API predates the introduction of `ArrayBuffer` into the JavaScript language. Bun implements both.
+Use the static `Buffer.from()` method to create a `Buffer` from an `ArrayBuffer`.
+```ts
+const arrBuffer = new ArrayBuffer(64);
+const nodeBuffer = Buffer.from(arrBuffer);
+```
+---
+To create a `Buffer` that only views a portion of the underlying buffer, pass the offset and length to the constructor.
+```ts
+const arrBuffer = new ArrayBuffer(64);
+const nodeBuffer = Buffer.from(arrBuffer, 0, 16); // view first 16 bytes
+```
+---
+See [Docs > API > Binary Data](/docs/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/binary/arraybuffer-to-string.mdx ADDED Viewed

@@ -0,0 +1,17 @@
+---
+title: Convert an ArrayBuffer to a string
+sidebarTitle: "ArrayBuffer to string"
+mode: center
+---
+Bun implements the Web-standard [`TextDecoder`](https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder) class for converting between binary data types and strings.
+```ts
+const buf = new ArrayBuffer(64);
+const decoder = new TextDecoder();
+const str = decoder.decode(buf);
+```
+---
+See [Docs > API > Binary Data](/docs/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/binary/arraybuffer-to-typedarray.mdx ADDED Viewed

@@ -0,0 +1,41 @@
+---
+title: Convert an ArrayBuffer to a Uint8Array
+sidebarTitle: "ArrayBuffer to Uint8Array"
+mode: center
+---
+A `Uint8Array` is a _typed array_, meaning it is a mechanism for viewing the data in an underlying `ArrayBuffer`.
+```ts
+const buffer = new ArrayBuffer(64);
+const arr = new Uint8Array(buffer);
+```
+---
+Instances of other typed arrays can be created similarly.
+```ts
+const buffer = new ArrayBuffer(64);
+const arr1 = new Uint8Array(buffer);
+const arr2 = new Uint16Array(buffer);
+const arr3 = new Uint32Array(buffer);
+const arr4 = new Float32Array(buffer);
+const arr5 = new Float64Array(buffer);
+const arr6 = new BigInt64Array(buffer);
+const arr7 = new BigUint64Array(buffer);
+```
+---
+To create a typed array that only views a portion of the underlying buffer, pass the offset and length to the constructor.
+```ts
+const buffer = new ArrayBuffer(64);
+const arr = new Uint8Array(buffer, 0, 16); // view first 16 bytes
+```
+---
+See [Docs > API > Utils](/docs/runtime/utils) for more useful utilities.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/binary/blob-to-arraybuffer.mdx ADDED Viewed

@@ -0,0 +1,16 @@
+---
+title: Convert a Blob to an ArrayBuffer
+sidebarTitle: "Blob to ArrayBuffer"
+mode: center
+---
+The [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) class provides a number of methods for consuming its contents in different formats, including `.arrayBuffer()`.
+```ts
+const blob = new Blob(["hello world"]);
+const buf = await blob.arrayBuffer();
+```
+---
+See [Docs > API > Binary Data](/docs/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/binary/blob-to-dataview.mdx ADDED Viewed

@@ -0,0 +1,16 @@
+---
+title: Convert a Blob to a DataView
+sidebarTitle: "Blob to DataView"
+mode: center
+---
+The [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) class provides a number of methods for consuming its contents in different formats. This snippets reads the contents to an `ArrayBuffer`, then creates a `DataView` from the buffer.
+```ts
+const blob = new Blob(["hello world"]);
+const arr = new DataView(await blob.arrayBuffer());
+```
+---
+See [Docs > API > Binary Data](/docs/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/binary/blob-to-stream.mdx ADDED Viewed

@@ -0,0 +1,16 @@
+---
+title: Convert a Blob to a ReadableStream
+sidebarTitle: "Blob to ReadableStream"
+mode: center
+---
+The [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) class provides a number of methods for consuming its contents in different formats, including `.stream()`. This returns `Promise<ReadableStream>`.
+```ts
+const blob = new Blob(["hello world"]);
+const stream = await blob.stream();
+```
+---
+See [Docs > API > Binary Data](/docs/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/binary/blob-to-string.mdx ADDED Viewed

@@ -0,0 +1,17 @@
+---
+title: Convert a Blob to a string
+sidebarTitle: "Blob to string"
+mode: center
+---
+The [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) class provides a number of methods for consuming its contents in different formats, including `.text()`.
+```ts
+const blob = new Blob(["hello world"]);
+const str = await blob.text();
+// => "hello world"
+```
+---
+See [Docs > API > Binary Data](/docs/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/binary/blob-to-typedarray.mdx ADDED Viewed

@@ -0,0 +1,16 @@
+---
+title: Convert a Blob to a Uint8Array
+sidebarTitle: "Blob to Uint8Array"
+mode: center
+---
+The [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) class provides a number of methods for consuming its contents in different formats. This snippets reads the contents to an `ArrayBuffer`, then creates a `Uint8Array` from the buffer.
+```ts
+const blob = new Blob(["hello world"]);
+const arr = new Uint8Array(await blob.arrayBuffer());
+```
+---
+See [Docs > API > Binary Data](/docs/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/binary/buffer-to-arraybuffer.mdx ADDED Viewed

@@ -0,0 +1,16 @@
+---
+title: Convert a Buffer to an ArrayBuffer
+sidebarTitle: "Buffer to ArrayBuffer"
+mode: center
+---
+The Node.js [`Buffer`](https://nodejs.org/api/buffer.html) class provides a way to view and manipulate data in an underlying `ArrayBuffer`, which is available via the `buffer` property.
+```ts
+const nodeBuf = Buffer.alloc(64);
+const arrBuf = nodeBuf.buffer;
+```
+---
+See [Docs > API > Binary Data](/docs/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/binary/buffer-to-blob.mdx ADDED Viewed

@@ -0,0 +1,16 @@
+---
+title: Convert a Buffer to a blob
+sidebarTitle: "Buffer to Blob"
+mode: center
+---
+A [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) can be constructed from an array of "chunks", where each chunk is a string, binary data structure (including `Buffer`), or another `Blob`.
+```ts
+const buf = Buffer.from("hello");
+const blob = new Blob([buf]);
+```
+---
+See [Docs > API > Binary Data](/docs/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.