@opra/core 0.33.13 → 1.0.0-alpha.1

package/esm/http/{http-server-response.js → impl/http-outgoing.host.js}

@@ -11,23 +11,9 @@ import mime from 'mime-types';
 import path from 'path';
 import { toString } from 'putil-varhelpers';
 import vary from 'vary';
-import { HttpStatusCode, isStream, mergePrototype } from '@opra/common';
-import { HttpOutgoingMessageHost } from './impl/http-outgoing-message.host.js';
+import { HttpStatusCode } from '@opra/common';
 const charsetRegExp = /;\s*charset\s*=/;
-function isHttpIncomingMessage(v) {
-    return v && typeof v.getHeaders === 'function' && isStream(v);
-}
-export var HttpServerResponse;
-(function (HttpServerResponse) {
-    function from(instance) {
-        if (!isHttpIncomingMessage(instance))
-            instance = new HttpOutgoingMessageHost(instance);
-        mergePrototype(instance, HttpServerResponseHost.prototype);
-        return instance;
-    }
-    HttpServerResponse.from = from;
-})(HttpServerResponse || (HttpServerResponse = {}));
-class HttpServerResponseHost {
+export class HttpOutgoingHost {
     attachment(filename) {
         if (filename)
             this.contentType(path.extname(filename));
@@ -35,9 +21,7 @@ class HttpServerResponseHost {
         return this;
     }
     contentType(type) {
-        const ct = type.indexOf('/') === -1
-            ? mime.lookup(type)
-            : type;
+        const ct = type.indexOf('/') === -1 ? mime.lookup(type) : type;
         this.setHeader('Content-Type', ct);
         return this;
     }
@@ -50,9 +34,7 @@ class HttpServerResponseHost {
             return this;
         }
         const fieldLower = field.toLowerCase();
-        let value = Array.isArray(val)
-            ? val.map(String)
-            : (val ? String(val) : '');
+        let value = Array.isArray(val) ? val.map(String) : val ? String(val) : '';
         // add charset to content-type
         if (fieldLower === 'content-type') {
             if (Array.isArray(value)) {
@@ -71,15 +53,13 @@ class HttpServerResponseHost {
         const opts = {
             expires: new Date(1),
             path: '/',
-            ...options
+            ...options,
         };
         return this.cookie(name, '', opts);
     }
     cookie(name, value, options) {
         const opts = { ...options };
-        let val = typeof value === 'object'
-            ? 'j:' + JSON.stringify(value)
-            : String(value);
+        let val = typeof value === 'object' ? 'j:' + JSON.stringify(value) : String(value);
         if (opts.signed) {
             const secret = opts.secret || this.req?.secret;
             if (!secret)

package/esm/http/{helpers/multipart-helper.js → impl/multipart-reader.js}

@@ -1,34 +1,38 @@
 import { EventEmitter } from 'events';
 import formidable from 'formidable';
 import fs from 'fs/promises';
-export class MultipartIterator extends EventEmitter {
-    constructor(options) {
+export class MultipartReader extends EventEmitter {
+    constructor(incoming, options) {
         super();
+        this._started = false;
         this._cancelled = false;
         this._items = [];
         this._stack = [];
         this.setMaxListeners(1000);
-        const form = this._form = formidable({
+        this._incoming = incoming;
+        const form = (this._form = formidable({
             ...options,
             filter: (part) => {
                 return !this._cancelled && (!options?.filter || options.filter(part));
-            }
-        });
+            },
+        }));
         form.once('error', () => {
             this._cancelled = true;
             if (this.listenerCount('error') > 0)
                 this.emit('error');
         });
-        form.on('field', (field, value) => {
-            const item = { field, value };
+        form.on('field', (fieldName, value) => {
+            const item = { fieldName, type: 'field', value };
             this._items.push(item);
             this._stack.push(item);
+            this.emit('field', item);
             this.emit('item', item);
         });
-        form.on('file', (field, file) => {
-            const item = { field, file };
+        form.on('file', (fieldName, file) => {
+            const item = { fieldName, type: 'file', file };
             this._items.push(item);
             this._stack.push(item);
+            this.emit('file', item);
             this.emit('item', item);
         });
     }
@@ -44,7 +48,7 @@ export class MultipartIterator extends EventEmitter {
             if (this._form.ended)
                 return resolve(undefined);
             this.once('item', () => resolve(this._stack.shift()));
-            this.once('error', (e) => reject(e));
+            this.once('error', e => reject(e));
         });
     }
     getAll() {
@@ -64,6 +68,8 @@ export class MultipartIterator extends EventEmitter {
             this.resume();
     }
     resume() {
+        if (!this._started)
+            this._form.parse(this._incoming, () => void 0);
         if (this._form.req)
             this._form.resume();
     }
@@ -71,10 +77,9 @@ export class MultipartIterator extends EventEmitter {
         if (this._form.req)
             this._form.pause();
     }
-    async deleteFiles() {
+    async deleteTempFiles() {
         const promises = [];
-        this._items
-            .forEach(item => {
+        this._items.forEach(item => {
             if (!item.file)
                 return;
             const file = item.file;
@@ -82,17 +87,14 @@ export class MultipartIterator extends EventEmitter {
                 if (file._writeStream.closed)
                     return resolve();
                 file._writeStream.once('close', resolve);
-            }).then(() => {
+            })
+                .then(() => {
                 return fs.unlink(file.filepath);
-            }).then(() => {
+            })
+                .then(() => {
                 return 0;
             }));
         });
         return Promise.allSettled(promises);
     }
-    static async create(incoming, options) {
-        const out = new MultipartIterator(options);
-        await out._form.parse(incoming);
-        return out;
-    }
 }

package/esm/http/impl/{http-incoming-message.host.js → node-incoming-message.host.js}

@@ -1,23 +1,18 @@
-/*
-  This file contains code blocks from open source NodeJs project
-  https://github.com/nodejs/
- */
 import { Duplex, Readable } from 'stream';
-import { HTTPParser } from '@browsery/http-parser';
 import { isAsyncIterable, isIterable } from '@opra/common';
-import { concatReadable } from '../helpers/concat-readable.js';
-import { convertToHeaders, convertToHeadersDistinct } from '../helpers/convert-to-headers.js';
-import { convertToRawHeaders } from '../helpers/convert-to-raw-headers.js';
+import { convertToHeaders, convertToHeadersDistinct } from '../utils/convert-to-headers.js';
+import { convertToRawHeaders } from '../utils/convert-to-raw-headers.js';
 export const CRLF = Buffer.from('\r\n');
 export const kHeaders = Symbol.for('kHeaders');
 export const kHeadersDistinct = Symbol.for('kHeadersDistinct');
 export const kTrailers = Symbol.for('kTrailers');
 export const kTrailersDistinct = Symbol.for('kTrailersDistinct');
+export const kHttpParser = Symbol.for('kHttpParser');
 /**
  *
- * @class HttpIncomingMessageHost
+ * @class NodeIncomingMessageHost
  */
-export class HttpIncomingMessageHost extends Duplex {
+export class NodeIncomingMessageHost extends Duplex {
     constructor(init) {
         super();
         this.rawHeaders = [];
@@ -46,12 +41,14 @@ export class HttpIncomingMessageHost extends Duplex {
             this.ips = init.ips || (this.ip ? [this.ip] : []);
             if (this.body && !this.headers['content-length'])
                 this.headers['content-length'] = String(this.body.length);
+            if (init.params)
+                this.params = init.params;
+            if (init.cookies)
+                this.cookies = init.cookies;
         }
     }
     get httpVersion() {
-        return this.httpVersionMajor
-            ? this.httpVersionMajor + '.' + this.httpVersionMinor
-            : '';
+        return this.httpVersionMajor ? this.httpVersionMajor + '.' + this.httpVersionMinor : '';
     }
     get headers() {
         if (!this[kHeaders])
@@ -95,50 +92,12 @@ export class HttpIncomingMessageHost extends Duplex {
         }
         const chunk = this._readStream.read(size);
         this.push(chunk);
-        // this.push(null);s
     }
     _write(chunk, encoding, callback) {
-        const error = this._httpParser?.execute(chunk);
+        const error = this[kHttpParser]?.execute(chunk);
         if (error && typeof error === 'object')
             callback(error);
         else
             callback();
     }
-    static from(iterable) {
-        if (typeof iterable === 'object' && !(isIterable(iterable) || isAsyncIterable(iterable)))
-            return new HttpIncomingMessageHost(iterable);
-        const msg = new HttpIncomingMessageHost();
-        const parser = msg._httpParser = new HTTPParser(HTTPParser.REQUEST);
-        let bodyChunks;
-        parser[HTTPParser.kOnHeadersComplete] = (info) => {
-            msg.httpVersionMajor = info.versionMajor;
-            msg.httpVersionMinor = info.versionMinor;
-            msg.rawHeaders = info.headers;
-            msg.method = HTTPParser.methods[info.method];
-            msg.url = info.url;
-        };
-        parser[HTTPParser.kOnHeaders] = (trailers) => {
-            msg.rawTrailers = trailers;
-        };
-        parser[HTTPParser.kOnBody] = (chunk, offset, length) => {
-            bodyChunks = bodyChunks || [];
-            bodyChunks.push(chunk.subarray(offset, offset + length));
-        };
-        parser[HTTPParser.kOnMessageComplete] = () => {
-            msg.complete = true;
-            if (bodyChunks)
-                msg.body = Buffer.concat(bodyChunks);
-        };
-        const readable = concatReadable(Readable.from(iterable), Readable.from(CRLF));
-        msg.once('finish', () => parser.finish());
-        readable.pipe(msg);
-        return msg;
-    }
-    static async fromAsync(iterable) {
-        return new Promise((resolve, reject) => {
-            const msg = this.from(iterable);
-            msg.once('finish', () => resolve(msg));
-            msg.once('error', (error) => reject(error));
-        });
-    }
 }

package/esm/http/impl/{http-outgoing-message.host.js → node-outgoing-message.host.js}

@@ -3,15 +3,15 @@
   https://github.com/nodejs/
  */
 import { Duplex } from 'stream';
-import { validateHeaderName, validateHeaderValue, validateString } from '../helpers/common.js';
+import { validateHeaderName, validateHeaderValue, validateString } from '../utils/common.js';
 export const kOutHeaders = Symbol.for('kOutHeaders');
 export const kOutTrailers = Symbol.for('kOutTrailers');
 // noinspection JSUnusedLocalSymbols
 /**
  *
- * @class HttpOutgoingMessageHost
+ * @class NodeOutgoingMessageHost
  */
-export class HttpOutgoingMessageHost extends Duplex {
+export class NodeOutgoingMessageHost extends Duplex {
     constructor(init) {
         super();
         this._headersSent = false;
@@ -64,8 +64,7 @@ export class HttpOutgoingMessageHost extends Duplex {
     }
     addTrailers(headers) {
         if (headers && typeof headers === 'object') {
-            const entries = typeof headers.entries === 'function'
-                ? headers.entries() : Object.entries(headers);
+            const entries = typeof headers.entries === 'function' ? headers.entries() : Object.entries(headers);
             let trailers = this[kOutTrailers];
             if (trailers == null)
                 this[kOutTrailers] = trailers = { __proto__: null };
@@ -78,6 +77,9 @@ export class HttpOutgoingMessageHost extends Duplex {
         }
         throw new TypeError('Invalid "headers" argument. Value must be an object or raw headers array');
     }
+    flushHeaders() {
+        // nothing to do
+    }
     setHeader(name, value) {
         if (this.headersSent)
             throw new Error(`Cannot set headers after they are sent to the client`);
@@ -93,8 +95,7 @@ export class HttpOutgoingMessageHost extends Duplex {
         if (this.headersSent)
             throw new Error(`Cannot set headers after they are sent to the client`);
         if (headers && typeof headers === 'object' && !Array.isArray(headers)) {
-            const entries = typeof headers.entries === 'function'
-                ? headers.entries() : Object.entries(headers);
+            const entries = typeof headers.entries === 'function' ? headers.entries() : Object.entries(headers);
             for (const entry of entries) {
                 this.setHeader(entry[0], entry[1]);
             }
@@ -142,8 +143,7 @@ export class HttpOutgoingMessageHost extends Duplex {
     }
     hasHeader(name) {
         validateString(name);
-        return this[kOutHeaders] != null &&
-            !!this[kOutHeaders][name.toLowerCase()];
+        return this[kOutHeaders] != null && !!this[kOutHeaders][name.toLowerCase()];
     }
     removeHeader(name) {
         validateString(name);
@@ -188,7 +188,4 @@ export class HttpOutgoingMessageHost extends Duplex {
         //
         return this;
     }
-    static from(init) {
-        return new HttpOutgoingMessageHost(init);
-    }
 }

package/esm/http/interfaces/http-incoming.interface.js

@@ -0,0 +1,22 @@
+import { mergePrototype } from '@opra/common';
+import { isHttpIncoming, isNodeIncomingMessage } from '../../type-guards.js';
+import { HttpIncomingHost } from '../impl/http-incoming.host.js';
+import { NodeIncomingMessage } from './node-incoming-message.interface.js';
+/**
+ * @namespace HttpIncoming
+ */
+export var HttpIncoming;
+(function (HttpIncoming) {
+    function from(instance) {
+        if (isHttpIncoming(instance))
+            return instance;
+        if (!isNodeIncomingMessage(instance))
+            instance = NodeIncomingMessage.from(instance);
+        mergePrototype(instance, HttpIncomingHost.prototype);
+        const req = instance;
+        req.baseUrl = req.baseUrl || '';
+        req.params = req.params || {};
+        return req;
+    }
+    HttpIncoming.from = from;
+})(HttpIncoming || (HttpIncoming = {}));

package/esm/http/interfaces/http-outgoing.interface.js

@@ -0,0 +1,19 @@
+import { mergePrototype } from '@opra/common';
+import { isHttpOutgoing, isNodeOutgoingMessage } from '../../type-guards.js';
+import { HttpOutgoingHost } from '../impl/http-outgoing.host.js';
+import { NodeOutgoingMessage } from './node-outgoing-message.interface.js';
+/**
+ * @namespace HttpIncoming
+ */
+export var HttpOutgoing;
+(function (HttpOutgoing) {
+    function from(instance) {
+        if (isHttpOutgoing(instance))
+            return instance;
+        if (!isNodeOutgoingMessage(instance))
+            instance = NodeOutgoingMessage.from(instance);
+        mergePrototype(instance, HttpOutgoingHost.prototype);
+        return instance;
+    }
+    HttpOutgoing.from = from;
+})(HttpOutgoing || (HttpOutgoing = {}));

package/esm/http/interfaces/node-incoming-message.interface.js

@@ -0,0 +1,60 @@
+import { Readable } from 'stream';
+import { HTTPParser } from '@browsery/http-parser';
+import { isAsyncIterable, isIterable } from '@opra/common';
+import { CRLF, kHttpParser, NodeIncomingMessageHost } from '../impl/node-incoming-message.host.js';
+import { concatReadable } from '../utils/concat-readable.js';
+/**
+ *
+ * @namespace NodeIncomingMessage
+ */
+export var NodeIncomingMessage;
+(function (NodeIncomingMessage) {
+    /**
+     * Creates a new NodeIncomingMessage from given argument
+     * @param iterable
+     */
+    function from(iterable) {
+        if (typeof iterable === 'object' && !(isIterable(iterable) || isAsyncIterable(iterable)))
+            return new NodeIncomingMessageHost(iterable);
+        const msg = new NodeIncomingMessageHost();
+        const parser = (msg[kHttpParser] = new HTTPParser(HTTPParser.REQUEST));
+        let bodyChunks;
+        parser[HTTPParser.kOnHeadersComplete] = (info) => {
+            msg.httpVersionMajor = info.versionMajor;
+            msg.httpVersionMinor = info.versionMinor;
+            msg.rawHeaders = info.headers;
+            msg.method = HTTPParser.methods[info.method];
+            msg.url = info.url;
+            msg.emit('headers');
+        };
+        parser[HTTPParser.kOnHeaders] = (trailers) => {
+            msg.rawTrailers = trailers;
+        };
+        parser[HTTPParser.kOnBody] = (chunk, offset, length) => {
+            bodyChunks = bodyChunks || [];
+            bodyChunks.push(chunk.subarray(offset, offset + length));
+        };
+        const readable = concatReadable(Readable.from(iterable), Readable.from(CRLF));
+        msg.once('finish', () => {
+            parser.finish();
+            msg.complete = true;
+            if (bodyChunks)
+                msg.body = Buffer.concat(bodyChunks);
+        });
+        readable.pipe(msg);
+        return msg;
+    }
+    NodeIncomingMessage.from = from;
+    /**
+     * Creates a new NodeIncomingMessage from given argument
+     * @param iterable
+     */
+    async function fromAsync(iterable) {
+        return new Promise((resolve, reject) => {
+            const msg = from(iterable);
+            msg.once('finish', () => resolve(msg));
+            msg.once('error', error => reject(error));
+        });
+    }
+    NodeIncomingMessage.fromAsync = fromAsync;
+})(NodeIncomingMessage || (NodeIncomingMessage = {}));

package/esm/http/interfaces/node-outgoing-message.interface.js

@@ -0,0 +1,12 @@
+import { NodeOutgoingMessageHost } from '../impl/node-outgoing-message.host.js';
+/**
+ *
+ * @namespace NodeOutgoingMessage
+ */
+export var NodeOutgoingMessage;
+(function (NodeOutgoingMessage) {
+    function from(init) {
+        return new NodeOutgoingMessageHost(init);
+    }
+    NodeOutgoingMessage.from = from;
+})(NodeOutgoingMessage || (NodeOutgoingMessage = {}));

package/esm/http/utils/body-reader.js

@@ -0,0 +1,210 @@
+import { Base64Decode } from 'base64-stream';
+import byteParser from 'bytes';
+import { parse as parseContentType } from 'content-type';
+import { EventEmitter } from 'events';
+import iconv from 'iconv-lite';
+import { Writable } from 'stream';
+import * as zlib from 'zlib';
+import typeIs from '@browsery/type-is';
+import { BadRequestError, InternalServerError, OpraHttpError } from '@opra/common';
+/**
+ *
+ * @class BodyReader
+ */
+export class BodyReader extends EventEmitter {
+    constructor(req, options) {
+        super();
+        this.req = req;
+        this._completed = false;
+        this._receivedSize = 0;
+        this.onAborted = () => this._onAborted();
+        this.onData = (chunk) => this._onData(chunk);
+        this.onEnd = (err) => this._onEnd(err);
+        this.cleanup = () => this._cleanup();
+        this.limit = options?.limit
+            ? typeof options.limit === 'number'
+                ? options.limit
+                : byteParser(options.limit)
+            : undefined;
+    }
+    async read() {
+        /* istanbul ignore next */
+        if (this._completed)
+            throw new InternalServerError({
+                message: 'Stream already read',
+                code: 'STREAM_ALREADY_READ',
+            });
+        if (!this.req.readable) {
+            throw new InternalServerError({
+                message: 'Stream is not readable',
+                code: 'STREAM_NOT_READABLE',
+            });
+        }
+        return new Promise((resolve, reject) => {
+            // eslint-disable-next-line prefer-const
+            let sizeStream;
+            this.once('finish', (error, data) => {
+                if (sizeStream)
+                    this.req.unpipe(sizeStream);
+                if (error)
+                    return reject(error);
+                resolve(data);
+            });
+            /**
+             * Check if a request has a request body.
+             * A request with a body __must__ either have `transfer-encoding`
+             * or `content-length` headers set.
+             * http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.3
+             */
+            const contentLength = parseInt(this.req.headers['content-length'] || '0', 10);
+            if (this.req.headers['transfer-encoding'] === undefined && !(contentLength && !isNaN(contentLength)))
+                return this.onEnd();
+            // check the length and limit options.
+            // note: we intentionally leave the stream paused,
+            // so users should handle the stream themselves.
+            if (this.limit != null && contentLength != null && contentLength > this.limit) {
+                return this.onEnd(new OpraHttpError({
+                    message: 'Content Too Large',
+                    code: 'HTTP.CONTENT_TOO_LARGE',
+                    details: {
+                        length: contentLength,
+                        limit: this.limit,
+                    },
+                }, 413));
+            }
+            // Pipe to a Writable stream to count received bytes
+            const _this = this;
+            sizeStream = new Writable({
+                write(chunk, encoding, callback) {
+                    if (_this._completed)
+                        return;
+                    _this._receivedSize += chunk.length;
+                    if (_this.limit != null && _this._receivedSize > _this.limit) {
+                        callback(new OpraHttpError({
+                            message: 'Content Too Large',
+                            code: 'HTTP.CONTENT_TOO_LARGE',
+                            details: {
+                                limit: _this.limit,
+                                received: _this._receivedSize,
+                            },
+                        }, 413));
+                    }
+                },
+            });
+            this.req.pipe(sizeStream);
+            let stream = BodyReader.encoderPipeline(this.req);
+            const mediaType = parseContentType(this.req.headers['content-type'] || '');
+            let charset = (mediaType.parameters.charset || '').toLowerCase();
+            if (!charset && typeIs.is(mediaType.type, ['json', 'xml', 'txt']))
+                charset = 'utf-8';
+            if (charset) {
+                const newStream = iconv.decodeStream(charset);
+                stream.pipe(newStream);
+                stream = newStream;
+            }
+            this._stream = stream;
+            // attach listeners
+            stream.on('aborted', this.onAborted);
+            stream.on('close', this.cleanup);
+            stream.on('data', this.onData);
+            stream.on('end', this.onEnd);
+            stream.on('error', this.onEnd);
+        });
+    }
+    _onEnd(error) {
+        if (this._completed)
+            return;
+        this._completed = true;
+        if (error) {
+            this._stream?.unpipe();
+            this._stream?.pause();
+        }
+        if (error)
+            this.emit('finish', error);
+        else if (Array.isArray(this._buffer))
+            this.emit('finish', error, Buffer.concat(this._buffer));
+        else
+            this.emit('finish', error, this._buffer);
+        this._cleanup();
+    }
+    _cleanup() {
+        if (this._stream) {
+            this._stream.removeListener('aborted', this.onAborted);
+            this._stream.removeListener('close', this.cleanup);
+            this._stream.removeListener('data', this.onData);
+            this._stream.removeListener('end', this.onEnd);
+            this._stream.removeListener('error', this.onEnd);
+        }
+    }
+    _onAborted() {
+        if (this._completed)
+            return;
+        this.onEnd(new BadRequestError({
+            message: 'request aborted',
+            code: 'ECONNABORTED',
+            details: {
+                length,
+                received: this._receivedSize,
+            },
+        }));
+    }
+    _onData(chunk) {
+        if (this._completed)
+            return;
+        if (typeof chunk === 'string') {
+            this._buffer = this._buffer || '';
+            this._buffer += chunk;
+        }
+        else {
+            this._buffer = this._buffer || [];
+            this._buffer.push(chunk);
+        }
+    }
+    static async read(req, options) {
+        const bodyReady = new BodyReader(req, options);
+        return bodyReady.read();
+    }
+    static encoderPipeline(req) {
+        const contentEncoding = req.headers['content-encoding'] || 'identity';
+        const contentEncodings = (Array.isArray(contentEncoding) ? contentEncoding : contentEncoding.split(/\s*,\s*/))
+            .map(s => s.toLowerCase())
+            .reverse();
+        return contentEncodings.reduce((prev, encoding) => {
+            switch (encoding) {
+                case 'gzip':
+                case 'x-gzip': {
+                    const newStream = zlib.createGunzip();
+                    prev.pipe(newStream);
+                    return newStream;
+                }
+                case 'deflate':
+                case 'x-deflate': {
+                    const newStream = zlib.createInflate();
+                    prev.pipe(newStream);
+                    return newStream;
+                }
+                case 'br': {
+                    const newStream = zlib.createBrotliDecompress();
+                    prev.pipe(newStream);
+                    return newStream;
+                }
+                case 'base64': {
+                    const newStream = new Base64Decode();
+                    prev.pipe(newStream);
+                    return newStream;
+                }
+                case 'identity':
+                    // prev.length = 0;
+                    return prev;
+                default:
+                    throw new BadRequestError({
+                        message: 'unsupported content encoding "' + encoding + '"',
+                        code: '',
+                        details: {
+                            encoding,
+                        },
+                    }, 415);
+            }
+        }, req);
+    }
+}

package/esm/http/{helpers → utils}/convert-to-headers.js

@@ -1,4 +1,4 @@
-import { ARRAY_FIELD, COMMA_DELIMITED_FIELD, matchKnownFields, SEMICOLON_DELIMITED_FIELD } from './match-known-fields.js';
+import { ARRAY_FIELD, COMMA_DELIMITED_FIELD, matchKnownFields, SEMICOLON_DELIMITED_FIELD, } from './match-known-fields.js';
 export function convertToHeaders(src, dst, joinDuplicateHeaders) {
     for (let n = 0; n < src.length; n += 2) {
         addHeaderLine(src[n], src[n + 1], dst, joinDuplicateHeaders);

package/esm/http/{helpers → utils}/convert-to-raw-headers.js

@@ -1,7 +1,6 @@
-import { ARRAY_FIELD, COMMA_DELIMITED_FIELD, matchKnownFields, SEMICOLON_DELIMITED_FIELD } from './match-known-fields.js';
+import { ARRAY_FIELD, COMMA_DELIMITED_FIELD, matchKnownFields, SEMICOLON_DELIMITED_FIELD, } from './match-known-fields.js';
 export function convertToRawHeaders(src) {
-    return Object.entries(src)
-        .reduce((a, [field, v]) => {
+    return Object.entries(src).reduce((a, [field, v]) => {
         const [name, flag] = matchKnownFields(field);
         if (flag === ARRAY_FIELD) {
             if (Array.isArray(v))