@mavogel/awscdk-rootmail 0.1.24 → 0.1.26

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/codec-v1/JsonShapeSerializer.d.ts

@@ -0,0 +1,29 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import { Schema, ShapeSerializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { JsonSettings } from "./JsonSettings";
+/**
+ * @deprecated prefer byte-targeting JsonShapeSerializer or its string adapter StringJsonShapeSerializer in codec-v2.
+ * @public
+ */
+export declare class JsonShapeSerializer extends SerdeContextConfig implements ShapeSerializer<string> {
+    readonly settings: JsonSettings;
+    /**
+     * Write buffer. Reused per value serialization pass.
+     * In the initial implementation, this is not an incremental buffer.
+     */
+    protected buffer: any;
+    protected useReplacer: boolean;
+    protected rootSchema: NormalizedSchema | undefined;
+    constructor(settings: JsonSettings);
+    write(schema: Schema, value: unknown): void;
+    flush(): string;
+    /**
+     * @internal
+     */
+    writeDiscriminatedDocument(schema: Schema, value: unknown): void;
+    /**
+     * Order if-statements by likelihood.
+     */
+    protected _write(schema: Schema, value: unknown, container?: NormalizedSchema): any;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/codec-v2/JsonBytesStringAdapter.d.ts

@@ -0,0 +1,51 @@
+/**
+ * A Uint8Array subclass holding serialized JSON bytes that provides
+ * string method compatibility for customer middleware.
+ *
+ * Middleware historically observed `request.body` as a string for JSON
+ * protocol services. This class preserves that contract: string methods
+ * and coercion (template literals, `+` operator) lazily decode the bytes
+ * to a cached string. The HTTP transport layer still sees a Uint8Array
+ * and sends raw bytes without conversion.
+ *
+ * @internal
+ * @deprecated this adapter will be removed in a future version.
+ */
+export declare class JsonBytesStringAdapter extends Uint8Array {
+    private string;
+    static allocUnsafe(bytes: number): JsonBytesStringAdapter;
+    /**
+     * Enables string coercion via template literals and `+` operator.
+     */
+    toString(): string;
+    /**
+     * Enables string coercion in comparison and arithmetic contexts.
+     * @returns a string. The signature is set to avoid incompatibility with extending Uint8Array.
+     */
+    valueOf(): any;
+    includes(searchString: string | number, position?: number): boolean;
+    indexOf(searchString: string | number, position?: number): number;
+    lastIndexOf(searchString: string | number, position?: number): number;
+    startsWith(searchString: string, position?: number): boolean;
+    endsWith(searchString: string, endPosition?: number): boolean;
+    match(regexp: string | RegExp): RegExpMatchArray | null;
+    replace(searchValue: string | RegExp, replaceValue: string): string;
+    search(regexp: string | RegExp): number;
+    split(separator: string | RegExp, limit?: number): string[];
+    substring(start: number, end?: number): string;
+    trim(): string;
+    trimStart(): string;
+    trimEnd(): string;
+    charAt(pos: number): string;
+    charCodeAt(index: number): number;
+    padStart(maxLength: number, fillString?: string): string;
+    padEnd(maxLength: number, fillString?: string): string;
+    repeat(count: number): string;
+    toUpperCase(): string;
+    toLowerCase(): string;
+    /**
+     * Decodes the bytes to a UTF-8 string on first access, then caches.
+     * Subsequent calls return the cached string with zero cost.
+     */
+    private s;
+}

package/node_modules/{@aws-sdk → @smithy}/core/dist-types/ts3.4/submodules/protocols/json/codec-v2/JsonCodec2.d.ts

@@ -1,9 +1,13 @@
-import { $ShapeSerializer, $Codec, $ShapeDeserializer } from "@smithy/types";
-import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
-import { JsonSettings } from "../JsonSettings";
-export declare class JsonCodec2 extends SerdeContextConfig implements $Codec<Uint8Array, string> {
-  readonly settings: JsonSettings;
-  constructor(settings: JsonSettings);
-  createSerializer(): $ShapeSerializer<Uint8Array>;
-  createDeserializer(): $ShapeDeserializer<string>;
-}
+import { $ShapeSerializer, $Codec, $ShapeDeserializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { JsonSettings } from "../JsonSettings";
+/**
+ * Codec grouping the v2 serializer and deserializer.
+ * @public
+ */
+export declare class JsonCodec2 extends SerdeContextConfig implements $Codec<Uint8Array, string> {
+    readonly settings: JsonSettings;
+    constructor(settings: JsonSettings);
+    createSerializer(): $ShapeSerializer<Uint8Array>;
+    createDeserializer(): $ShapeDeserializer<string>;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/codec-v2/JsonShapeDeserializer2.d.ts

@@ -0,0 +1,30 @@
+import { DocumentType, Schema, ShapeDeserializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { JsonSettings } from "../JsonSettings";
+/**
+ * Performance-optimized JSON deserializer.
+ *
+ * Skips UTF-8 decoding when the runtime supports JSON.parse(Buffer) (Node 22+).
+ *
+ * After JSON.parse, lists, maps, and document containers are mutated in place
+ * (element values are overwritten with their deserialized form) rather than
+ * copied into new arrays/objects. Structs allocate a fresh object because
+ * jsonName traits require key renaming, and building the output object
+ * incrementally lets V8 assign a stable hidden class rather than
+ * deoptimizing from repeated property deletion/addition on an existing shape.
+ *
+ * In-place mutation is safe here because the parsed tree is locally owned
+ * after JSON.parse with no external references, so rewriting values avoids
+ * redundant allocation and GC pressure.
+ *
+ * @public
+ */
+export declare class JsonShapeDeserializer2 extends SerdeContextConfig implements ShapeDeserializer<string> {
+    readonly settings: JsonSettings;
+    constructor(settings: JsonSettings);
+    read(schema: Schema, data: string | Uint8Array | unknown): Promise<any>;
+    readObject(schema: Schema, data: DocumentType): any;
+    protected _read(schema: Schema, value: unknown): any;
+    private _readStruct;
+    private needsTransform;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/codec-v2/JsonShapeSerializer2.d.ts

@@ -0,0 +1,60 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import { Schema, ShapeSerializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { JsonSettings } from "../JsonSettings";
+/**
+ * Single-pass JSON serializer that writes directly to a Uint8Array buffer.
+ * Fewer intermediate states as when compared to the initial multi-pass implementation.
+ *
+ * @public
+ */
+export declare class JsonShapeSerializer2 extends SerdeContextConfig implements ShapeSerializer<Uint8Array> {
+    readonly settings: JsonSettings;
+    private json;
+    private i;
+    private rootSchema;
+    private rawValue;
+    private passthrough;
+    constructor(settings: JsonSettings);
+    write(schema: Schema, value: unknown): void;
+    /**
+     * @internal
+     */
+    writeDiscriminatedDocument(schema: Schema, value: unknown): void;
+    /**
+     * Returns the serialized JSON as a Uint8Array (UTF-8 bytes).
+     * This is the primary output — pass directly to request.body.
+     */
+    flush(): Uint8Array;
+    protected ensure(byteCount: number): void;
+    /**
+     * Write a raw ASCII string (no JSON escaping). Used for pre-validated content
+     * like numeric literals and pre-encoded base64.
+     */
+    protected writeAscii(s: string): void;
+    /**
+     * Write a quoted ASCII string with no escape checking.
+     * Used for struct member keys (jsonName or model names) which are
+     * guaranteed to be safe ASCII identifiers. No control chars, quotes,
+     * backslashes, or non-ASCII.
+     * Ensures extra room for surrounding structural chars (comma, colon).
+     */
+    protected writeAsciiQuoted(s: string): void;
+    /**
+     * Write a JSON-escaped string including the surrounding quotes.
+     * Fast-path for ASCII, falls back to TextEncoder for multi-byte.
+     */
+    protected writeJsonString(s: string): void;
+    protected writeUnicodeEscape(code: number): void;
+    protected static readonly B64: Uint8Array;
+    /**
+     * Write a Uint8Array as a quoted base64 string directly into the buffer.
+     * No intermediate JS string, no escape checking (base64 alphabet is safe ASCII).
+     */
+    protected writeBase64(data: Uint8Array): void;
+    protected writeValue(schema: Schema, value: unknown, container: NormalizedSchema | undefined): void;
+    protected writeStruct(ns: NormalizedSchema, value: Record<string, unknown>): void;
+    protected writeList(ns: NormalizedSchema, value: unknown[], isDocument?: boolean): void;
+    protected writeMap(ns: NormalizedSchema, value: Record<string, unknown>, isDocument?: boolean): void;
+    protected writeTimestamp(ns: NormalizedSchema, value: Date): void;
+}

package/node_modules/{@aws-sdk → @smithy}/core/dist-types/ts3.4/submodules/protocols/json/detectBufferParsing.d.ts

@@ -1 +1 @@
-export declare function detectBufferParsing(): boolean;
+export declare function detectBufferParsing(): boolean;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/jsonReplacer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Serializes BigInt and NumericValue to JSON-number.
+ * @internal
+ */
+export declare class JsonReplacer {
+    /**
+     * Stores placeholder key to true serialized value lookup.
+     */
+    private readonly values;
+    private counter;
+    private stage;
+    /**
+     * Creates a jsonReplacer function that reserves big integer and big decimal values
+     * for later replacement.
+     */
+    createReplacer(): (key: string, value: unknown) => unknown;
+    /**
+     * Replaces placeholder keys with their true values.
+     */
+    replaceInJson(json: string): string;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/jsonReviver.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param key - JSON object key.
+ * @param value - parsed value.
+ * @param context - original JSON string for reference. Not available until Node.js 21 and unavailable in Safari as
+ * of April 2025.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#browser_compatibility
+ *
+ * @internal
+ *
+ * @returns transformed value.
+ */
+export declare function jsonReviver(key: string, value: any, context?: {
+    source?: string;
+}): any;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/needsReviver.d.ts

@@ -0,0 +1,11 @@
+import { Schema } from "@smithy/types";
+/**
+ * Determines whether a schema tree contains BigInteger or BigDecimal members,
+ * which require a JSON.parse reviver to preserve numeric precision.
+ *
+ * The result is cached on the root static schema array (struct schemas) via a Symbol key,
+ * so subsequent calls for the same schema are O(1).
+ *
+ * @internal
+ */
+export declare function needsReviver(schema: Schema): boolean;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/parseJsonBody.d.ts

@@ -0,0 +1,38 @@
+import { HttpResponse, Schema, SerdeFunctions } from "@smithy/types";
+/**
+ * @deprecated new calls to parseJsonBody must pass schema.
+ * @internal
+ */
+export declare function parseJsonBody(streamBody: any, context: SerdeFunctions): Promise<any>;
+/**
+ * @internal
+ */
+export declare function parseJsonBody(streamBody: any, context: SerdeFunctions, schema: Schema): Promise<any>;
+/**
+ * @internal
+ */
+export declare const parseJsonErrorBody: (errorBody: any, context: SerdeFunctions) => Promise<any>;
+/**
+ * @internal
+ */
+export declare const loadRestJsonErrorCode: (output: HttpResponse, data: any) => string | undefined;
+/**
+ * @internal
+ */
+export declare const loadJsonRpcErrorCode: (output: HttpResponse, data: any, queryCompat?: boolean) => string | undefined;
+/**
+ * Smithy RPCv2 JSON error identifier loader.
+ *
+ * Unlike {@link loadJsonRpcErrorCode} (used by AWS JSON 1.0/1.1 and restJson1),
+ * this preserves the ABSOLUTE shape id carried in `__type`. The RPCv2 JSON SEP
+ * requires `__type` to contain the fully-qualified shape id, and the protocol
+ * resolves errors by that absolute id to avoid ambiguous resolution when the
+ * same shape name exists in more than one namespace.
+ *
+ * It trims the Smithy-specific `,` fault/tag suffix and the `:` suffix, but does
+ * NOT strip the `#` namespace separator:
+ *   "com.a.b#Error:Sender,tag" -> "com.a.b#Error"
+ *
+ * @internal
+ */
+export declare const loadSmithyRpcV2JsonErrorCode: (output: HttpResponse, data: any) => string | undefined;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/writeKey.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Makes __proto__ writable on a given object.
+ */
+export declare function writeKey(obj: object | Record<string, unknown> | any): void;

package/node_modules/@smithy/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/core",
-  "version": "3.35.2",
+  "version": "3.36.0",
   "homepage": "https://github.com/smithy-lang/smithy-typescript/tree/main/packages/core",
   "license": "Apache-2.0",
   "author": {
@@ -226,6 +226,7 @@
   "scripts": {
     "benchmark:cbor": "node ./scripts/cbor-perf.mjs",
     "benchmark:checksum": "node ./scripts/checksum-perf.mjs",
+    "benchmark:json": "npx tsx ./scripts/benchmark-json-serializer.ts",
     "benchmark:schema:cbor": "node ./scripts/cbor-shape-perf.mjs",
     "build": "concurrently 'yarn:build:types' 'yarn:build:es:cjs'",
     "build:es:cjs": "node ../../scripts/compilation/es_cjs.js",

package/node_modules/@zone-eu/mailsplit/README.md

@@ -29,9 +29,9 @@ let splitter = new Splitter(options);
 
 Where
 
--   **options** is an optional options object
-    -   **options.ignoreEmbedded** (boolean, defaults to false) if true then treat message/rfc822 node as normal leaf node and do not try to parse it
-    -   **options.maxHeadSize** (number, defaults to Infinity) limits message header size in bytes
+- **options** is an optional options object
+    - **options.ignoreEmbedded** (boolean, defaults to false) if true then treat message/rfc822 node as normal leaf node and do not try to parse it
+    - **options.maxHeadSize** (number, defaults to 1 MiB) limits the header size of a MIME node in bytes, every header line counting for at least 64 bytes
 
 #### Events
 
@@ -39,13 +39,13 @@ Where
 
 #### Data objects
 
--   **type**
-    -   `'node'` means that we reached the next mime node and the previous one is completely processed
-    -   `'data'` provides us multipart body parts, including boundaries. This data is not directly related to any specific multipart node, basically it includes everything between the end of one normal node and the header of next node
-    -   `'body'` provides us next chunk for the last seen `'node'` element
--   **value** is a buffer value for `'body'` and `'data'` parts
--   **getDecoder()** is a function that returns a stream object you can use to decode node contents. Write data from 'body' to decoder and read decoded Buffer value out from it
--   **getEncoder()** is a function that returns a stream object you can use to encode node contents. Write buffer data to encoder and read encoded object value out that you can pass to a Joiner
+- **type**
+    - `'node'` means that we reached the next mime node and the previous one is completely processed
+    - `'data'` provides us multipart body parts, including boundaries. This data is not directly related to any specific multipart node, basically it includes everything between the end of one normal node and the header of next node
+    - `'body'` provides us next chunk for the last seen `'node'` element
+- **value** is a buffer value for `'body'` and `'data'` parts
+- **getDecoder()** is a function that returns a stream object you can use to decode node contents. Write data from 'body' to decoder and read decoded Buffer value out from it
+- **getEncoder()** is a function that returns a stream object you can use to encode node contents. Write buffer data to encoder and read encoded object value out that you can pass to a Joiner
 
 Element with type `'node'` has a bunch of header related methods and properties, see [below](#manipulating-headers).
 
@@ -82,31 +82,31 @@ someMessagStream.pipe(splitter);
 
 If the data object has `type='node'` then you can modify headers for that node (headers can be modified until the data object is passed over to a `Joiner`)
 
--   **node.getHeaders()** returns a Buffer value with generated headers. If you have not modified the headers object in any way then you should get the exact copy of the original. In case you have done something (for example removed a key, or added a new header key), then all linebreaks are forced to <CR><LF> even if the original headers used just <LF>
--   **node.setContentType(contentType)** sets or updates mime type for the node
--   **node.setCharset(charset)** sets or updates character set in the Content-Type header
--   **node.setFilename(filename)** sets or updates filename in the Content-Disposition header (unicode allowed)
+- **node.getHeaders()** returns a Buffer value with generated headers. If you have not modified the headers object in any way then you should get the exact copy of the original. In case you have done something (for example removed a key, or added a new header key), then all linebreaks are forced to <CR><LF> even if the original headers used just <LF>
+- **node.setContentType(contentType)** sets or updates mime type for the node
+- **node.setCharset(charset)** sets or updates character set in the Content-Type header
+- **node.setFilename(filename)** sets or updates filename in the Content-Disposition header (unicode allowed)
 
 You can manipulate specific header keys as well using the `headers` object
 
--   **node.headers.get(key)** returns an array of strings with all header rows for the selected key (these are full header lines, so key name is part of the row string, eg `["Subject: This is subject line"]`)
--   **node.headers.getFirst(key)** returns string value of the specified header key (eg `"This is subject line"`)
--   **node.headers.hasHeader(key)** returns boolean value if the specified header key exists
--   **node.headers.add(key, value [,index])** adds a new header value to the specified index or to the top of the header block if index is not specified
--   **node.headers.update(key, value, [,relativeKeyIndex])** replaces a header value to the specified relative key index (note that relative key index means relative to the same header key, eg if multiple exist and you specify `1` as the value, then it will update the second) or if no relative key index is specified, then it will remove all header value matches found for the key and append one at the last matching key index found with the specified value. If a relative key index is specified and it does not exist then it will be replaced (eg if there are two headers of `X-Foo-Bar` and you pass `2`, meaning it will update the third, no updates will be made since the third did not exist)
--   **node.headers.remove(key)** remove header value
--   **node.headers.mbox** If this is a MBOX formatted message then this value holds the prefix line (eg. "From MAILER-DAEMON Fri Jul 8 12:08:34 2011")
--   **node.headers.mbox** If this is a POST form-data then this value holds the HTTP prefix line (eg. "POST /upload.php HTTP/1.1")
+- **node.headers.get(key)** returns an array of strings with all header rows for the selected key (these are full header lines, so key name is part of the row string, eg `["Subject: This is subject line"]`)
+- **node.headers.getFirst(key)** returns string value of the specified header key (eg `"This is subject line"`)
+- **node.headers.hasHeader(key)** returns boolean value if the specified header key exists
+- **node.headers.add(key, value [,index])** adds a new header value to the specified index or to the top of the header block if index is not specified
+- **node.headers.update(key, value, [,relativeKeyIndex])** replaces a header value to the specified relative key index (note that relative key index means relative to the same header key, eg if multiple exist and you specify `1` as the value, then it will update the second) or if no relative key index is specified, then it will remove all header value matches found for the key and append one at the last matching key index found with the specified value. If a relative key index is specified and it does not exist then it will be replaced (eg if there are two headers of `X-Foo-Bar` and you pass `2`, meaning it will update the third, no updates will be made since the third did not exist)
+- **node.headers.remove(key)** remove header value
+- **node.headers.mbox** If this is a MBOX formatted message then this value holds the prefix line (eg. "From MAILER-DAEMON Fri Jul 8 12:08:34 2011")
+- **node.headers.mbox** If this is a POST form-data then this value holds the HTTP prefix line (eg. "POST /upload.php HTTP/1.1")
 
 Additionally you can check the details of the node with the following properties automatically parsed from the headers:
 
--   **node.root** if true then it means this is the message root, so this node should contain Subject, From, To etc. headers
--   **node.contentType** returns the mime type of the node (eg. 'text/html')
--   **node.disposition** either `'attachment'`, `'inline'` or `false` if not set
--   **node.charset** returns the charset of the node as defined in 'Content-Type' header (eg. 'UTF-8') or false if not defined
--   **node.encoding** returns the Transfer-Encoding value (eg. 'base64' or 'quoted-printable') or false if not defined
--   **node.multipart** if has value, then this is a multipart node (does not have 'body' parts)
--   **node.filename** is set if the headers contain a filename value. This is decoded to unicode, so it is a normal string or false if not found
+- **node.root** if true then it means this is the message root, so this node should contain Subject, From, To etc. headers
+- **node.contentType** returns the mime type of the node (eg. 'text/html')
+- **node.disposition** either `'attachment'`, `'inline'` or `false` if not set
+- **node.charset** returns the charset of the node as defined in 'Content-Type' header (eg. 'UTF-8') or false if not defined
+- **node.encoding** returns the Transfer-Encoding value (eg. 'base64' or 'quoted-printable') or false if not defined
+- **node.multipart** if has value, then this is a multipart node (does not have 'body' parts)
+- **node.filename** is set if the headers contain a filename value. This is decoded to unicode, so it is a normal string or false if not found
 
 ### Join parsed message stream
 
@@ -118,10 +118,7 @@ let Joiner = require('mailsplit').Joiner;
 let splitter = new Splitter();
 let joiner = new Joiner();
 // pipe a message source to splitter, then joiner and finally to stdout
-someMessagStream
-    .pipe(splitter)
-    .pipe(joiner)
-    .pipe(process.stdout);
+someMessagStream.pipe(splitter).pipe(joiner).pipe(process.stdout);
 ```
 
 ### Rewrite specific nodes
@@ -130,14 +127,14 @@ someMessagStream
 
 Rewriter takes the following argument:
 
--   **filterFunc** gets the current node as argument and starts processing it if `filterFunc` returns true
+- **filterFunc** gets the current node as argument and starts processing it if `filterFunc` returns true
 
 Once Rewriter finds a matching node, it emits the following event:
 
--   _'node'_ with an object argument `data`
-    -   `data.node` includes the current node with headers
-    -   `data.decoder` is the decoder stream that you can read data from
-    -   `data.encoder` is the encoder stream that you can write data to. Whatever you write into that stream will be encoded properly and inserted as the content of the current node
+- _'node'_ with an object argument `data`
+    - `data.node` includes the current node with headers
+    - `data.decoder` is the decoder stream that you can read data from
+    - `data.encoder` is the encoder stream that you can write data to. Whatever you write into that stream will be encoded properly and inserted as the content of the current node
 
 ```javascript
 let Splitter = require('mailsplit').Splitter;
@@ -153,11 +150,7 @@ rewriter.on('node', data => {
     data.decoder.pipe(data.encoder);
 });
 // pipe a message source to splitter, then rewriter, then joiner and finally to stdout
-someMessagStream
-    .pipe(splitter)
-    .pipe(rewriter)
-    .pipe(joiner)
-    .pipe(process.stdout);
+someMessagStream.pipe(splitter).pipe(rewriter).pipe(joiner).pipe(process.stdout);
 ```
 
 ### Stream specific nodes
@@ -166,14 +159,14 @@ someMessagStream
 
 Streamer takes the following argument:
 
--   **filterFunc** gets the current node as argument and starts processing it if `filterFunc` returns true
+- **filterFunc** gets the current node as argument and starts processing it if `filterFunc` returns true
 
 Once Streamer finds a matching node, it emits the following event:
 
--   _'node'_ with an object argument `data`
-    -   `data.node` includes the current node with headers (informational only, you can't modify it)
-    -   `data.decoder` is the decoder stream that you can read data from
-    -   `data.done` is a function you must call once you have processed the stream
+- _'node'_ with an object argument `data`
+    - `data.node` includes the current node with headers (informational only, you can't modify it)
+    - `data.decoder` is the decoder stream that you can read data from
+    - `data.done` is a function you must call once you have processed the stream
 
 ```javascript
 let Splitter = require('mailsplit').Splitter;
@@ -189,11 +182,7 @@ streamer.on('node', data => {
     data.done();
 });
 // pipe a message source to splitter, then streamer, then joiner and finally to stdout
-someMessagStream
-    .pipe(splitter)
-    .pipe(streamer)
-    .pipe(joiner)
-    .pipe(process.stdout);
+someMessagStream.pipe(splitter).pipe(streamer).pipe(joiner).pipe(process.stdout);
 ```
 
 ### Benchmark
@@ -211,4 +200,4 @@ Done. 20000 messages [1244 MB] processed in 55.882 s. with average of 358 messag
 
 Dual licensed under **MIT** or **EUPLv1.1+**
 
-> `mailsplit` is part of the Zone Mail Suite (ZMS). Suite of programs and modules for an efficient, fast and modern email server.
+> `mailsplit` is part of the Zone Mail Suite (ZMS). Suite of programs and modules for an efficient, fast and modern email server.

package/node_modules/@zone-eu/mailsplit/lib/headers.js

@@ -365,10 +365,16 @@ class Headers {
             return;
         }
 
-        let rawLines = this.headers
-            .toString('binary')
-            .replace(/[\r\n]+$/, '')
-            .split(/\r?\n/);
+        let raw = this.headers.toString('binary');
+
+        // Trailing line breaks go with an index scan. /[\r\n]+$/ retried a run of carriage
+        // returns from every position in it, quadratic on a header line made of them
+        let end = raw.length;
+        while (end > 0 && (raw.charCodeAt(end - 1) === 0x0a || raw.charCodeAt(end - 1) === 0x0d)) {
+            end--;
+        }
+
+        let rawLines = raw.slice(0, end).split(/\r?\n/);
 
         // Single forward pass. Splicing folded lines out of the source array in place was
         // quadratic on a header block with many continuation lines.

package/node_modules/@zone-eu/mailsplit/lib/message-splitter.js

@@ -488,13 +488,14 @@ class MessageSplitter extends Transform {
     }
 
     /**
-     * Checks the header bytes collected for the current node against maxHeadSize.
+     * Checks the header bytes collected for the current node against maxHeadSize. See
+     * MimeNode#headerCost.
      *
      * @param {number} [extra] Bytes that belong to the header block but are not stored yet.
      * @returns {(Error & {code?: string}) | null} Error object if the limit was exceeded.
      */
     checkHeadSize(extra) {
-        if (this.node._headerlen + (extra || 0) > this.maxHeadSize) {
+        if (this.node.headerCost(extra) > this.maxHeadSize) {
             return maxLenError('Max header size for a MIME node exceeded');
         }
         return null;
@@ -630,12 +631,12 @@ class MessageSplitter extends Transform {
 
         switch (this.state) {
             case HEAD: {
-                this.node.addHeaderChunk(line);
+                let endsBlock = this.node.addHeaderChunk(line);
                 let headSizeError = this.checkHeadSize();
                 if (headSizeError) {
                     return next(headSizeError);
                 }
-                if (final || (line.length === 1 && line[0] === 0x0a) || (line.length === 2 && line[0] === 0x0d && line[1] === 0x0a)) {
+                if (final || endsBlock) {
                     let currentNode = this.node;
 
                     currentNode.parseHeaders();

package/node_modules/@zone-eu/mailsplit/lib/mime-node.d.ts

@@ -23,6 +23,7 @@ declare class MimeNode implements MimeNodeShape {
 
     /** Length, in bytes, of the raw header block collected for this node. */
     _headerlen: number;
+    _headerCost: number;
 
     /** Multipart subtype such as `mixed` or `alternative`, or `false` for leaf nodes. */
     multipart: string | false;
@@ -88,7 +89,9 @@ declare class MimeNode implements MimeNodeShape {
      * @param line Raw header line bytes; falsy values are ignored.
      * @returns Nothing.
      */
-    addHeaderChunk(line?: Buffer | false): void;
+    addHeaderChunk(line?: Buffer | false): boolean;
+    /** What the header lines count for against maxHeadSize, every line at least 64 bytes */
+    headerCost(extra?: number): number;
 
     /**
      * Parses collected header bytes and populates MIME metadata fields.

package/node_modules/@zone-eu/mailsplit/lib/mime-node.js

@@ -18,6 +18,10 @@ const pathlib = require('path');
 
 const Libmime = /** @type {any} */ (libmime.Libmime);
 
+// The least a header line counts for against maxHeadSize. A parsed line costs a fixed
+// overhead on top of its bytes, so 1 MiB of header is at most 16k lines
+const HEADER_LINE_MIN_COST = 64;
+
 /**
  * Removes everything from the first `(` to the last `)` of each line, the same result as
  * `value.replace(/\(.*\)/g, '')`, but in linear time. The regex backtracks quadratically
@@ -69,7 +73,11 @@ function rfc2231ParamNames(value) {
         if (eq < 0) {
             return;
         }
-        let match = segment.substring(0, eq).trim().toLowerCase().match(/^(.+?)\*(\d+\*?)?$/);
+        let match = segment
+            .substring(0, eq)
+            .trim()
+            .toLowerCase()
+            .match(/^(.+?)\*(\d+\*?)?$/);
         if (match) {
             names.add(match[1]);
         }
@@ -117,6 +125,7 @@ class MimeNode {
         /** @type {Buffer[]} */
         this._headersLines = [];
         this._headerlen = 0;
+        this._headerCost = 0;
 
         /** @type {StructuredHeader | false} */
         this._parsedContentType = false;
@@ -171,14 +180,28 @@ class MimeNode {
 
     /**
      * @param {Buffer | false} [line]
-     * @returns {void}
+     * @returns {boolean} Whether the line is the empty line that ends the header block.
      */
     addHeaderChunk(line) {
         if (!line) {
-            return;
+            return false;
         }
         this._headersLines.push(line);
         this._headerlen += line.length;
+        let endsBlock = (line.length === 1 && line[0] === 0x0a) || (line.length === 2 && line[0] === 0x0d && line[1] === 0x0a);
+        // the empty line that ends the block costs its bytes, every other line at least the floor
+        this._headerCost += endsBlock ? line.length : Math.max(line.length, HEADER_LINE_MIN_COST);
+        return endsBlock;
+    }
+
+    /**
+     * What the header lines of this node count for against maxHeadSize, see HEADER_LINE_MIN_COST.
+     *
+     * @param {number} [extra] Bytes of a header line that is not stored yet.
+     * @returns {number} The cost in bytes.
+     */
+    headerCost(extra) {
+        return this._headerCost + (extra ? Math.max(extra, HEADER_LINE_MIN_COST) : 0);
     }
 
     /**
@@ -189,6 +212,8 @@ class MimeNode {
             return;
         }
         this.headers = new Headers(Buffer.concat(this._headersLines, this._headerlen), this.config);
+        // the views held the input chunks alive, the block lives on in the copy
+        this._headersLines = [];
         let headers = this.headers;
 
         let dispositionHeader = headers.getFirst('Content-Disposition');
@@ -227,7 +252,7 @@ class MimeNode {
         if (this.disposition) {
             try {
                 this.disposition = this.libmime.decodeWords(this.disposition);
-            } catch (E) {
+            } catch (_E) {
                 // failed to parse disposition, keep as is (most probably an unknown charset is used)
             }
         }
@@ -249,7 +274,7 @@ class MimeNode {
             if (!decoded) {
                 try {
                     this.filename = this.libmime.decodeWords(this.filename);
-                } catch (E) {
+                } catch (_E) {
                     // failed to parse filename, keep as is (most probably an unknown charset is used)
                 }
             }