@remix-run/multipart-parser 0.12.0 → 0.14.0

package/dist/lib/buffer-search.js

@@ -0,0 +1,51 @@
+export function createSearch(pattern) {
+    let needle = new TextEncoder().encode(pattern);
+    let search;
+    if ('Buffer' in globalThis && !('Bun' in globalThis || 'Deno' in globalThis)) {
+        // Use the built-in Buffer.indexOf method on Node.js for better perf.
+        search = (haystack, start = 0) => Buffer.prototype.indexOf.call(haystack, needle, start);
+    }
+    else {
+        let needleEnd = needle.length - 1;
+        let skipTable = new Uint8Array(256).fill(needle.length);
+        for (let i = 0; i < needleEnd; ++i) {
+            skipTable[needle[i]] = needleEnd - i;
+        }
+        search = (haystack, start = 0) => {
+            let haystackLength = haystack.length;
+            let i = start + needleEnd;
+            while (i < haystackLength) {
+                for (let j = needleEnd, k = i; j >= 0 && haystack[k] === needle[j]; --j, --k) {
+                    if (j === 0)
+                        return k;
+                }
+                i += skipTable[haystack[i]];
+            }
+            return -1;
+        };
+    }
+    return search;
+}
+export function createPartialTailSearch(pattern) {
+    let needle = new TextEncoder().encode(pattern);
+    let byteIndexes = {};
+    for (let i = 0; i < needle.length; ++i) {
+        let byte = needle[i];
+        if (byteIndexes[byte] === undefined)
+            byteIndexes[byte] = [];
+        byteIndexes[byte].push(i);
+    }
+    return function (haystack) {
+        let haystackEnd = haystack.length - 1;
+        if (haystack[haystackEnd] in byteIndexes) {
+            let indexes = byteIndexes[haystack[haystackEnd]];
+            for (let i = indexes.length - 1; i >= 0; --i) {
+                for (let j = indexes[i], k = haystackEnd; j >= 0 && haystack[k] === needle[j]; --j, --k) {
+                    if (j === 0)
+                        return k;
+                }
+            }
+        }
+        return -1;
+    };
+}

package/dist/lib/multipart-request.js

@@ -0,0 +1,46 @@
+import { MultipartParseError, parseMultipartStream } from "./multipart.js";
+/**
+ * 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 function getMultipartBoundary(contentType) {
+    let match = /boundary=(?:"([^"]+)"|([^;]+))/i.exec(contentType);
+    return match ? (match[1] ?? match[2]) : 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 function isMultipartRequest(request) {
+    let contentType = request.headers.get('Content-Type');
+    return contentType != null && contentType.startsWith('multipart/');
+}
+/**
+ * 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 async function* parseMultipartRequest(request, options) {
+    if (!isMultipartRequest(request)) {
+        throw new MultipartParseError('Request is not a multipart request');
+    }
+    if (!request.body) {
+        throw new MultipartParseError('Request body is empty');
+    }
+    let boundary = getMultipartBoundary(request.headers.get('Content-Type'));
+    if (!boundary) {
+        throw new MultipartParseError('Invalid Content-Type header: missing boundary');
+    }
+    yield* parseMultipartStream(request.body, {
+        boundary,
+        maxHeaderSize: options?.maxHeaderSize,
+        maxFileSize: options?.maxFileSize,
+    });
+}

package/dist/lib/multipart.d.ts

@@ -3,20 +3,32 @@ import Headers from '@remix-run/headers';
  * The base class for errors thrown by the multipart parser.
  */
 export declare class MultipartParseError extends Error {
+    /**
+     * @param message The error message
+     */
     constructor(message: string);
 }
 /**
  * An error thrown when the maximum allowed size of a header is exceeded.
  */
 export declare class MaxHeaderSizeExceededError extends MultipartParseError {
+    /**
+     * @param maxHeaderSize The maximum header size that was exceeded
+     */
     constructor(maxHeaderSize: number);
 }
 /**
  * An error thrown when the maximum allowed size of a file is exceeded.
  */
 export declare class MaxFileSizeExceededError extends MultipartParseError {
+    /**
+     * @param maxFileSize The maximum file size that was exceeded
+     */
     constructor(maxFileSize: number);
 }
+/**
+ * Options for parsing a multipart message.
+ */
 export interface ParseMultipartOptions {
     /**
      * The boundary string used to separate parts in the multipart message,
@@ -27,14 +39,14 @@ export interface ParseMultipartOptions {
      * 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
+     * @default 8192 (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
+     * @default 2097152 (2 MiB)
      */
     maxFileSize?: number;
 }
@@ -60,6 +72,9 @@ export declare function parseMultipart(message: Uint8Array | Iterable<Uint8Array
  * @return An async generator that yields `MultipartPart` objects
  */
 export declare function parseMultipartStream(stream: ReadableStream<Uint8Array>, options: ParseMultipartOptions): AsyncGenerator<MultipartPart, void, unknown>;
+/**
+ * Options for configuring a `MultipartParser`.
+ */
 export type MultipartParserOptions = Omit<ParseMultipartOptions, 'boundary'>;
 /**
  * A streaming parser for `multipart/*` HTTP messages.
@@ -69,6 +84,10 @@ export declare class MultipartParser {
     readonly boundary: string;
     readonly maxHeaderSize: number;
     readonly maxFileSize: number;
+    /**
+     * @param boundary The boundary string used to separate parts
+     * @param options Options for the parser
+     */
     constructor(boundary: string, options?: MultipartParserOptions);
     /**
      * Write a chunk of data to the parser.
@@ -96,6 +115,10 @@ export declare class MultipartPart {
      * The raw content of this part as an array of `Uint8Array` chunks.
      */
     readonly content: Uint8Array[];
+    /**
+     * @param header The raw header bytes
+     * @param content The content chunks
+     */
     constructor(header: Uint8Array, content: Uint8Array[]);
     /**
      * The content of this part as an `ArrayBuffer`.

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

@@ -1 +1 @@
-{"version":3,"file":"multipart.d.ts","sourceRoot":"","sources":["../../src/lib/multipart.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,oBAAoB,CAAA;AAMxC;;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,CAAA;IAChB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;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,CAAA;AAa5E;;GAEG;AACH,qBAAa,eAAe;;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;gBAahB,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,CAAA;gBAKlB,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"}
+{"version":3,"file":"multipart.d.ts","sourceRoot":"","sources":["../../src/lib/multipart.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,oBAAoB,CAAA;AAUxC;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C;;OAEG;gBACS,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,0BAA2B,SAAQ,mBAAmB;IACjE;;OAEG;gBACS,aAAa,EAAE,MAAM;CAIlC;AAED;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,mBAAmB;IAC/D;;OAEG;gBACS,WAAW,EAAE,MAAM;CAIhC;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;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;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,qBAAqB,EAAE,UAAU,CAAC,CAAA;AAa5E;;GAEG;AACH,qBAAa,eAAe;;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAa5B;;;OAGG;gBACS,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,CAAA;IAK9B;;;OAGG;gBACS,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.js

@@ -0,0 +1,337 @@
+import Headers from '@remix-run/headers';
+import { createSearch, createPartialTailSearch, } from "./buffer-search.js";
+import { readStream } from "./read-stream.js";
+/**
+ * The base class for errors thrown by the multipart parser.
+ */
+export class MultipartParseError extends Error {
+    /**
+     * @param message The error message
+     */
+    constructor(message) {
+        super(message);
+        this.name = 'MultipartParseError';
+    }
+}
+/**
+ * An error thrown when the maximum allowed size of a header is exceeded.
+ */
+export class MaxHeaderSizeExceededError extends MultipartParseError {
+    /**
+     * @param maxHeaderSize The maximum header size that was exceeded
+     */
+    constructor(maxHeaderSize) {
+        super(`Multipart header size exceeds maximum allowed size of ${maxHeaderSize} bytes`);
+        this.name = 'MaxHeaderSizeExceededError';
+    }
+}
+/**
+ * An error thrown when the maximum allowed size of a file is exceeded.
+ */
+export class MaxFileSizeExceededError extends MultipartParseError {
+    /**
+     * @param maxFileSize The maximum file size that was exceeded
+     */
+    constructor(maxFileSize) {
+        super(`File size exceeds maximum allowed size of ${maxFileSize} bytes`);
+        this.name = 'MaxFileSizeExceededError';
+    }
+}
+/**
+ * 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 function* parseMultipart(message, options) {
+    let parser = new MultipartParser(options.boundary, {
+        maxHeaderSize: options.maxHeaderSize,
+        maxFileSize: options.maxFileSize,
+    });
+    if (message instanceof Uint8Array) {
+        if (message.length === 0) {
+            return; // No data to parse
+        }
+        yield* parser.write(message);
+    }
+    else {
+        for (let chunk of message) {
+            yield* parser.write(chunk);
+        }
+    }
+    parser.finish();
+}
+/**
+ * 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 async function* parseMultipartStream(stream, options) {
+    let parser = new MultipartParser(options.boundary, {
+        maxHeaderSize: options.maxHeaderSize,
+        maxFileSize: options.maxFileSize,
+    });
+    for await (let chunk of readStream(stream)) {
+        if (chunk.length === 0) {
+            continue; // No data to parse
+        }
+        yield* parser.write(chunk);
+    }
+    parser.finish();
+}
+const MultipartParserStateStart = 0;
+const MultipartParserStateAfterBoundary = 1;
+const MultipartParserStateHeader = 2;
+const MultipartParserStateBody = 3;
+const MultipartParserStateDone = 4;
+const findDoubleNewline = createSearch('\r\n\r\n');
+const oneKb = 1024;
+const oneMb = 1024 * oneKb;
+/**
+ * A streaming parser for `multipart/*` HTTP messages.
+ */
+export class MultipartParser {
+    boundary;
+    maxHeaderSize;
+    maxFileSize;
+    #findOpeningBoundary;
+    #openingBoundaryLength;
+    #findBoundary;
+    #findPartialTailBoundary;
+    #boundaryLength;
+    #state = MultipartParserStateStart;
+    #buffer = null;
+    #currentPart = null;
+    #contentLength = 0;
+    /**
+     * @param boundary The boundary string used to separate parts
+     * @param options Options for the parser
+     */
+    constructor(boundary, options) {
+        this.boundary = boundary;
+        this.maxHeaderSize = options?.maxHeaderSize ?? 8 * oneKb;
+        this.maxFileSize = options?.maxFileSize ?? 2 * oneMb;
+        this.#findOpeningBoundary = createSearch(`--${boundary}`);
+        this.#openingBoundaryLength = 2 + boundary.length; // length of '--' + boundary
+        this.#findBoundary = createSearch(`\r\n--${boundary}`);
+        this.#findPartialTailBoundary = createPartialTailSearch(`\r\n--${boundary}`);
+        this.#boundaryLength = 4 + boundary.length; // length of '\r\n--' + boundary
+    }
+    /**
+     * 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) {
+        if (this.#state === MultipartParserStateDone) {
+            throw new MultipartParseError('Unexpected data after end of stream');
+        }
+        let index = 0;
+        let chunkLength = chunk.length;
+        if (this.#buffer !== null) {
+            let newChunk = new Uint8Array(this.#buffer.length + chunkLength);
+            newChunk.set(this.#buffer, 0);
+            newChunk.set(chunk, this.#buffer.length);
+            chunk = newChunk;
+            chunkLength = chunk.length;
+            this.#buffer = null;
+        }
+        while (true) {
+            if (this.#state === MultipartParserStateBody) {
+                if (chunkLength - index < this.#boundaryLength) {
+                    this.#buffer = chunk.subarray(index);
+                    break;
+                }
+                let boundaryIndex = this.#findBoundary(chunk, index);
+                if (boundaryIndex === -1) {
+                    // No boundary found, but there may be a partial match at the end of the chunk.
+                    let partialTailIndex = this.#findPartialTailBoundary(chunk);
+                    if (partialTailIndex === -1) {
+                        this.#append(index === 0 ? chunk : chunk.subarray(index));
+                    }
+                    else {
+                        this.#append(chunk.subarray(index, partialTailIndex));
+                        this.#buffer = chunk.subarray(partialTailIndex);
+                    }
+                    break;
+                }
+                this.#append(chunk.subarray(index, boundaryIndex));
+                yield this.#currentPart;
+                index = boundaryIndex + this.#boundaryLength;
+                this.#state = MultipartParserStateAfterBoundary;
+            }
+            if (this.#state === MultipartParserStateAfterBoundary) {
+                if (chunkLength - index < 2) {
+                    this.#buffer = chunk.subarray(index);
+                    break;
+                }
+                if (chunk[index] === 45 && chunk[index + 1] === 45) {
+                    this.#state = MultipartParserStateDone;
+                    break;
+                }
+                index += 2; // Skip \r\n after boundary
+                this.#state = MultipartParserStateHeader;
+            }
+            if (this.#state === MultipartParserStateHeader) {
+                if (chunkLength - index < 4) {
+                    this.#buffer = chunk.subarray(index);
+                    break;
+                }
+                let headerEndIndex = findDoubleNewline(chunk, index);
+                if (headerEndIndex === -1) {
+                    if (chunkLength - index > this.maxHeaderSize) {
+                        throw new MaxHeaderSizeExceededError(this.maxHeaderSize);
+                    }
+                    this.#buffer = chunk.subarray(index);
+                    break;
+                }
+                if (headerEndIndex - index > this.maxHeaderSize) {
+                    throw new MaxHeaderSizeExceededError(this.maxHeaderSize);
+                }
+                this.#currentPart = new MultipartPart(chunk.subarray(index, headerEndIndex), []);
+                this.#contentLength = 0;
+                index = headerEndIndex + 4; // Skip header + \r\n\r\n
+                this.#state = MultipartParserStateBody;
+                continue;
+            }
+            if (this.#state === MultipartParserStateStart) {
+                if (chunkLength < this.#openingBoundaryLength) {
+                    this.#buffer = chunk;
+                    break;
+                }
+                if (this.#findOpeningBoundary(chunk) !== 0) {
+                    throw new MultipartParseError('Invalid multipart stream: missing initial boundary');
+                }
+                index = this.#openingBoundaryLength;
+                this.#state = MultipartParserStateAfterBoundary;
+            }
+        }
+    }
+    #append(chunk) {
+        if (this.#contentLength + chunk.length > this.maxFileSize) {
+            throw new MaxFileSizeExceededError(this.maxFileSize);
+        }
+        this.#currentPart.content.push(chunk);
+        this.#contentLength += chunk.length;
+    }
+    /**
+     * 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() {
+        if (this.#state !== MultipartParserStateDone) {
+            throw new MultipartParseError('Multipart stream not finished');
+        }
+    }
+}
+const decoder = new TextDecoder('utf-8', { fatal: true });
+/**
+ * A part of a `multipart/*` HTTP message.
+ */
+export class MultipartPart {
+    /**
+     * The raw content of this part as an array of `Uint8Array` chunks.
+     */
+    content;
+    #header;
+    #headers;
+    /**
+     * @param header The raw header bytes
+     * @param content The content chunks
+     */
+    constructor(header, content) {
+        this.#header = header;
+        this.content = content;
+    }
+    /**
+     * The content of this part as an `ArrayBuffer`.
+     */
+    get arrayBuffer() {
+        return this.bytes.buffer;
+    }
+    /**
+     * 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() {
+        let buffer = new Uint8Array(this.size);
+        let offset = 0;
+        for (let chunk of this.content) {
+            buffer.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return buffer;
+    }
+    /**
+     * The headers associated with this part.
+     */
+    get headers() {
+        if (!this.#headers) {
+            this.#headers = new Headers(decoder.decode(this.#header));
+        }
+        return this.#headers;
+    }
+    /**
+     * True if this part originated from a file upload.
+     */
+    get isFile() {
+        return this.filename !== undefined || this.mediaType === 'application/octet-stream';
+    }
+    /**
+     * True if this part originated from a text input field in a form submission.
+     */
+    get isText() {
+        return !this.isFile;
+    }
+    /**
+     * The filename of the part, if it is a file upload.
+     */
+    get filename() {
+        return this.headers.contentDisposition.preferredFilename;
+    }
+    /**
+     * The media type of the part.
+     */
+    get mediaType() {
+        return this.headers.contentType.mediaType;
+    }
+    /**
+     * The name of the part, usually the `name` of the field in the `<form>` that submitted the request.
+     */
+    get name() {
+        return this.headers.contentDisposition.name;
+    }
+    /**
+     * The size of the content in bytes.
+     */
+    get size() {
+        let size = 0;
+        for (let chunk of this.content) {
+            size += chunk.length;
+        }
+        return size;
+    }
+    /**
+     * 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() {
+        return decoder.decode(this.bytes);
+    }
+}

package/dist/lib/multipart.node.js

@@ -0,0 +1,60 @@
+import { Readable } from 'node:stream';
+import { MultipartParseError, parseMultipart as parseMultipartWeb, parseMultipartStream as parseMultipartStreamWeb, } from "./multipart.js";
+import { getMultipartBoundary } from "./multipart-request.js";
+/**
+ * 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 function* parseMultipart(message, options) {
+    yield* parseMultipartWeb(message, options);
+}
+/**
+ * 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 async function* parseMultipartStream(stream, options) {
+    yield* parseMultipartStreamWeb(Readable.toWeb(stream), options);
+}
+/**
+ * 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 function isMultipartRequest(req) {
+    let contentType = req.headers['content-type'];
+    return contentType != null && /^multipart\//i.test(contentType);
+}
+/**
+ * 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 async function* parseMultipartRequest(req, options) {
+    if (!isMultipartRequest(req)) {
+        throw new MultipartParseError('Request is not a multipart request');
+    }
+    let boundary = getMultipartBoundary(req.headers['content-type']);
+    if (!boundary) {
+        throw new MultipartParseError('Invalid Content-Type header: missing boundary');
+    }
+    yield* parseMultipartStream(req, {
+        boundary,
+        maxHeaderSize: options?.maxHeaderSize,
+        maxFileSize: options?.maxFileSize,
+    });
+}

package/dist/lib/read-stream.js

@@ -0,0 +1,16 @@
+// We need this little helper for environments that do not support
+// ReadableStream.prototype[Symbol.asyncIterator] yet. See #46
+export async function* readStream(stream) {
+    let reader = stream.getReader();
+    try {
+        while (true) {
+            let result = await reader.read();
+            if (result.done)
+                break;
+            yield result.value;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}