mhtml-stream 2.0.1 → 3.0.0

package/README.md

@@ -5,10 +5,10 @@ MHTML Stream
 [![npm](https://img.shields.io/npm/v/mhtml-stream)](https://www.npmjs.com/package/mhtml-stream)
 [![license](https://img.shields.io/github/license/erikbrinkman/mhtml-stream)](LICENSE)
 
-Zero-dependency library for parsing MHTML data as streams using modern WHATWG
-streams and async iterators. Because it relies on modern cross javascript
-standards it works out-of-the-box in all javascript environments, with only a
-little tweaking necessary for module definitions.
+Library for parsing MHTML data as streams using modern WHATWG streams and async
+iterators. Because it relies on modern cross javascript standards it works
+out-of-the-box in all javascript environments, with only a little tweaking
+necessary for module definitions.
 
 Usage
 -----
@@ -39,3 +39,7 @@ Notes
   comes to whether whitespace should be added when unfolding. This currently
   uses the first whitespace character to indicate folding, and preservers any
   others.
+- Decoded part content preserves the original MIME line endings. The parser
+  splits the stream on `\r\n`, and the quoted-printable and 7bit/8bit decoders
+  re-insert that `\r\n` between lines, so extraction is lossless. Both decoders
+  accept a `newLine` argument if you'd rather normalize to `\n`.

package/dist/cli.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-console */
-import { argv } from "bun";
 import { mkdir } from "node:fs/promises";
+import { argv } from "bun";
 import yargs from "yargs";
 import { parseMhtml } from ".";
 async function* readFile(name) {

package/dist/headers.d.ts

@@ -56,7 +56,7 @@ export declare class Headers implements MhtmlHeaders {
     get(key: string, delim?: string): string | null;
     getAll(key: string): string[];
     has(key: string): boolean;
-    keys(): Iterable<string>;
+    keys(): IterableIterator<string>;
     values(delim?: string): IterableIterator<string>;
     valuesAll(): IterableIterator<string>;
 }

package/dist/headers.js

@@ -1,55 +1,59 @@
 export class Headers {
+    // keyed by lowercased name; the original name casing (first seen) is
+    // preserved for iteration while lookups are case-insensitive, per RFC 5322
     #raw = new Map();
     [Symbol.iterator]() {
         return this.entries();
     }
     append(key, value) {
-        const list = this.#raw.get(key);
-        if (list === undefined) {
-            this.#raw.set(key, [value]);
+        const entry = this.#raw.get(key.toLowerCase());
+        if (entry === undefined) {
+            this.#raw.set(key.toLowerCase(), { key, values: [value] });
         }
         else {
-            list.push(value);
+            entry.values.push(value);
         }
     }
     *entries(delim = ", ") {
-        for (const [key, values] of this.#raw.entries()) {
+        for (const { key, values } of this.#raw.values()) {
             yield [key, values.join(delim)];
         }
     }
     *entriesAll() {
-        for (const [key, values] of this.#raw.entries()) {
+        for (const { key, values } of this.#raw.values()) {
             for (const val of values) {
                 yield [key, val];
             }
         }
     }
     get(key, delim = ", ") {
-        const vals = this.#raw.get(key);
-        if (vals === undefined) {
+        const entry = this.#raw.get(key.toLowerCase());
+        if (entry === undefined) {
             return null;
         }
         else {
-            return vals.join(delim);
+            return entry.values.join(delim);
         }
     }
     getAll(key) {
-        return this.#raw.get(key) ?? [];
+        return this.#raw.get(key.toLowerCase())?.values ?? [];
     }
     has(key) {
-        return this.#raw.has(key);
+        return this.#raw.has(key.toLowerCase());
     }
-    keys() {
-        return this.#raw.keys();
+    *keys() {
+        for (const { key } of this.#raw.values()) {
+            yield key;
+        }
     }
     *values(delim = ", ") {
-        for (const vals of this.#raw.values()) {
-            yield vals.join(delim);
+        for (const { values } of this.#raw.values()) {
+            yield values.join(delim);
         }
     }
     *valuesAll() {
-        for (const vals of this.#raw.values()) {
-            yield* vals;
+        for (const { values } of this.#raw.values()) {
+            yield* values;
         }
     }
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { MhtmlHeaders } from "./headers";
+import { type MhtmlHeaders } from "./headers";
 export type { MhtmlHeaders };
 /** a file that was encoded in MHTML format */
 export interface MhtmlFile {
@@ -15,7 +15,28 @@ export interface MhtmlFile {
 export type Decoder = (lines: AsyncIterable<Uint8Array>) => AsyncIterable<Uint8Array>;
 /** options for mhtml parsing */
 export interface ParseOptions {
-    /** custom decoders for other Content-Transfer-Encodings */
+    /**
+     * custom decoders keyed by (lowercased) Content-Transfer-Encoding
+     *
+     * Use these to handle an encoding the defaults don't, or to override one. A
+     * {@link Decoder} turns the CRLF-split lines of a part into its decoded
+     * bytes; the parser strips the CRLFs when splitting, so a passthrough decoder
+     * re-emits them between lines:
+     *
+     * ```ts
+     * const crlf = new Uint8Array([13, 10]);
+     * const decoderOverrides = new Map([
+     *   ["binary", async function* (lines) {
+     *     let first = true;
+     *     for await (const line of lines) {
+     *       if (!first) yield crlf;
+     *       first = false;
+     *       yield line;
+     *     }
+     *   }],
+     * ]);
+     * ```
+     */
     decoderOverrides?: Map<string, Decoder>;
 }
 /**

package/dist/index.js

@@ -1,6 +1,6 @@
 import { toByteArray } from "base64-js";
 import { Headers } from "./headers";
-import { bytesEqual, collect, decodeBase64, decodeBinary, decodeIdentity, decodeQuotedPrintable, splitStream, } from "./utils";
+import { bytesEqual, collect, decodeBase64, decodeBinary, decodeIdentity, decodeQuotedPrintable, isHexDigit, splitStream, } from "./utils";
 // NOTE we use this for ascii because it's faster than manual, but may cause
 // unexpected errors if the assumption is violated
 const encoder = new TextEncoder();
@@ -21,9 +21,12 @@ function decodeQEncoding(text) {
         }
         else if (code === 61) {
             // encoded character
-            val = parseInt(text[++ind], 16);
-            val *= 16;
-            val += parseInt(text[++ind], 16);
+            const high = text.charCodeAt(++ind);
+            const low = text.charCodeAt(++ind);
+            if (!isHexDigit(high) || !isHexDigit(low)) {
+                throw new Error(`got invalid hex escape when decoding q-quoted word: "${text}"`);
+            }
+            val = parseInt(String.fromCharCode(high, low), 16);
         }
         else {
             // residual ascii
@@ -81,12 +84,12 @@ async function parseHeaders(iter) {
                 headers.append(key, val);
             }
             if (line) {
-                const delim = line.indexOf(": ");
+                const delim = line.indexOf(":");
                 if (delim === -1) {
                     throw new Error(`header line didn't have key-value delimiter: "${line}"`);
                 }
                 key = line.slice(0, delim);
-                val = decodeLine(line.slice(delim + 2));
+                val = decodeLine(line.slice(delim + 1).replace(/^\s+/, ""));
             }
             else {
                 return headers;
@@ -113,13 +116,16 @@ function getBoundary(headers) {
     if (contentType === null) {
         throw new Error(`first headers didn't contain a content type: ${JSON.stringify(Object.fromEntries(headers))}`);
     }
-    let bound = undefined;
+    let bound;
     let multipart = false;
     for (const field of contentType.split(/;\s*/)) {
-        if (field.startsWith("multipart/")) {
+        // the media type and the boundary parameter name are case-insensitive, but
+        // the boundary value itself is not, so match on a lowercased copy
+        const lower = field.toLowerCase();
+        if (lower.startsWith("multipart/")) {
             multipart = true;
         }
-        else if (field.startsWith("boundary=")) {
+        else if (lower.startsWith("boundary=")) {
             bound = field.slice(9);
             // TODO handling of quoted fields is not great
             if (bound.startsWith('"') && bound.endsWith('"')) {
@@ -155,7 +161,7 @@ export async function* parseMhtml(stream, { decoderOverrides = new Map() } = {})
         // parse out headers and get encoding for content
         const headers = await parseHeaders(lines);
         const [boundary, terminus] = bound ?? (bound = getBoundary(headers));
-        const encoding = headers.get("Content-Transfer-Encoding") ?? "7bit";
+        const encoding = (headers.get("Content-Transfer-Encoding") ?? "7bit").toLowerCase();
         const decode = decoders.get(encoding);
         if (decode === undefined) {
             throw new Error(`unhandled encoding type: ${encoding}`);

package/dist/index.spec.js

@@ -140,6 +140,86 @@ Subject: =?iso-8859-1?Q?=A1Hola,\xffse=F1or!?=
         // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression,@typescript-eslint/await-thenable
         await expect(consume(parser)).rejects.toThrow("got non-ascii character when decoding q-quoted word");
     });
+    test("decodes base64 wrapped at a non-multiple-of-4 column", async () => {
+        // "hello world hello world" wrapped at column 23 (not a multiple of 4)
+        const content = `MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary=frontier
+
+--frontier
+Content-Type: application/octet-stream
+Content-Transfer-Encoding: base64
+
+aGVsbG8gd29ybGQgaGVsbG8
+gd29ybGQ=
+--frontier--
+`;
+        const files = [];
+        for await (const file of parseMhtml(stringToStream(content))) {
+            files.push(file);
+        }
+        expect(decoder.decode(files[1].content)).toStrictEqual("hello world hello world");
+    });
+    test("matches header names and encodings case-insensitively", async () => {
+        const content = `mime-version: 1.0
+content-type: MULTIPART/mixed; BOUNDARY=frontier
+
+--frontier
+content-type: application/octet-stream
+content-transfer-encoding: Base64
+
+aGVsbG8gd29ybGQ=
+--frontier--
+`;
+        const files = [];
+        for await (const file of parseMhtml(stringToStream(content))) {
+            files.push(file);
+        }
+        const headers = files.map(({ headers }) => Object.fromEntries(headers));
+        expect(headers).toEqual([
+            {
+                "mime-version": "1.0",
+                "content-type": "MULTIPART/mixed; BOUNDARY=frontier",
+            },
+            {
+                "content-type": "application/octet-stream",
+                "content-transfer-encoding": "Base64",
+            },
+        ]);
+        expect(decoder.decode(files[1].content)).toStrictEqual("hello world");
+    });
+    test("accepts headers without a space after the colon", async () => {
+        const content = `MIME-Version:1.0
+Content-Type:multipart/mixed; boundary=frontier
+X-Empty:
+
+This is a message with multiple parts in MIME format.
+--frontier--
+`;
+        const files = [];
+        for await (const file of parseMhtml(stringToStream(content))) {
+            files.push(file);
+        }
+        const headers = files.map(({ headers }) => Object.fromEntries(headers));
+        expect(headers).toEqual([
+            {
+                "MIME-Version": "1.0",
+                "Content-Type": "multipart/mixed; boundary=frontier",
+                "X-Empty": "",
+            },
+        ]);
+        const text = files.map(({ content }) => decoder.decode(content));
+        expect(text).toEqual([
+            "This is a message with multiple parts in MIME format.",
+        ]);
+    });
+    test("fails on invalid hex in q-encoding", async () => {
+        const content = `MIME-Version: 1.0
+Subject: =?utf-8?Q?a=ZZb?=
+`;
+        const parser = parseMhtml(stringToStream(content));
+        // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression,@typescript-eslint/await-thenable
+        await expect(consume(parser)).rejects.toThrow("got invalid hex escape when decoding q-quoted word");
+    });
     test("fails without empty header delimiter", async () => {
         const content = `MIME-Version: 1.0`;
         const parser = parseMhtml(stringToStream(content));

package/dist/mhtml.esm.min.js

@@ -1 +1 @@
-var D=L;var g=[],Y=[],f=typeof Uint8Array!=="undefined"?Uint8Array:Array,P="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";for(Z=0,F=P.length;Z<F;++Z)g[Z]=P[Z],Y[P.charCodeAt(Z)]=Z;var Z,F;Y[45]=62;Y[95]=63;function m(G){var K=G.length;if(K%4>0)throw new Error("Invalid string. Length must be a multiple of 4");var J=G.indexOf("=");if(J===-1)J=K;var M=J===K?0:4-J%4;return[J,M]}function v(G,K,J){return(K+J)*3/4-J}function L(G){var K,J=m(G),M=J[0],R=J[1],U=new f(v(G,M,R)),V=0,W=R>0?M-4:M,X;for(X=0;X<W;X+=4)K=Y[G.charCodeAt(X)]<<18|Y[G.charCodeAt(X+1)]<<12|Y[G.charCodeAt(X+2)]<<6|Y[G.charCodeAt(X+3)],U[V++]=K>>16&255,U[V++]=K>>8&255,U[V++]=K&255;if(R===2)K=Y[G.charCodeAt(X)]<<2|Y[G.charCodeAt(X+1)]>>4,U[V++]=K&255;if(R===1)K=Y[G.charCodeAt(X)]<<10|Y[G.charCodeAt(X+1)]<<4|Y[G.charCodeAt(X+2)]>>2,U[V++]=K>>8&255,U[V++]=K&255;return U}class S{#G=new Map;[Symbol.iterator](){return this.entries()}append(G,K){let J=this.#G.get(G);if(J===void 0)this.#G.set(G,[K]);else J.push(K)}*entries(G=", "){for(let[K,J]of this.#G.entries())yield[K,J.join(G)]}*entriesAll(){for(let[G,K]of this.#G.entries())for(let J of K)yield[G,J]}get(G,K=", "){let J=this.#G.get(G);if(J===void 0)return null;else return J.join(K)}getAll(G){return this.#G.get(G)??[]}has(G){return this.#G.has(G)}keys(){return this.#G.keys()}*values(G=", "){for(let K of this.#G.values())yield K.join(G)}*valuesAll(){for(let G of this.#G.values())yield*G}}function _(G,K){if(G.length!==K.length)return!1;else if(G.byteOffset%4===K.byteOffset%4){let J=(4-G.byteOffset%4)%4,M=Math.floor((G.byteLength-J)/4),R=J+M*4,U=new Uint32Array(G.buffer,G.byteOffset+J,M),V=new Uint32Array(K.buffer,K.byteOffset+J,M);for(let W=0;W<J;++W)if(G[W]!==K[W])return!1;for(let W=0;W<M;++W)if(U[W]!==V[W])return!1;for(let W=R;W<G.length;++W)if(G[W]!==K[W])return!1;return!0}else{for(let J of G.keys())if(G[J]!==K[J])return!1;return!0}}function h(G,K){return G.findIndex((J,M)=>{if(J!==K[0]||M+K.length>G.length)return!1;else{for(let R=1;R<K.length;++R)if(G[M+R]!==K[R])return!1;return!0}})}async function*Q(G,K){let J=new Uint8Array(0);for await(let M of G){J=J.length?E([J,M]):M;let R;while((R=h(J,K))!==-1)yield J.subarray(0,R),J=J.subarray(R+K.length)}yield J}function E(G){let K=G.reduce((R,U)=>R+U.length,0),J=new Uint8Array(K),M=0;for(let R of G)J.set(R,M),M+=R.length;return J}async function O(G){let K=[];for await(let J of G)K.push(J);return E(K)}var k=new Uint8Array([10]);async function*T(G,K=k){for await(let J of G){let M=new Uint8Array(J.length+K.length),R=!1,U=0;for(let V=0;V<J.length;++V){let W=J[V];if(W>=128)throw new Error(`got non-ascii character when decoding quoted printable: ${W}`);if(W!==61)M[U++]=W;else{let X=J[++V];if(X===void 0)R=!0;else{let z=J[++V];if(z===void 0)throw new Error("quoted printable escape (=) was not followed by two bytes");let $=parseInt(String.fromCharCode(X),16);$*=16,$+=parseInt(String.fromCharCode(z),16),M[U++]=$}}}if(!R)M.set(K,U),U+=K.length;yield M.subarray(0,U)}}var y=new TextDecoder;async function*C(G){for await(let K of G)yield D(y.decode(K))}async function*j(G){for await(let K of G)yield K}function A(){throw new Error("binary transfer-encoding is explicitly not supported and trying to add an implementation will likely result in unexpected results, but if you want to ignore anyway, set binary to `decode8bit`")}var I=new TextEncoder,B=new TextDecoder;function b(G){let K=new Uint8Array(G.length),J=0;for(let M=0;M<G.length;++M){let R=G.charCodeAt(M),U;if(R>=128)throw new Error(`got non-ascii character when decoding q-quoted word: "${G}"`);else if(R===95)U=32;else if(R===61)U=parseInt(G[++M],16),U*=16,U+=parseInt(G[++M],16);else U=R;K[J++]=U}return K.subarray(0,J)}var p=/^=\?([^?\s]+)\?([BQ])\?([^?\s]+)\?=$/;function H(G){let K=p.exec(G);if(K){let[,J,M,R]=K,U;if(M==="Q")U=b(R);else U=D(R);return new TextDecoder(J).decode(U)}else return G}async function c(G){let K=new S,J="",M="";for(;;){let{done:R,value:U}=await G.next();if(R)throw new Error("didn't find an empty line to signify the end of header parsing");let V=B.decode(U);if(/^\s/.test(V))M+=H(V.substring(1));else{if(J)K.append(J,M);if(V){let W=V.indexOf(": ");if(W===-1)throw new Error(`header line didn't have key-value delimiter: "${V}"`);J=V.slice(0,W),M=H(V.slice(W+2))}else return K}}}var u=new Map([["7bit",j],["base64",C],["quoted-printable",T],["8bit",j],["binary",A]]);function s(G){let K=G.get("Content-Type");if(K===null)throw new Error(`first headers didn't contain a content type: ${JSON.stringify(Object.fromEntries(G))}`);let J=void 0,M=!1;for(let V of K.split(/;\s*/))if(V.startsWith("multipart/"))M=!0;else if(V.startsWith("boundary=")){if(J=V.slice(9),J.startsWith('"')&&J.endsWith('"'))J=J.slice(1,-1)}if(!M||J===void 0)throw new Error("first content type header didn't contain 'multipart/...' and a boundary string");let R=I.encode(`--${J}`),U=I.encode(`--${J}--`);return[R,U]}async function*e(G,{decoderOverrides:K=new Map}={}){let J=new Map([...u.entries(),...K.entries()]),M=new Uint8Array([13,10]),R=Q(G,M),U=null,V=!0;while(V){let W=await c(R),[X,z]=U??(U=s(W)),$=W.get("Content-Transfer-Encoding")??"7bit",q=J.get($);if(q===void 0)throw new Error(`unhandled encoding type: ${$}`);let w=await O(q({[Symbol.asyncIterator](){return{async next(){let{done:x,value:N}=await R.next();if(x)throw new Error(`stream didn't end with the appropriate termination boundary: ${B.decode(z)}`);else if(_(N,X))return{done:!0,value:void 0};else if(_(N,z))return V=!1,{done:!0,value:void 0};else return{value:N}}}}}));yield{headers:W,content:w}}}export{e as parseMhtml};
+var R=k;var m=[],Z=[],f=typeof Uint8Array<"u"?Uint8Array:Array,j="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";for($=0,q=j.length;$<q;++$)m[$]=j[$],Z[j.charCodeAt($)]=$;var $,q;Z[45]=62;Z[95]=63;function L(G){var J=G.length;if(J%4>0)throw Error("Invalid string. Length must be a multiple of 4");var K=G.indexOf("=");if(K===-1)K=J;var M=K===J?0:4-K%4;return[K,M]}function h(G,J,K){return(J+K)*3/4-K}function k(G){var J,K=L(G),M=K[0],U=K[1],W=new f(h(G,M,U)),X=0,V=U>0?M-4:M,Y;for(Y=0;Y<V;Y+=4)J=Z[G.charCodeAt(Y)]<<18|Z[G.charCodeAt(Y+1)]<<12|Z[G.charCodeAt(Y+2)]<<6|Z[G.charCodeAt(Y+3)],W[X++]=J>>16&255,W[X++]=J>>8&255,W[X++]=J&255;if(U===2)J=Z[G.charCodeAt(Y)]<<2|Z[G.charCodeAt(Y+1)]>>4,W[X++]=J&255;if(U===1)J=Z[G.charCodeAt(Y)]<<10|Z[G.charCodeAt(Y+1)]<<4|Z[G.charCodeAt(Y+2)]>>2,W[X++]=J>>8&255,W[X++]=J&255;return W}class Q{#G=new Map;[Symbol.iterator](){return this.entries()}append(G,J){let K=this.#G.get(G.toLowerCase());if(K===void 0)this.#G.set(G.toLowerCase(),{key:G,values:[J]});else K.values.push(J)}*entries(G=", "){for(let{key:J,values:K}of this.#G.values())yield[J,K.join(G)]}*entriesAll(){for(let{key:G,values:J}of this.#G.values())for(let K of J)yield[G,K]}get(G,J=", "){let K=this.#G.get(G.toLowerCase());if(K===void 0)return null;else return K.values.join(J)}getAll(G){return this.#G.get(G.toLowerCase())?.values??[]}has(G){return this.#G.has(G.toLowerCase())}*keys(){for(let{key:G}of this.#G.values())yield G}*values(G=", "){for(let{values:J}of this.#G.values())yield J.join(G)}*valuesAll(){for(let{values:G}of this.#G.values())yield*G}}function E(G,J){if(G.length!==J.length)return!1;else if(G.byteOffset%4===J.byteOffset%4){let K=(4-G.byteOffset%4)%4,M=Math.floor((G.byteLength-K)/4),U=K+M*4,W=new Uint32Array(G.buffer,G.byteOffset+K,M),X=new Uint32Array(J.buffer,J.byteOffset+K,M);for(let V=0;V<K;++V)if(G[V]!==J[V])return!1;for(let V=0;V<M;++V)if(W[V]!==X[V])return!1;for(let V=U;V<G.length;++V)if(G[V]!==J[V])return!1;return!0}else{for(let K of G.keys())if(G[K]!==J[K])return!1;return!0}}function b(G,J){return G.findIndex((K,M)=>{if(K!==J[0]||M+J.length>G.length)return!1;else{for(let U=1;U<J.length;++U)if(G[M+U]!==J[U])return!1;return!0}})}async function*O(G,J){let K=new Uint8Array(0);for await(let M of G){K=K.length?T([K,M]):M;let U;while((U=b(K,J))!==-1)yield K.subarray(0,U),K=K.subarray(U+J.length)}yield K}function T(G){let J=G.reduce((U,W)=>U+W.length,0),K=new Uint8Array(J),M=0;for(let U of G)K.set(U,M),M+=U.length;return K}async function C(G){let J=[];for await(let K of G)J.push(K);return T(J)}var D=new Uint8Array([13,10]);function S(G){return G>=48&&G<=57||G>=65&&G<=70||G>=97&&G<=102}async function*A(G,J=D){let K=!1;for await(let M of G){let U=new Uint8Array(M.length+J.length),W=0;if(K)U.set(J,W),W+=J.length,K=!1;let X=!1;for(let V=0;V<M.length;++V){let Y=M[V];if(Y>=128)throw Error(`got non-ascii character when decoding quoted printable: ${Y}`);if(Y!==61)U[W++]=Y;else{let z=M[++V];if(z===void 0)X=!0;else{let P=M[++V];if(P===void 0)throw Error("quoted printable escape (=) was not followed by two bytes");else if(!S(z)||!S(P))throw Error(`quoted printable escape (=) was not followed by two hex digits: "=${String.fromCharCode(z,P)}"`);U[W++]=parseInt(String.fromCharCode(z,P),16)}}}if(!X)K=!0;yield U.subarray(0,W)}}var y=new TextDecoder;async function*I(G){let J="";for await(let K of G){J+=y.decode(K).replace(/\s/g,"");let M=J.length-J.length%4;if(M>0)yield R(J.slice(0,M)),J=J.slice(M)}if(J.length>0)yield R(J)}async function*F(G,J=D){let K=!0;for await(let M of G){if(K)K=!1;else yield J;yield M}}function H(){throw Error("binary transfer-encoding is explicitly not supported and trying to add an implementation will likely result in unexpected results, but if you want to handle it anyway, override `binary` in `decoderOverrides`")}var B=new TextEncoder,x=new TextDecoder;function p(G){let J=new Uint8Array(G.length),K=0;for(let M=0;M<G.length;++M){let U=G.charCodeAt(M),W;if(U>=128)throw Error(`got non-ascii character when decoding q-quoted word: "${G}"`);else if(U===95)W=32;else if(U===61){let X=G.charCodeAt(++M),V=G.charCodeAt(++M);if(!S(X)||!S(V))throw Error(`got invalid hex escape when decoding q-quoted word: "${G}"`);W=parseInt(String.fromCharCode(X,V),16)}else W=U;J[K++]=W}return J.subarray(0,K)}var c=/^=\?([^?\s]+)\?([BQ])\?([^?\s]+)\?=$/;function w(G){let J=c.exec(G);if(J){let[,K,M,U]=J,W;if(M==="Q")W=p(U);else W=R(U);return new TextDecoder(K).decode(W)}else return G}async function u(G){let J=new Q,K="",M="";for(;;){let{done:U,value:W}=await G.next();if(U)throw Error("didn't find an empty line to signify the end of header parsing");let X=x.decode(W);if(/^\s/.test(X))M+=w(X.substring(1));else{if(K)J.append(K,M);if(X){let V=X.indexOf(":");if(V===-1)throw Error(`header line didn't have key-value delimiter: "${X}"`);K=X.slice(0,V),M=w(X.slice(V+1).replace(/^\s+/,""))}else return J}}}var a=new Map([["7bit",F],["base64",I],["quoted-printable",A],["8bit",F],["binary",H]]);function s(G){let J=G.get("Content-Type");if(J===null)throw Error(`first headers didn't contain a content type: ${JSON.stringify(Object.fromEntries(G))}`);let K,M=!1;for(let X of J.split(/;\s*/)){let V=X.toLowerCase();if(V.startsWith("multipart/"))M=!0;else if(V.startsWith("boundary=")){if(K=X.slice(9),K.startsWith('"')&&K.endsWith('"'))K=K.slice(1,-1)}}if(!M||K===void 0)throw Error("first content type header didn't contain 'multipart/...' and a boundary string");let U=B.encode(`--${K}`),W=B.encode(`--${K}--`);return[U,W]}async function*e(G,{decoderOverrides:J=new Map}={}){let K=new Map([...a.entries(),...J.entries()]),M=new Uint8Array([13,10]),U=O(G,M),W=null,X=!0;while(X){let V=await u(U),[Y,z]=W??(W=s(V)),P=(V.get("Content-Transfer-Encoding")??"7bit").toLowerCase(),N=K.get(P);if(N===void 0)throw Error(`unhandled encoding type: ${P}`);let g=await C(N({[Symbol.asyncIterator](){return{async next(){let{done:v,value:_}=await U.next();if(v)throw Error(`stream didn't end with the appropriate termination boundary: ${x.decode(z)}`);else if(E(_,Y))return{done:!0,value:void 0};else if(E(_,z))return X=!1,{done:!0,value:void 0};else return{value:_}}}}}));yield{headers:V,content:g}}}export{e as parseMhtml};

package/dist/utils.d.ts

@@ -18,21 +18,38 @@ export declare function splitStream(iter: AsyncIterable<Uint8Array>, split: Uint
  * collect an async iterable of buffers into one
  */
 export declare function collect(stream: AsyncIterable<Uint8Array>): Promise<Uint8Array>;
+/** whether a character code is a hex digit (0-9, A-F, a-f) */
+export declare function isHexDigit(code: number): boolean;
 /**
  * decoder for quoted printable
  *
  * If quoted printable "lines" aren't escaped with an "=" then a new line needs
- * to be inserted. We use `newLine` which defaults to a single "\n".
+ * to be inserted. We use `newLine`, which defaults to CRLF to match the
+ * canonical MIME form; pass a custom separator (e.g. a single "\n") to
+ * normalize instead. The separator goes between lines; the CRLF before the MIME
+ * boundary belongs to the delimiter, not the body.
  */
 export declare function decodeQuotedPrintable(lines: AsyncIterable<Uint8Array>, newLine?: Uint8Array): AsyncIterableIterator<Uint8Array>;
 /**
  * decoder for base64
+ *
+ * RFC 2045 requires decoders to ignore line breaks and decode the concatenated
+ * stream, so producers may wrap at any column. We strip whitespace and buffer
+ * characters that don't yet form a complete four-character quantum, flushing
+ * the remainder at the end of the part.
  */
 export declare function decodeBase64(lines: AsyncIterable<Uint8Array>): AsyncIterableIterator<Uint8Array>;
 /**
  * decoder for 7bit and 8bit
- */
-export declare function decodeIdentity(lines: AsyncIterable<Uint8Array>): AsyncIterableIterator<Uint8Array>;
+ *
+ * 7bit/8bit apply no transfer transformation, so the content bytes are the
+ * payload as-is. parseMhtml splits the stream on CRLF to find part boundaries,
+ * so we re-insert `newLine` (defaulting to CRLF) between lines to restore the
+ * original bytes exactly. Pass `newLine` (e.g. a single "\n") to normalize line
+ * endings instead. The separator goes between lines; the CRLF before the
+ * boundary belongs to the delimiter, not the body.
+ */
+export declare function decodeIdentity(lines: AsyncIterable<Uint8Array>, newLine?: Uint8Array): AsyncIterableIterator<Uint8Array>;
 /**
  * decoder for binary
  *

package/dist/utils.js

@@ -77,7 +77,9 @@ export function indexOf(haystack, needle) {
 export async function* splitStream(iter, split) {
     let current = new Uint8Array(0);
     for await (const chunk of iter) {
-        current = current.length ? concat([current, chunk]) : chunk;
+        current = current.length
+            ? concat([current, chunk])
+            : chunk;
         let nextInd;
         while ((nextInd = indexOf(current, split)) !== -1) {
             yield current.subarray(0, nextInd);
@@ -109,19 +111,33 @@ export async function collect(stream) {
     }
     return concat(chunks);
 }
-// default new line character for quoted printable decoding
-const defaultNewLine = new Uint8Array([10]);
+const crlf = new Uint8Array([13, 10]);
+/** whether a character code is a hex digit (0-9, A-F, a-f) */
+export function isHexDigit(code) {
+    return ((code >= 48 && code <= 57) ||
+        (code >= 65 && code <= 70) ||
+        (code >= 97 && code <= 102));
+}
 /**
  * decoder for quoted printable
  *
  * If quoted printable "lines" aren't escaped with an "=" then a new line needs
- * to be inserted. We use `newLine` which defaults to a single "\n".
+ * to be inserted. We use `newLine`, which defaults to CRLF to match the
+ * canonical MIME form; pass a custom separator (e.g. a single "\n") to
+ * normalize instead. The separator goes between lines; the CRLF before the MIME
+ * boundary belongs to the delimiter, not the body.
  */
-export async function* decodeQuotedPrintable(lines, newLine = defaultNewLine) {
+export async function* decodeQuotedPrintable(lines, newLine = crlf) {
+    let pendingNewLine = false; // a hard line break from the previous line
     for await (const bytes of lines) {
         const res = new Uint8Array(bytes.length + newLine.length);
-        let softLine = false; // if newline wasn't escaped so we need to add
         let destInd = 0;
+        if (pendingNewLine) {
+            res.set(newLine, destInd);
+            destInd += newLine.length;
+            pendingNewLine = false;
+        }
+        let softLine = false; // if newline was escaped, so we shouldn't add one
         for (let ind = 0; ind < bytes.length; ++ind) {
             const code = bytes[ind];
             if (code >= 128) {
@@ -142,16 +158,15 @@ export async function* decodeQuotedPrintable(lines, newLine = defaultNewLine) {
                     if (second === undefined) {
                         throw new Error("quoted printable escape (=) was not followed by two bytes");
                     }
-                    let val = parseInt(String.fromCharCode(first), 16);
-                    val *= 16;
-                    val += parseInt(String.fromCharCode(second), 16);
-                    res[destInd++] = val;
+                    else if (!isHexDigit(first) || !isHexDigit(second)) {
+                        throw new Error(`quoted printable escape (=) was not followed by two hex digits: "=${String.fromCharCode(first, second)}"`);
+                    }
+                    res[destInd++] = parseInt(String.fromCharCode(first, second), 16);
                 }
             }
         }
         if (!softLine) {
-            res.set(newLine, destInd);
-            destInd += newLine.length;
+            pendingNewLine = true;
         }
         yield res.subarray(0, destInd);
     }
@@ -159,17 +174,45 @@ export async function* decodeQuotedPrintable(lines, newLine = defaultNewLine) {
 const decoder = new TextDecoder();
 /**
  * decoder for base64
+ *
+ * RFC 2045 requires decoders to ignore line breaks and decode the concatenated
+ * stream, so producers may wrap at any column. We strip whitespace and buffer
+ * characters that don't yet form a complete four-character quantum, flushing
+ * the remainder at the end of the part.
  */
 export async function* decodeBase64(lines) {
+    let residual = "";
     for await (const bytes of lines) {
-        yield toByteArray(decoder.decode(bytes));
+        residual += decoder.decode(bytes).replace(/\s/g, "");
+        const usable = residual.length - (residual.length % 4);
+        if (usable > 0) {
+            yield toByteArray(residual.slice(0, usable));
+            residual = residual.slice(usable);
+        }
+    }
+    if (residual.length > 0) {
+        yield toByteArray(residual);
     }
 }
 /**
  * decoder for 7bit and 8bit
+ *
+ * 7bit/8bit apply no transfer transformation, so the content bytes are the
+ * payload as-is. parseMhtml splits the stream on CRLF to find part boundaries,
+ * so we re-insert `newLine` (defaulting to CRLF) between lines to restore the
+ * original bytes exactly. Pass `newLine` (e.g. a single "\n") to normalize line
+ * endings instead. The separator goes between lines; the CRLF before the
+ * boundary belongs to the delimiter, not the body.
  */
-export async function* decodeIdentity(lines) {
+export async function* decodeIdentity(lines, newLine = crlf) {
+    let first = true;
     for await (const bytes of lines) {
+        if (first) {
+            first = false;
+        }
+        else {
+            yield newLine;
+        }
         yield bytes;
     }
 }
@@ -180,5 +223,5 @@ export async function* decodeIdentity(lines) {
  * error.
  */
 export function decodeBinary() {
-    throw new Error("binary transfer-encoding is explicitly not supported and trying to add an implementation will likely result in unexpected results, but if you want to ignore anyway, set binary to `decode8bit`");
+    throw new Error("binary transfer-encoding is explicitly not supported and trying to add an implementation will likely result in unexpected results, but if you want to handle it anyway, override `binary` in `decoderOverrides`");
 }

package/dist/utils.spec.js

@@ -115,7 +115,13 @@ describe("decodeQuotedPrintable()", () => {
         // eslint-disable-next-line spellcheck/spell-checker
         const input = ["key=3Dvalue", "this line continues =", "on the next line"];
         const res = decoder.decode(await collect(decodeQuotedPrintable(toAsyncIterable(input.map((l) => encoder.encode(l))))));
-        expect(res).toStrictEqual("key=value\nthis line continues on the next line\n");
+        expect(res).toStrictEqual("key=value\r\nthis line continues on the next line");
+    });
+    test("normalizes to a custom separator when given one", async () => {
+        // eslint-disable-next-line spellcheck/spell-checker
+        const input = ["key=3Dvalue", "this line continues =", "on the next line"];
+        const res = decoder.decode(await collect(decodeQuotedPrintable(toAsyncIterable(input.map((l) => encoder.encode(l))), new Uint8Array([10]))));
+        expect(res).toStrictEqual("key=value\nthis line continues on the next line");
     });
     test("ascii failure", async () => {
         const input = ["\xff"];
@@ -137,11 +143,33 @@ describe("decodeQuotedPrintable()", () => {
             }
         })()).rejects.toThrow("quoted printable escape");
     });
+    test("non-hex escape failure", async () => {
+        const input = ["a=ZZb"];
+        const decoded = decodeQuotedPrintable(toAsyncIterable(input.map((l) => encoder.encode(l))));
+        // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression,@typescript-eslint/await-thenable
+        await expect((async () => {
+            for await (const _ of decoded) {
+                //
+            }
+        })()).rejects.toThrow("two hex digits");
+    });
 });
-test("decodeIdentity()", async () => {
-    const input = ["line ", "not ascii \xff"];
-    const res = decoder.decode(await collect(decodeIdentity(toAsyncIterable(input.map((l) => encoder.encode(l))))));
-    expect(res).toStrictEqual("line not ascii \xff");
+describe("decodeIdentity()", () => {
+    test("passes bytes through", async () => {
+        const input = ["line ", "not ascii \xff"];
+        const res = decoder.decode(await collect(decodeIdentity(toAsyncIterable(input.map((l) => encoder.encode(l))))));
+        expect(res).toStrictEqual("line \r\nnot ascii \xff");
+    });
+    test("reinserts CRLF between lines", async () => {
+        const input = ["line one", "line two", "line three"];
+        const res = decoder.decode(await collect(decodeIdentity(toAsyncIterable(input.map((l) => encoder.encode(l))))));
+        expect(res).toStrictEqual("line one\r\nline two\r\nline three");
+    });
+    test("normalizes to a custom separator when given one", async () => {
+        const input = ["line one", "line two"];
+        const res = decoder.decode(await collect(decodeIdentity(toAsyncIterable(input.map((l) => encoder.encode(l))), new Uint8Array([10]))));
+        expect(res).toStrictEqual("line one\nline two");
+    });
 });
 test("decodeBinary()", () => {
     expect(decodeBinary).toThrow("explicitly");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mhtml-stream",
-  "version": "2.0.1",
-  "description": "Zero dependency stream MHTML parser",
+  "version": "3.0.0",
+  "description": "Streaming MHTML parser",
   "keywords": [
     "mhtml",
     "stream"
@@ -10,90 +10,42 @@
     "type": "git",
     "url": "git+https://github.com/erikbrinkman/mhtml-stream.git"
   },
+  "homepage": "https://erikbrinkman.github.io/mhtml-stream/",
   "author": "Erik Brinkman <erik.brinkman@gmail.com>",
   "license": "MIT",
   "type": "module",
+  "sideEffects": false,
   "types": "dist/index.d.ts",
   "module": "dist/mhtml.esm.min.js",
-  "exports": "./dist/mhtml.esm.min.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/mhtml.esm.min.js"
+    }
+  },
   "files": [
     "/dist/**/*.js",
     "/dist/**/*.d.ts"
   ],
   "scripts": {
     "cli": "bun src/cli.ts",
-    "fmt": "prettier --cache --write 'src/*.ts' '*.{js,json}'",
-    "lint": "tsc && eslint --cache 'src/*.ts' && typedoc --emit none",
+    "fmt": "biome format --write",
+    "lint": "tsc && biome check && typedoc --emit none",
     "doc": "typedoc",
     "export": "tsc -p tsconfig.build.json && bun build src/index.ts --minify --outfile dist/mhtml.esm.min.js",
-    "prepack": "bun lint && bun test --coverage && bun export"
+    "prepack": "bun lint && bun test --coverage && bun export && publint"
   },
   "dependencies": {
     "base64-js": "^1.5.1"
   },
   "devDependencies": {
-    "@types/base64-js": "^1.3.2",
-    "@types/bun": "^1.1.14",
-    "@types/yargs": "^17.0.33",
-    "eslint": "^9.17.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-spellcheck": "^0.0.20",
-    "eslint-plugin-tsdoc": "^0.4.0",
-    "prettier": "^3.4.2",
-    "prettier-plugin-organize-imports": "^4.1.0",
-    "typedoc": "^0.27.5",
-    "typescript": "^5.7.2",
-    "typescript-eslint": "^8.18.1",
-    "yargs": "^17.7.2"
-  },
-  "eslintConfig": {
-    "rules": {
-      "@typescript-eslint/no-inferrable-types": "off",
-      "@typescript-eslint/no-non-null-assertion": "off",
-      "@typescript-eslint/no-unused-vars": [
-        "error",
-        {
-          "varsIgnorePattern": "^_+$"
-        }
-      ],
-      "prefer-const": [
-        "error",
-        {
-          "destructuring": "all"
-        }
-      ],
-      "no-warning-comments": [
-        "error",
-        {
-          "terms": [
-            "fixme"
-          ],
-          "location": "anywhere"
-        }
-      ],
-      "spellcheck/spell-checker": [
-        "error",
-        {
-          "identifiers": false,
-          "skipIfMatch": [
-            "[^\\s]{20,}"
-          ],
-          "skipWords": [
-            "0x7fffffff",
-            "Chr",
-            "Dvalue",
-            "Hola",
-            "Mhtml",
-            "Today’s",
-            "Uint",
-            "Yorker",
-            "ascii",
-            "delim",
-            "multipart",
-            "versa"
-          ]
-        }
-      ]
-    }
+    "@biomejs/biome": "^2.4.15",
+    "@types/base64-js": "^1.5.0",
+    "@types/bun": "^1.3.14",
+    "@types/yargs": "^17.0.35",
+    "publint": "^0.3.21",
+    "typedoc": "^0.28.19",
+    "typescript": "~6.0.3",
+    "yargs": "^18.0.0"
   }
 }