@remix-run/multipart-parser 0.11.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Michael Jackson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,235 @@
+# multipart-parser
+
+`multipart-parser` is a fast, streaming multipart parser that works in **any JavaScript environment**, from serverless functions to traditional servers. Whether you're handling file uploads, parsing email attachments, or working with multipart API responses, `multipart-parser` has you covered.
+
+## 🚀 Why multipart-parser?
+
+- **Universal JavaScript** - One library that works everywhere: Node.js, Bun, Deno, Cloudflare Workers, and browsers
+- **Blazing Fast** - Consistently outperforms popular alternatives like busboy in benchmarks
+- **Zero Dependencies** - Lightweight and secure with no external dependencies
+- **Memory Efficient** - Streaming architecture that `yield`s files as they are found in the stream
+- **Type Safe** - Written in TypeScript with comprehensive type definitions
+- **Standards Based** - Built on the web standard [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API) for maximum compatibility
+- **Production Ready** - Battle-tested error handling with specific error types for common scenarios
+
+## 📦 Features
+
+- Parse file uploads (`multipart/form-data`) with automatic field and file detection
+- Support for all `multipart/*` content types (mixed, alternative, related, etc.)
+- Convenient `MultipartPart` API with `arrayBuffer`, `bytes`, `text`, `size`, and metadata access
+- Built-in file size limiting to prevent abuse
+- First-class Node.js support with native `http.IncomingMessage` compatibility
+- [Examples for every major runtime](https://github.com/remix-run/remix/tree/v3/packages/multipart-parser/examples)
+
+## Installation
+
+Install from [npm](https://www.npmjs.com/):
+
+```sh
+npm install @remix-run/multipart-parser
+```
+
+Or install from [JSR](https://jsr.io/):
+
+```sh
+deno add @remix-run/multipart-parser
+```
+
+## Usage
+
+The most common use case for `multipart-parser` is handling file uploads when you're building a web server. For this case, the `parseMultipartRequest` function is your friend. It automatically validates the request is `multipart/form-data`, extracts the multipart boundary from the `Content-Type` header, parses all fields and files in the `request.body` stream, and gives each one to you as a `MultipartPart` object with a rich API for accessing its metadata and content.
+
+```ts
+import { MultipartParseError, parseMultipartRequest } from '@remix-run/multipart-parser';
+
+async function handleRequest(request: Request): void {
+  try {
+    for await (let part of parseMultipartRequest(request)) {
+      if (part.isFile) {
+        // Access file data in multiple formats
+        let buffer = part.arrayBuffer; // ArrayBuffer
+        console.log(`File received: ${part.filename} (${buffer.byteLength} bytes)`);
+        console.log(`Content type: ${part.mediaType}`);
+        console.log(`Field name: ${part.name}`);
+
+        // Save to disk, upload to cloud storage, etc.
+        await saveFile(part.filename, part.bytes);
+      } else {
+        let text = part.text; // string
+        console.log(`Field received: ${part.name} = ${JSON.stringify(text)}`);
+      }
+    }
+  } catch (error) {
+    if (error instanceof MultipartParseError) {
+      console.error('Failed to parse multipart request:', error.message);
+    } else {
+      console.error('An unexpected error occurred:', error);
+    }
+  }
+}
+```
+
+## Limiting File Upload Size
+
+A common use case when handling file uploads is limiting the size of uploaded files to prevent malicious users from sending very large files that may overload your server's memory and/or storage capacity. You can set a file upload size limit using the `maxFileSize` option, and return a 413 "Payload Too Large" response when you receive a request that exceeds the limit.
+
+```ts
+import {
+  MultipartParseError,
+  MaxFileSizeExceededError,
+  parseMultipartRequest,
+} from '@remix-run/multipart-parser/node';
+
+const oneMb = Math.pow(2, 20);
+const maxFileSize = 10 * oneMb;
+
+async function handleRequest(request: Request): Promise<Response> {
+  try {
+    for await (let part of parseMultipartRequest(request, { maxFileSize })) {
+      // ...
+    }
+  } catch (error) {
+    if (error instanceof MaxFileSizeExceededError) {
+      return new Response('File size limit exceeded', { status: 413 });
+    } else if (error instanceof MultipartParseError) {
+      return new Response('Failed to parse multipart request', { status: 400 });
+    } else {
+      console.error(error);
+      return new Response('Internal Server Error', { status: 500 });
+    }
+  }
+}
+```
+
+## Node.js Bindings
+
+The main module (`import from "@remix-run/multipart-parser"`) assumes you're working with [the fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) (`Request`, `ReadableStream`, etc). Support for these interfaces was added to Node.js by the [undici](https://github.com/nodejs/undici) project in [version 16.5.0](https://nodejs.org/en/blog/release/v16.5.0).
+
+If however you're building a server for Node.js that relies on node-specific APIs like `http.IncomingMessage`, `stream.Readable`, and `buffer.Buffer` (ala Express or `http.createServer`), `multipart-parser` ships with an additional module that works directly with these APIs.
+
+```ts
+import * as http from 'node:http';
+import { MultipartParseError, parseMultipartRequest } from '@remix-run/multipart-parser/node';
+
+let server = http.createServer(async (req, res) => {
+  try {
+    for await (let part of parseMultipartRequest(req)) {
+      // ...
+    }
+  } catch (error) {
+    if (error instanceof MultipartParseError) {
+      console.error('Failed to parse multipart request:', error.message);
+    } else {
+      console.error('An unexpected error occurred:', error);
+    }
+  }
+});
+
+server.listen(8080);
+```
+
+## Low-level API
+
+If you're working directly with multipart boundaries and buffers/streams of multipart data that are not necessarily part of a request, `multipart-parser` provides a low-level `parseMultipart()` API that you can use directly:
+
+```ts
+import { parseMultipart } from '@remix-run/multipart-parser';
+
+let message = new Uint8Array(/* ... */);
+let boundary = '----WebKitFormBoundary56eac3x';
+
+for (let part of parseMultipart(message, { boundary })) {
+  // ...
+}
+```
+
+In addition, the `parseMultipartStream` function provides an `async` generator interface for multipart data in a `ReadableStream`:
+
+```ts
+import { parseMultipartStream } from '@remix-run/multipart-parser';
+
+let message = new ReadableStream(/* ... */);
+let boundary = '----WebKitFormBoundary56eac3x';
+
+for await (let part of parseMultipartStream(message, { boundary })) {
+  // ...
+}
+```
+
+## Examples
+
+The [`examples` directory](https://github.com/remix-run/remix/tree/v3/packages/multipart-parser/examples) contains a few working examples of how you can use this library:
+
+- [`examples/bun`](https://github.com/remix-run/remix/tree/v3/packages/multipart-parser/examples/bun) - using multipart-parser in Bun
+- [`examples/cf-workers`](https://github.com/remix-run/remix/tree/v3/packages/multipart-parser/examples/cf-workers) - using multipart-parser in a Cloudflare Worker and storing file uploads in R2
+- [`examples/deno`](https://github.com/remix-run/remix/tree/v3/packages/multipart-parser/examples/deno) - using multipart-parser in Deno
+- [`examples/node`](https://github.com/remix-run/remix/tree/v3/packages/multipart-parser/examples/node) - using multipart-parser in Node.js
+
+## Benchmark
+
+`multipart-parser` is designed to be as efficient as possible, operating on streams of data and rarely buffering in common usage. This design yields exceptional performance when handling multipart payloads of any size. In benchmarks, `multipart-parser` is as fast or faster than `busboy`.
+
+The results of running the benchmarks on my laptop:
+
+```
+> @remix-run/multipart-parser@0.10.1 bench:node /Users/michael/Projects/remix-the-web/packages/multipart-parser
+> node --disable-warning=ExperimentalWarning ./bench/runner.ts
+
+Platform: Darwin (24.5.0)
+CPU: Apple M1 Pro
+Date: 6/13/2025, 12:27:09 PM
+Node.js v24.0.2
+┌──────────────────┬──────────────────┬──────────────────┬──────────────────┬───────────────────┐
+│ (index)          │ 1 small file     │ 1 large file     │ 100 small files  │ 5 large files     │
+├──────────────────┼──────────────────┼──────────────────┼──────────────────┼───────────────────┤
+│ multipart-parser │ '0.01 ms ± 0.03' │ '1.08 ms ± 0.08' │ '0.04 ms ± 0.01' │ '10.50 ms ± 0.38' │
+│ multipasta       │ '0.02 ms ± 0.06' │ '1.07 ms ± 0.02' │ '0.15 ms ± 0.02' │ '10.46 ms ± 0.11' │
+│ busboy           │ '0.06 ms ± 0.17' │ '3.07 ms ± 0.24' │ '0.24 ms ± 0.05' │ '29.85 ms ± 0.18' │
+│ @fastify/busboy  │ '0.05 ms ± 0.13' │ '1.23 ms ± 0.09' │ '0.45 ms ± 0.22' │ '11.81 ms ± 0.11' │
+└──────────────────┴──────────────────┴──────────────────┴──────────────────┴───────────────────┘
+
+> @remix-run/multipart-parser@0.10.1 bench:bun /Users/michael/Projects/remix-the-web/packages/multipart-parser
+> bun run ./bench/runner.ts
+
+Platform: Darwin (24.5.0)
+CPU: Apple M1 Pro
+Date: 6/13/2025, 12:27:31 PM
+Bun 1.2.13
+┌──────────────────┬────────────────┬────────────────┬─────────────────┬─────────────────┐
+│                  │ 1 small file   │ 1 large file   │ 100 small files │ 5 large files   │
+├──────────────────┼────────────────┼────────────────┼─────────────────┼─────────────────┤
+│ multipart-parser │ 0.01 ms ± 0.04 │ 0.86 ms ± 0.09 │ 0.04 ms ± 0.01  │ 8.32 ms ± 0.26  │
+│       multipasta │ 0.02 ms ± 0.07 │ 0.87 ms ± 0.03 │ 0.25 ms ± 0.21  │ 8.27 ms ± 0.09  │
+│           busboy │ 0.05 ms ± 0.17 │ 3.54 ms ± 0.10 │ 0.30 ms ± 0.03  │ 34.79 ms ± 0.38 │
+│  @fastify/busboy │ 0.06 ms ± 0.18 │ 4.04 ms ± 0.08 │ 0.48 ms ± 0.06  │ 39.91 ms ± 0.37 │
+└──────────────────┴────────────────┴────────────────┴─────────────────┴─────────────────┘
+
+> @remix-run/multipart-parser@0.10.1 bench:deno /Users/michael/Projects/remix-the-web/packages/multipart-parser
+> deno run --allow-sys ./bench/runner.ts
+
+Platform: Darwin (24.5.0)
+CPU: Apple M1 Pro
+Date: 6/13/2025, 12:28:12 PM
+Deno 2.3.6
+┌──────────────────┬──────────────────┬────────────────────┬──────────────────┬─────────────────────┐
+│ (idx)            │ 1 small file     │ 1 large file       │ 100 small files  │ 5 large files       │
+├──────────────────┼──────────────────┼────────────────────┼──────────────────┼─────────────────────┤
+│ multipart-parser │ "0.01 ms ± 0.03" │ "1.03 ms ± 0.04"   │ "0.05 ms ± 0.01" │ "10.05 ms ± 0.20"   │
+│ multipasta       │ "0.02 ms ± 0.07" │ "1.04 ms ± 0.03"   │ "0.16 ms ± 0.02" │ "10.10 ms ± 0.08"   │
+│ busboy           │ "0.05 ms ± 0.19" │ "3.06 ms ± 0.15"   │ "0.32 ms ± 0.05" │ "29.92 ms ± 0.24"   │
+│ @fastify/busboy  │ "0.06 ms ± 0.14" │ "14.72 ms ± 11.42" │ "0.81 ms ± 0.20" │ "127.63 ms ± 35.77" │
+└──────────────────┴──────────────────┴────────────────────┴──────────────────┴─────────────────────┘
+```
+
+## Related Packages
+
+- [`form-data-parser`](https://github.com/remix-run/remix/tree/v3/packages/form-data-parser) - Uses `multipart-parser` internally to parse multipart requests and generate `FileUpload`s for storage
+- [`headers`](https://github.com/remix-run/remix/tree/v3/packages/headers) - Used internally to parse HTTP headers and get metadata (filename, content type) for each `MultipartPart`
+
+## Credits
+
+Thanks to Jacob Ebey who gave me several code reviews on this project prior to publishing.
+
+## License
+
+See [LICENSE](https://github.com/remix-run/remix/blob/v3/LICENSE)

package/dist/lib/buffer-search.d.ts

@@ -0,0 +1,9 @@
+export interface SearchFunction {
+    (haystack: Uint8Array, start?: number): number;
+}
+export declare function createSearch(pattern: string): SearchFunction;
+export interface PartialTailSearchFunction {
+    (haystack: Uint8Array): number;
+}
+export declare function createPartialTailSearch(pattern: string): PartialTailSearchFunction;
+//# sourceMappingURL=buffer-search.d.ts.map

package/dist/lib/buffer-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-search.d.ts","sourceRoot":"","sources":["../../src/lib/buffer-search.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAChD;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CA+B5D;AAED,MAAM,WAAW,yBAAyB;IACxC,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAAC;CAChC;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,yBAAyB,CAyBlF"}

package/dist/lib/multipart-request.d.ts

@@ -0,0 +1,25 @@
+import type { MultipartParserOptions, MultipartPart } from './multipart.ts';
+/**
+ * Extracts the boundary string from a `multipart/*` content type.
+ *
+ * @param contentType The `Content-Type` header value from the request
+ * @return The boundary string if found, or null if not present
+ */
+export declare function getMultipartBoundary(contentType: string): string | null;
+/**
+ * Returns true if the given request contains multipart data.
+ *
+ * @param request The `Request` object to check
+ * @return `true` if the request is a multipart request, `false` otherwise
+ */
+export declare function isMultipartRequest(request: Request): boolean;
+/**
+ * Parse a multipart [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) and yield each part as
+ * a `MultipartPart` object. Useful in HTTP server contexts for handling incoming `multipart/*` requests.
+ *
+ * @param request The `Request` object containing multipart data
+ * @param options Optional parser options, such as `maxHeaderSize` and `maxFileSize`
+ * @return An async generator yielding `MultipartPart` objects
+ */
+export declare function parseMultipartRequest(request: Request, options?: MultipartParserOptions): AsyncGenerator<MultipartPart, void, unknown>;
+//# sourceMappingURL=multipart-request.d.ts.map

package/dist/lib/multipart-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multipart-request.d.ts","sourceRoot":"","sources":["../../src/lib/multipart-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAG5E;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGvE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAG5D;AAED;;;;;;;GAOG;AACH,wBAAuB,qBAAqB,CAC1C,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,cAAc,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,CAAC,CAkB9C"}

package/dist/lib/multipart.d.ts

@@ -0,0 +1,145 @@
+import Headers from '@remix-run/headers';
+/**
+ * The base class for errors thrown by the multipart parser.
+ */
+export declare class MultipartParseError extends Error {
+    constructor(message: string);
+}
+/**
+ * An error thrown when the maximum allowed size of a header is exceeded.
+ */
+export declare class MaxHeaderSizeExceededError extends MultipartParseError {
+    constructor(maxHeaderSize: number);
+}
+/**
+ * An error thrown when the maximum allowed size of a file is exceeded.
+ */
+export declare class MaxFileSizeExceededError extends MultipartParseError {
+    constructor(maxFileSize: number);
+}
+export interface ParseMultipartOptions {
+    /**
+     * The boundary string used to separate parts in the multipart message,
+     * e.g. the `boundary` parameter in the `Content-Type` header.
+     */
+    boundary: string;
+    /**
+     * The maximum allowed size of a header in bytes. If an individual part's header
+     * exceeds this size, a `MaxHeaderSizeExceededError` will be thrown.
+     *
+     * Default: 8 KiB
+     */
+    maxHeaderSize?: number;
+    /**
+     * The maximum allowed size of a file in bytes. If an individual part's content
+     * exceeds this size, a `MaxFileSizeExceededError` will be thrown.
+     *
+     * Default: 2 MiB
+     */
+    maxFileSize?: number;
+}
+/**
+ * Parse a `multipart/*` message from a buffer/iterable and yield each part as a `MultipartPart` object.
+ *
+ * Note: This is a low-level API that requires manual handling of the content and boundary. If you're
+ * building a web server, consider using `parseMultipartRequest(request)` instead.
+ *
+ * @param message The multipart message as a `Uint8Array` or an iterable of `Uint8Array` chunks
+ * @param options Options for the parser
+ * @return A generator that yields `MultipartPart` objects
+ */
+export declare function parseMultipart(message: Uint8Array | Iterable<Uint8Array>, options: ParseMultipartOptions): Generator<MultipartPart, void, unknown>;
+/**
+ * Parse a `multipart/*` message stream and yield each part as a `MultipartPart` object.
+ *
+ * Note: This is a low-level API that requires manual handling of the content and boundary. If you're
+ * building a web server, consider using `parseMultipartRequest(request)` instead.
+ *
+ * @param stream A stream containing multipart data as a `ReadableStream<Uint8Array>`
+ * @param options Options for the parser
+ * @return An async generator that yields `MultipartPart` objects
+ */
+export declare function parseMultipartStream(stream: ReadableStream<Uint8Array>, options: ParseMultipartOptions): AsyncGenerator<MultipartPart, void, unknown>;
+export type MultipartParserOptions = Omit<ParseMultipartOptions, 'boundary'>;
+/**
+ * A streaming parser for `multipart/*` HTTP messages.
+ */
+export declare class MultipartParser {
+    #private;
+    readonly boundary: string;
+    readonly maxHeaderSize: number;
+    readonly maxFileSize: number;
+    constructor(boundary: string, options?: MultipartParserOptions);
+    /**
+     * Write a chunk of data to the parser.
+     *
+     * @param chunk A chunk of data to write to the parser
+     * @return A generator yielding `MultipartPart` objects as they are parsed
+     */
+    write(chunk: Uint8Array): Generator<MultipartPart, void, unknown>;
+    /**
+     * Should be called after all data has been written to the parser.
+     *
+     * Note: This will throw if the multipart message is incomplete or
+     * wasn't properly terminated.
+     *
+     * @return void
+     */
+    finish(): void;
+}
+/**
+ * A part of a `multipart/*` HTTP message.
+ */
+export declare class MultipartPart {
+    #private;
+    /**
+     * The raw content of this part as an array of `Uint8Array` chunks.
+     */
+    readonly content: Uint8Array[];
+    constructor(header: Uint8Array, content: Uint8Array[]);
+    /**
+     * The content of this part as an `ArrayBuffer`.
+     */
+    get arrayBuffer(): ArrayBuffer;
+    /**
+     * The content of this part as a single `Uint8Array`. In `multipart/form-data` messages, this is useful
+     * for reading the value of files that were uploaded using `<input type="file">` fields.
+     */
+    get bytes(): Uint8Array;
+    /**
+     * The headers associated with this part.
+     */
+    get headers(): Headers;
+    /**
+     * True if this part originated from a file upload.
+     */
+    get isFile(): boolean;
+    /**
+     * True if this part originated from a text input field in a form submission.
+     */
+    get isText(): boolean;
+    /**
+     * The filename of the part, if it is a file upload.
+     */
+    get filename(): string | undefined;
+    /**
+     * The media type of the part.
+     */
+    get mediaType(): string | undefined;
+    /**
+     * The name of the part, usually the `name` of the field in the `<form>` that submitted the request.
+     */
+    get name(): string | undefined;
+    /**
+     * The size of the content in bytes.
+     */
+    get size(): number;
+    /**
+     * The content of this part as a string. In `multipart/form-data` messages, this is useful for
+     * reading the value of parts that originated from `<input type="text">` fields.
+     *
+     * Note: Do not use this for binary data, use `part.bytes` or `part.arrayBuffer` instead.
+     */
+    get text(): string;
+}
+//# sourceMappingURL=multipart.d.ts.map

package/dist/lib/multipart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multipart.d.ts","sourceRoot":"","sources":["../../src/lib/multipart.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,oBAAoB,CAAC;AAMzC;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,0BAA2B,SAAQ,mBAAmB;gBACrD,aAAa,EAAE,MAAM;CAIlC;AAED;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,mBAAmB;gBACnD,WAAW,EAAE,MAAM;CAIhC;AAED,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;GASG;AACH,wBAAiB,cAAc,CAC7B,OAAO,EAAE,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC,EAC1C,OAAO,EAAE,qBAAqB,GAC7B,SAAS,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,CAAC,CAmBzC;AAED;;;;;;;;;GASG;AACH,wBAAuB,oBAAoB,CACzC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,EAClC,OAAO,EAAE,qBAAqB,GAC7B,cAAc,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,CAAC,CAe9C;AAED,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,qBAAqB,EAAE,UAAU,CAAC,CAAC;AAa7E;;GAEG;AACH,qBAAa,eAAe;;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;gBAajB,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB;IAY9D;;;;;OAKG;IACF,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,CAAC;IA0HlE;;;;;;;OAOG;IACH,MAAM,IAAI,IAAI;CAKf;AAID;;GAEG;AACH,qBAAa,aAAa;;IACxB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,CAAC;gBAKnB,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE;IAKrD;;OAEG;IACH,IAAI,WAAW,IAAI,WAAW,CAE7B;IAED;;;OAGG;IACH,IAAI,KAAK,IAAI,UAAU,CAUtB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAMrB;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,MAAM,GAAG,SAAS,CAEjC;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,MAAM,GAAG,SAAS,CAElC;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,GAAG,SAAS,CAE7B;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAQjB;IAED;;;;;OAKG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/lib/multipart.node.d.ts

@@ -0,0 +1,41 @@
+import type * as http from 'node:http';
+import { Readable } from 'node:stream';
+import type { ParseMultipartOptions, MultipartParserOptions, MultipartPart } from './multipart.ts';
+/**
+ * Parse a `multipart/*` Node.js `Buffer` and yield each part as a `MultipartPart` object.
+ *
+ * Note: This is a low-level API that requires manual handling of the content and boundary. If you're
+ * building a web server, consider using `parseMultipartRequest(request)` instead.
+ *
+ * @param message The multipart message as a `Buffer` or an iterable of `Buffer` chunks
+ * @param options Options for the parser
+ * @return A generator yielding `MultipartPart` objects
+ */
+export declare function parseMultipart(message: Buffer | Iterable<Buffer>, options: ParseMultipartOptions): Generator<MultipartPart, void, unknown>;
+/**
+ * Parse a `multipart/*` Node.js `Readable` stream and yield each part as a `MultipartPart` object.
+ *
+ * Note: This is a low-level API that requires manual handling of the stream and boundary. If you're
+ * building a web server, consider using `parseMultipartRequest(request)` instead.
+ *
+ * @param stream A Node.js `Readable` stream containing multipart data
+ * @param options Options for the parser
+ * @return An async generator yielding `MultipartPart` objects
+ */
+export declare function parseMultipartStream(stream: Readable, options: ParseMultipartOptions): AsyncGenerator<MultipartPart, void, unknown>;
+/**
+ * Returns true if the given request is a multipart request.
+ *
+ * @param req The Node.js `http.IncomingMessage` object to check
+ * @return `true` if the request is a multipart request, `false` otherwise
+ */
+export declare function isMultipartRequest(req: http.IncomingMessage): boolean;
+/**
+ * Parse a multipart Node.js request and yield each part as a `MultipartPart` object.
+ *
+ * @param req The Node.js `http.IncomingMessage` object containing multipart data
+ * @param options Options for the parser
+ * @return An async generator yielding `MultipartPart` objects
+ */
+export declare function parseMultipartRequest(req: http.IncomingMessage, options?: MultipartParserOptions): AsyncGenerator<MultipartPart, void, unknown>;
+//# sourceMappingURL=multipart.node.d.ts.map

package/dist/lib/multipart.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multipart.node.d.ts","sourceRoot":"","sources":["../../src/lib/multipart.node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,IAAI,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,OAAO,KAAK,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAQnG;;;;;;;;;GASG;AACH,wBAAiB,cAAc,CAC7B,OAAO,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,EAClC,OAAO,EAAE,qBAAqB,GAC7B,SAAS,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,CAAC,CAEzC;AAED;;;;;;;;;GASG;AACH,wBAAuB,oBAAoB,CACzC,MAAM,EAAE,QAAQ,EAChB,OAAO,EAAE,qBAAqB,GAC7B,cAAc,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,CAAC,CAE9C;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,GAAG,OAAO,CAGrE;AAED;;;;;;GAMG;AACH,wBAAuB,qBAAqB,CAC1C,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,cAAc,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,CAAC,CAe9C"}

package/dist/lib/read-stream.d.ts

@@ -0,0 +1,2 @@
+export declare function readStream(stream: ReadableStream<Uint8Array>): AsyncIterable<Uint8Array>;
+//# sourceMappingURL=read-stream.d.ts.map

package/dist/lib/read-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-stream.d.ts","sourceRoot":"","sources":["../../src/lib/read-stream.ts"],"names":[],"mappings":"AAEA,wBAAuB,UAAU,CAAC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,CAY/F"}