@withbuddi/buddi 0.1.0-pre.21 → 0.1.0-pre.23

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

@@ -28,6 +28,10 @@ const BOUNDARY_LINE_SUFFIX = 2 /* "--" prefix */ + 2 /* "--" suffix */ + 2; /* t
 // the longest a delimiter line can ever be once the boundary value is subtracted
 const BOUNDARY_LINE_OVERHEAD = BOUNDARY_LINE_SUFFIX + 2; /* leading <CR><LF> */
 
+// Bytes of input split in one go before yielding to the event loop. Bytes rather than lines
+// bound the work per batch whatever the line length: 16 KiB is at most 16k (empty) lines.
+const YIELD_BYTES = 16 * 1024;
+
 const HEAD = 0x01;
 const BODY = 0x02;
 
@@ -153,6 +157,12 @@ class MessageSplitter extends Transform {
         };
         let groupstart = this.lineLength ? -this.lineLength : 0;
         let groupend = 0;
+        // input position where the current batch started
+        let yieldPos = 0;
+        // true while processLine() runs synchronously for the current line
+        let inLine = false;
+        // set when the current line finished synchronously and the batch may continue in place
+        let resumeInLine = false;
 
         /**
          * Removes a pending line break from body data that belongs to a following boundary.
@@ -187,96 +197,133 @@ class MessageSplitter extends Transform {
             }
         };
 
+        // assigned below, the line handlers and the batch loop call each other
+        /** @type {() => void} */
+        let iterateData;
+
         /**
-         * Iterates the current input chunk line by line and emits parsed groups.
+         * Continues with the next line. Lines are processed in place and the event loop is
+         * only yielded to every YIELD_BYTES of input, a setImmediate per line made line-dense
+         * input very slow to split. A line that completed asynchronously always reschedules.
          *
          * @returns {void}
          */
-        let iterateData = () => {
-            for (let len = chunk.length; i < len; i++) {
-                // find next <LF>
-                if (chunk[i] === 0x0a) {
-                    // line end
+        let nextLine = () => {
+            if (inLine && i - yieldPos < YIELD_BYTES) {
+                resumeInLine = true;
+                return;
+            }
+            setImmediate(iterateData);
+        };
 
-                    let start = Math.max(pos, 0);
-                    pos = ++i;
+        /**
+         * Handles the result of processLine() for the line that ends at `i`. Defined once per
+         * write rather than once per line.
+         *
+         * @type {ProcessLineCallback}
+         */
+        let onLine = (err, data, flush) => {
+            if (err) {
+                this.hasFailed = true;
+                return setImmediate(() => callback(err));
+            }
 
-                    return this.processLine(chunk.slice(start, i), false, (err, data, flush) => {
-                        if (err) {
-                            this.hasFailed = true;
-                            return setImmediate(() => callback(err));
-                        }
+            if (!data) {
+                return nextLine();
+            }
 
-                        if (!data) {
-                            return setImmediate(iterateData);
+            if (flush) {
+                if (group && group.type !== 'none') {
+                    // do not include the last line ending for body
+                    groupend = trimBodyLineEnd(group, chunk, groupstart, groupend);
+                    if (groupstart < groupend) {
+                        // re-slice, the value the line was emitted with may
+                        // still include the line ending we just trimmed
+                        group.value = chunk.slice(groupstart, groupend);
+                        if (groupend < i && 'value' in data) {
+                            // the trimmed line ending belongs to the boundary line
+                            data.value = chunk.slice(groupend, i);
                         }
+                    }
+                    // the group is pushed even when nothing is left of it, so that a
+                    // part whose whole body is a line ending still reports a body
+                    this.push(group);
+                    group = {
+                        type: 'none'
+                    };
+                    groupstart = groupend = i;
+                }
+                this.push(data);
+                groupend = i;
+                return nextLine();
+            }
 
-                        if (flush) {
-                            if (group && group.type !== 'none') {
-                                // do not include the last line ending for body
-                                groupend = trimBodyLineEnd(group, chunk, groupstart, groupend);
-                                if (groupstart < groupend) {
-                                    // re-slice, the value the line was emitted with may
-                                    // still include the line ending we just trimmed
-                                    group.value = chunk.slice(groupstart, groupend);
-                                    if (groupend < i && 'value' in data) {
-                                        // the trimmed line ending belongs to the boundary line
-                                        data.value = chunk.slice(groupend, i);
-                                    }
-                                }
-                                // the group is pushed even when nothing is left of it, so that a
-                                // part whose whole body is a line ending still reports a body
-                                this.push(group);
-                                group = {
-                                    type: 'none'
-                                };
-                                groupstart = groupend = i;
-                            }
-                            this.push(data);
-                            groupend = i;
-                            return setImmediate(iterateData);
+            if (data.type === group.type) {
+                // shift slice end position forward
+                groupend = i;
+            } else {
+                // do not include the last line ending for body
+                groupend = trimBodyLineEnd(group, chunk, groupstart, groupend);
+
+                if (group.type !== 'none' && group.type !== 'node') {
+                    // we have a previous data/body chunk to output
+                    if (groupstart !== groupend) {
+                        group.value = chunk.slice(groupstart, groupend);
+                        if (group.value && group.value.length) {
+                            this.push(group);
+                            group = {
+                                type: 'none'
+                            };
                         }
+                    }
+                }
 
-                        if (data.type === group.type) {
-                            // shift slice end position forward
-                            groupend = i;
-                        } else {
-                            // do not include the last line ending for body
-                            groupend = trimBodyLineEnd(group, chunk, groupstart, groupend);
-
-                            if (group.type !== 'none' && group.type !== 'node') {
-                                // we have a previous data/body chunk to output
-                                if (groupstart !== groupend) {
-                                    group.value = chunk.slice(groupstart, groupend);
-                                    if (group.value && group.value.length) {
-                                        this.push(group);
-                                        group = {
-                                            type: 'none'
-                                        };
-                                    }
-                                }
-                            }
-
-                            if (data.type === 'node') {
-                                this.push(data);
-                                groupstart = i;
-                                groupend = i;
-                            } else if (groupstart < 0) {
-                                groupstart = i;
-                                groupend = i;
-                                checkTrailingLinebreak(data);
-                                if (data.value && data.value.length) {
-                                    this.push(data);
-                                }
-                            } else {
-                                // start new body/data chunk
-                                group = data;
-                                groupstart = groupend;
-                                groupend = i;
-                            }
-                        }
-                        return setImmediate(iterateData);
-                    });
+                if (data.type === 'node') {
+                    this.push(data);
+                    groupstart = i;
+                    groupend = i;
+                } else if (groupstart < 0) {
+                    groupstart = i;
+                    groupend = i;
+                    checkTrailingLinebreak(data);
+                    if (data.value && data.value.length) {
+                        this.push(data);
+                    }
+                } else {
+                    // start new body/data chunk
+                    group = data;
+                    groupstart = groupend;
+                    groupend = i;
+                }
+            }
+            return nextLine();
+        };
+
+        /**
+         * Iterates the current input chunk line by line and emits parsed groups.
+         *
+         * @returns {void}
+         */
+        iterateData = () => {
+            yieldPos = i;
+            while (i < chunk.length) {
+                // find next <LF>
+                if (chunk[i] !== 0x0a) {
+                    i++;
+                    continue;
+                }
+
+                // line end
+                let start = Math.max(pos, 0);
+                pos = ++i;
+
+                inLine = true;
+                resumeInLine = false;
+                this.processLine(chunk.slice(start, i), false, onLine);
+                inLine = false;
+                if (!resumeInLine) {
+                    // an error or a scheduled continuation takes over from here
+                    return;
                 }
             }
 

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

@@ -18,6 +18,32 @@ const pathlib = require('path');
 
 const Libmime = /** @type {any} */ (libmime.Libmime);
 
+/**
+ * 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
+ * on a value with many `(` characters and no closing `)`.
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+function stripComments(value) {
+    if (value.indexOf('(') < 0) {
+        // the common case, nothing to strip
+        return value;
+    }
+    return value
+        .split(/([\n\r\u2028\u2029])/)
+        .map(part => {
+            let start = part.indexOf('(');
+            if (start < 0) {
+                return part;
+            }
+            let end = part.lastIndexOf(')');
+            return end > start ? part.slice(0, start) + part.slice(end + 1) : part;
+        })
+        .join('');
+}
+
 /**
  * Parsed MIME node with mutable headers and transfer-encoding helpers.
  */
@@ -142,11 +168,7 @@ class MimeNode {
         this._parsedContentType = this.libmime.parseHeaderValue(contentHeader);
         let parsedContentType = /** @type {StructuredHeader} */ (this._parsedContentType);
 
-        this.encoding = headers
-            .getFirst('Content-Transfer-Encoding')
-            .replace(/\(.*\)/g, '')
-            .toLowerCase()
-            .trim();
+        this.encoding = stripComments(headers.getFirst('Content-Transfer-Encoding')).toLowerCase().trim();
         this.contentType = (parsedContentType.value || '').toLowerCase().trim() || false;
         this.charset = parsedContentType.params.charset || false;
         this.disposition = (parsedContentDisposition.value || '').toLowerCase().trim() || false;

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

@@ -203,9 +203,10 @@ class NodeRewriter extends Transform {
         if (/^text\//.test(node.contentType || '') && node.flowed) {
             // text/plain; format=flowed is a special case
             let flowDecoder = decoder;
+            // the transfer encoding is already removed by node.getDecoder(), so the flowed
+            // decoder must not decode base64 a second time
             decoder = new FlowedDecoder({
-                delSp: node.delSp,
-                encoding: node.encoding || false
+                delSp: node.delSp
             });
             flowDecoder.on(
                 'error',

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

@@ -41,9 +41,6 @@ export interface ChunkedPassthroughOptions {
 export interface FlowedDecoderOptions extends LibmimeOptions {
     /** Whether format=flowed uses RFC 3676 `DelSp=yes` space deletion semantics. */
     delSp?: boolean;
-
-    /** Source Content-Transfer-Encoding hint used during format=flowed handling. */
-    encoding?: string | false;
 }
 
 /** Parsed raw header line with a normalized lookup key. */

package/node_modules/@zone-eu/mailsplit/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zone-eu/mailsplit",
-    "version": "5.4.17",
+    "version": "5.4.19",
     "description": "Split email messages into an object stream",
     "main": "index.js",
     "types": "index.d.ts",
@@ -15,9 +15,9 @@
     "author": "Andris Reinman",
     "license": "(MIT OR EUPL-1.1+)",
     "dependencies": {
-        "libbase64": "1.3.0",
-        "libmime": "5.4.4",
-        "libqp": "2.1.1"
+        "libbase64": "1.3.1",
+        "libmime": "5.4.6",
+        "libqp": "2.1.2"
     },
     "devDependencies": {
         "@types/eslint": "9.6.1",
@@ -25,7 +25,7 @@
         "@types/grunt": "0.4.32",
         "@types/libmime": "5.3.0",
         "@types/libqp": "1.1.3",
-        "@types/node": "26.5.1",
+        "@types/node": "26.6.3",
         "eslint": "8.29.0",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "9.1.0",

package/node_modules/hono/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/node_modules/hono/dist/adapter/aws-lambda/conninfo.js

@@ -1,24 +1,43 @@
-// src/adapter/aws-lambda/conninfo.ts
-var getConnInfo = (c) => {
-  const requestContext = c.env.requestContext;
-  let address;
-  if ("identity" in requestContext && requestContext.identity?.sourceIp) {
-    address = requestContext.identity.sourceIp;
-  } else if ("http" in requestContext && requestContext.http?.sourceIp) {
-    address = requestContext.http.sourceIp;
-  } else {
-    const xff = c.req.header("x-forwarded-for");
-    if (xff) {
-      const ips = xff.split(",");
-      address = ips[ips.length - 1].trim();
-    }
-  }
-  return {
-    remote: {
-      address
-    }
-  };
-};
-export {
-  getConnInfo
+//#region src/adapter/aws-lambda/conninfo.ts
+/**
+* Get connection information from AWS Lambda
+*
+* Extracts client IP from various Lambda event sources:
+* - API Gateway v1 (REST API): requestContext.identity.sourceIp
+* - API Gateway v2 (HTTP API/Function URLs): requestContext.http.sourceIp
+* - ALB: Falls back to x-forwarded-for header
+*
+* @param c - Context
+* @returns Connection information including remote address
+* @example
+* ```ts
+* import { Hono } from 'hono'
+* import { handle, getConnInfo } from 'hono/aws-lambda'
+*
+* const app = new Hono()
+*
+* app.get('/', (c) => {
+*   const info = getConnInfo(c)
+*   return c.text(`Your IP: ${info.remote.address}`)
+* })
+*
+* export const handler = handle(app)
+* ```
+* @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+*/
+const getConnInfo = (c) => {
+	const requestContext = c.env.requestContext;
+	let address;
+	if ("identity" in requestContext && requestContext.identity?.sourceIp) address = requestContext.identity.sourceIp;
+	else if ("http" in requestContext && requestContext.http?.sourceIp) address = requestContext.http.sourceIp;
+	else {
+		const xff = c.req.header("x-forwarded-for");
+		if (xff) {
+			const ips = xff.split(",");
+			address = ips[ips.length - 1].trim();
+		}
+	}
+	return { remote: { address } };
 };
+//#endregion
+export { getConnInfo };