@remix-run/multipart-parser 0.11.0 → 0.13.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Michael Jackson
+Copyright (c) 2025 Shopify Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -19,7 +19,7 @@
 - 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)
+- [Demos for every major runtime](https://github.com/remix-run/remix/tree/main/packages/multipart-parser/demos)
 
 ## Installation
 
@@ -29,41 +29,35 @@ Install from [npm](https://www.npmjs.com/):
 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';
+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}`);
+        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);
+        await saveFile(part.filename, part.bytes)
       } else {
-        let text = part.text; // string
-        console.log(`Field received: ${part.name} = ${JSON.stringify(text)}`);
+        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);
+      console.error('Failed to parse multipart request:', error.message)
     } else {
-      console.error('An unexpected error occurred:', error);
+      console.error('An unexpected error occurred:', error)
     }
   }
 }
@@ -78,10 +72,10 @@ import {
   MultipartParseError,
   MaxFileSizeExceededError,
   parseMultipartRequest,
-} from '@remix-run/multipart-parser/node';
+} from '@remix-run/multipart-parser/node'
 
-const oneMb = Math.pow(2, 20);
-const maxFileSize = 10 * oneMb;
+const oneMb = Math.pow(2, 20)
+const maxFileSize = 10 * oneMb
 
 async function handleRequest(request: Request): Promise<Response> {
   try {
@@ -90,12 +84,12 @@ async function handleRequest(request: Request): Promise<Response> {
     }
   } catch (error) {
     if (error instanceof MaxFileSizeExceededError) {
-      return new Response('File size limit exceeded', { status: 413 });
+      return new Response('File size limit exceeded', { status: 413 })
     } else if (error instanceof MultipartParseError) {
-      return new Response('Failed to parse multipart request', { status: 400 });
+      return new Response('Failed to parse multipart request', { status: 400 })
     } else {
-      console.error(error);
-      return new Response('Internal Server Error', { status: 500 });
+      console.error(error)
+      return new Response('Internal Server Error', { status: 500 })
     }
   }
 }
@@ -108,8 +102,8 @@ The main module (`import from "@remix-run/multipart-parser"`) assumes you're wor
 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';
+import * as http from 'node:http'
+import { MultipartParseError, parseMultipartRequest } from '@remix-run/multipart-parser/node'
 
 let server = http.createServer(async (req, res) => {
   try {
@@ -118,14 +112,14 @@ let server = http.createServer(async (req, res) => {
     }
   } catch (error) {
     if (error instanceof MultipartParseError) {
-      console.error('Failed to parse multipart request:', error.message);
+      console.error('Failed to parse multipart request:', error.message)
     } else {
-      console.error('An unexpected error occurred:', error);
+      console.error('An unexpected error occurred:', error)
     }
   }
-});
+})
 
-server.listen(8080);
+server.listen(8080)
 ```
 
 ## Low-level API
@@ -133,10 +127,10 @@ server.listen(8080);
 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';
+import { parseMultipart } from '@remix-run/multipart-parser'
 
-let message = new Uint8Array(/* ... */);
-let boundary = '----WebKitFormBoundary56eac3x';
+let message = new Uint8Array(/* ... */)
+let boundary = '----WebKitFormBoundary56eac3x'
 
 for (let part of parseMultipart(message, { boundary })) {
   // ...
@@ -146,24 +140,24 @@ 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';
+import { parseMultipartStream } from '@remix-run/multipart-parser'
 
-let message = new ReadableStream(/* ... */);
-let boundary = '----WebKitFormBoundary56eac3x';
+let message = new ReadableStream(/* ... */)
+let boundary = '----WebKitFormBoundary56eac3x'
 
 for await (let part of parseMultipartStream(message, { boundary })) {
   // ...
 }
 ```
 
-## Examples
+## Demos
 
-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:
+The [`demos` directory](https://github.com/remix-run/remix/tree/main/packages/multipart-parser/demos) contains a few working demos 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
+- [`demos/bun`](https://github.com/remix-run/remix/tree/main/packages/multipart-parser/demos/bun) - using multipart-parser in Bun
+- [`demos/cf-workers`](https://github.com/remix-run/remix/tree/main/packages/multipart-parser/demos/cf-workers) - using multipart-parser in a Cloudflare Worker and storing file uploads in R2
+- [`demos/deno`](https://github.com/remix-run/remix/tree/main/packages/multipart-parser/demos/deno) - using multipart-parser in Deno
+- [`demos/node`](https://github.com/remix-run/remix/tree/main/packages/multipart-parser/demos/node) - using multipart-parser in Node.js
 
 ## Benchmark
 
@@ -223,8 +217,8 @@ Deno 2.3.6
 
 ## 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`
+- [`form-data-parser`](https://github.com/remix-run/remix/tree/main/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/main/packages/headers) - Used internally to parse HTTP headers and get metadata (filename, content type) for each `MultipartPart`
 
 ## Credits
 
@@ -232,4 +226,4 @@ Thanks to Jacob Ebey who gave me several code reviews on this project prior to p
 
 ## License
 
-See [LICENSE](https://github.com/remix-run/remix/blob/v3/LICENSE)
+See [LICENSE](https://github.com/remix-run/remix/blob/main/LICENSE)

package/dist/{multipart-parser.d.ts → index.d.ts}

@@ -1,4 +1,4 @@
 export type { ParseMultipartOptions, MultipartParserOptions } from './lib/multipart.ts';
 export { MultipartParseError, MaxHeaderSizeExceededError, MaxFileSizeExceededError, parseMultipart, parseMultipartStream, MultipartParser, MultipartPart, } from './lib/multipart.ts';
 export { getMultipartBoundary, isMultipartRequest, parseMultipartRequest, } from './lib/multipart-request.ts';
-//# sourceMappingURL=multipart-parser.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AACvF,OAAO,EACL,mBAAmB,EACnB,0BAA0B,EAC1B,wBAAwB,EACxB,cAAc,EACd,oBAAoB,EACpB,eAAe,EACf,aAAa,GACd,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,GACtB,MAAM,4BAA4B,CAAA"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { MultipartParseError, MaxHeaderSizeExceededError, MaxFileSizeExceededError, parseMultipart, parseMultipartStream, MultipartParser, MultipartPart, } from "./lib/multipart.js";
+export { getMultipartBoundary, isMultipartRequest, parseMultipartRequest, } from "./lib/multipart-request.js";

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

@@ -1 +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"}
+{"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,CAAA;CAC/C;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CA+B5D;AAED,MAAM,WAAW,yBAAyB;IACxC,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAAA;CAC/B;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,yBAAyB,CAyBlF"}

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.d.ts.map

@@ -1 +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"}
+{"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,CAAA;AAG3E;;;;;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-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.map

@@ -1 +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"}
+{"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"}

package/dist/lib/multipart.js

@@ -0,0 +1,320 @@
+import Headers from '@remix-run/headers';
+import { readStream } from "./read-stream.js";
+import { createSearch, createPartialTailSearch } from "./buffer-search.js";
+/**
+ * The base class for errors thrown by the multipart parser.
+ */
+export class MultipartParseError extends Error {
+    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 {
+    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 {
+    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;
+    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;
+    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.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"multipart.node.d.ts","sourceRoot":"","sources":["../../src/lib/multipart.node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,IAAI,MAAM,WAAW,CAAA;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEtC,OAAO,KAAK,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAQlG;;;;;;;;;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"}