@depup/zone-eu__mailsplit 5.4.16-depup.0

package/LICENSE.EUPL-1.2

@@ -0,0 +1,153 @@
+EUROOPA LIIDU TARKVARA VABA KASUTUSE LITSENTS v. 1.2
+EUPL © Euroopa Liit 2007, 2016
+
+Euroopa Liidu tarkvara vaba kasutuse litsents („EUPL“) kehtib allpool määratletud teose suhtes, mida levitatakse vastavalt käesoleva litsentsi tingimustele. Teost on keelatud kasutada muul viisil kui vastavalt käesoleva litsentsi tingimustele niivõrd, kuivõrd sellise kasutamise suhtes kehtivad teose autoriõiguse omaja õigused).
+
+Teost levitatakse vastavalt käesoleva litsentsi tingimustele, kui allpool määratletud litsentsiandja paneb vahetult teose autoriõiguse märke järele järgmise märke:
+
+Litsentsitud EUPL alusel
+
+või on muul viisil väljendanud soovi litsentsida originaalteos EUPL alusel.
+
+1. Mõisted
+Käesolevas litsentsis kasutatakse järgmisi mõisteid:
+
+— „litsents“ – käesolev litsents;
+
+— „originaalteos“ – teos või tarkvara, mida litsentsiandja käesoleva litsentsi alusel levitab või edastab ning mis on kättesaadav lähtekoodina ja teatavatel juhtudel ka täitmiskoodina;
+
+— „tuletatud teos“ – teos või tarkvara, mida litsentsisaajal on olnud võimalik luua tuginedes originaalteosele või selle muudetud versioonile. Käesolevas litsentsis ei määratleta muudatuse ulatust või sõltuvust originaalteosest, mis on vajalik selleks, et klassifitseerida teos tuletatud teoseks; selline ulatus määratakse kindlaks vastavalt artiklis 15 nimetatud riigis kehtivatele autoriõigust käsitlevatele õigusaktidele;
+
+— „teos“ – originaalteos või sellest tuletatud teosed;
+
+— „lähtekood“ – teose inimloetav vorm, mida inimestel on kõige lihtsam uurida ja muuta;
+
+— „täitmiskood“ – igasugune kood, mille on tavaliselt koostanud arvuti ja mis on mõeldud arvuti poolt programmina tõlgendamiseks;
+
+— „litsentsiandja“ – füüsiline või juriidiline isik, kes levitab või edastab teost litsentsi alusel;
+
+— „edasiarendaja“ – füüsiline või juriidiline isik, kes muudab teost litsentsi alusel või osaleb muul moel tuletatud teose loomises;
+
+— „litsentsisaaja“ või „Teie“ – iga füüsiline või juriidiline isik, kes kasutab teost ükskõik mis moel vastavalt litsentsi tingimustele;
+
+— „levitamine“ või „edastamine“ – teose koopiate müümine, teisele isikule andmine, laenutamine, rentimine, levitamine, edastamine, ülekandmine või teose koopiate või selle oluliste funktsioonide muul viisil teistele füüsilistele või juriidilistele isikutele kättesaadavaks tegemine võrgus või võrguväliselt.
+
+2. Litsentsiga antavate õiguste ulatus
+Käesolevaga annab litsentsiandja Teile ülemaailmse, tasuta, all-litsentsi andmise õigusega lihtlitsentsi, mille alusel võite teha originaalteose autoriõiguse kehtivusaja jooksul järgmist:
+
+— kasutada teost mis tahes eesmärgil ja mis tahes viisil,
+
+— teost reprodutseerida,
+
+— teost muuta ja luua teosel põhinevaid tuletatud teoseid,
+
+— teost või selle koopiaid üldsusele edastada, sealhulgas neid kättesaadavaks teha või eksponeerida, samuti avalikult esitada,
+
+— teost või selle koopiaid levitada,
+
+— teost või selle koopiaid laenutada ja rentida,
+
+— anda all-litsentse teose või selle koopiate suhtes kehtivate õiguste kohta.
+
+Neid õigusi võib teostada mistahes praegu tuntud või hiljem leiutatud keskkonnas, toel või formaadis, ja sellises ulatuses, nagu lubab kohaldatav õigus.
+
+Riikides, kus kehtivad isiklikud õigused, loobub litsentsiandja seadusega lubatud ulatuses oma õigusest teostada isiklikke õigusi, et oleks võimalik eespool loetletud varalisi õigusi litsentsida.
+
+Litsentsiandja annab litsentsisaajale tasuta lihtlitsentsi kõigi litsentsiandjale kuuluvate patentide kasutamiseks ulatuses, mis on vajalik teose suhtes käesoleva litsentsiga antud õiguste kasutamiseks.
+
+3. Lähtekoodi edastamine
+Litsentsiandja võib teose kättesaadavaks teha kas lähtekoodi või täitmiskoodi kujul. Kui teos tehakse kättesaadavaks täitmiskoodi kujul, lisab litsentsiandja igale tema poolt levitatavale teose koopiale lähtekoodi masinloetava koopia või näitab teose autoriõiguse märke järele lisatud märkega ära hoidla, kust lähtekood on kergesti ja tasuta kättesaadav seni, kuni litsentsiandja jätkab teose levitamist või edastamist.
+
+4. Autoriõiguse piiramine
+Käesolev litsents ei võta litsentsisaajalt võimalusi, mis tulenevad teose õiguste omaja ainuõiguste suhtes kehtestatud eranditest või ainuõiguste piiramisest, nende õiguste ammendumisest või muudest nende õiguste suhtes kohaldatavatest piirangutest.
+
+5. Litsentsisaaja kohustused
+Eespool nimetatud õigused antakse litsentsisaajale tingimusel, et ta peab kinni teatavatest piirangutest ja täidab teatavaid talle pandud kohustusi. Need kohustused on järgmised:
+
+Õigus autorsusele. Litsentsisaaja hoiab puutumatuna kõik autoriõiguse, patentide ja kaubamärkide kohta käivad märked ja kõik märked, mis viitavad litsentsile ja garantii puudumisele. Litsentsisaaja peab teose iga tema poolt levitatavale või edastatavale koopiale lisama nimetatud märgete koopiad ja litsentsi koopia. Litsentsisaaja peab tagama, et iga tuletatud teos kannab selget märget selle kohta, et teost on muudetud ja muutmise kuupäeva.
+Klausel vaba kasutamise tagamise kohta (copyleft). Kui litsentsisaaja levitab või edastab originaalteose või tuletatud teoste koopiaid, toimub see levitamine või edastamine vastavalt käesoleva litsentsi tingimustele või käesoleva litsentsi hilisema versiooni tingimustele, välja arvatud juhul, kui originaalteost levitatakse ainult vastavalt litsentsi käesolevale versioonile (näiteks märkides „ainult EUPL v.1.2“). Litsentsisaaja ei tohi (litsentsiandjaks saades) teosele või tuletatud teosele lisada ega kehtestada mingeid lisatingimusi, mis muudavad või piiravad litsentsi tingimusi.
+Ühilduvuse klausel. Kui litsentsisaaja levitab või edastab tuletatud teoseid või nende koopiaid, mis põhinevad nii teosel kui ka teisel, käesoleva litsentsiga ühilduva litsentsi alusel litsentsitud teosel, võib see levitamine või edastamine toimuda vastavalt nimetatud ühilduva litsentsi tingimustele. Käesolevas klauslis tähendab „ühilduv litsents“ käesoleva litsentsi lisas loetletud litsentse. Kui litsentsisaaja ühilduvale litsentsile vastavad kohustused on vastuolus tema kohustustega vastavalt käesolevale litsentsile, loetakse kehtivaks ühilduva litsentsi kohased kohustused.
+Lähtekoodi lisamine. Teose koopiate levitamisel või edastamisel lisab litsentsisaaja igale koopiale lähtekoodi masinloetava koopia või näitab ära hoidla, kust lähtekood on kergesti ja tasuta kättesaadav seni, kuni litsentsisaaja jätkab teose levitamist või edastamist.
+Õiguskaitse. Käesoleva litsentsiga ei anta luba kasutada litsentsiandja ärinimesid, kaubamärke, teenindusmärke või nimesid, välja arvatud juhul, kui see on vajalik mõistlikuks ja tavapäraseks kasutamiseks teose päritolu kirjeldamisel ja autoriõiguse märke sisu reprodutseerimisel.
+6. Autorsuse ahel
+Esialgne litsentsiandja tagab, et käesoleva litsentsiga antav autoriõigus originaalteosele kuulub talle või on talle litsentsitud ja et tal on õigus seda litsentsiga edasi anda.
+
+Iga edasiarendaja tagab, et autoriõigus tema poolt teosele tehtavatele muudatustele kuulub talle või on talle litsentsitud ja et tal on õigus litsentsi anda.
+
+Iga kord, kui Te võtate vastu litsentsi, annavad esialgne litsentsiandja ja hilisemad edasiarendajad Teile litsentsi nende osaluse kasutamiseks teoses vastavalt käesoleva litsentsi tingimustele.
+
+7. Garantii puudumine
+Teos on veel pooleli ja arvukad edasiarendajad parendavad seda järjepidevalt. See ei ole lõpetatud teos ja võib seetõttu sisaldada defekte ja programmivigu, mis on omased seda liiki arendustegevusele.
+
+Seetõttu levitatakse teost litsentsi alusel „sellisena, nagu see on“ ilma teose suhtes kehtiva garantiita, muu hulgas garantiita kaubandusliku kvaliteedi kohta, garantiita sobivuse kohta mingi kindla eesmärgi jaoks, garantiita defektide ja vigade puudumise kohta, garantiita täpsuse kohta ja selle kohta, et ei ole rikutud muid intellektuaalse omandi õigusi peale käesoleva litsentsi artiklis 6 nimetatud autoriõiguse.
+
+Käesolev garantii puudumise klausel on litsentsi oluline osa ja teosele õiguste andmise eeltingimus.
+
+8. Vastutuse välistamine
+Välja arvatud tahtliku õiguserikkumise või füüsilistele isikutele tekitatud otsese kahju puhul, ei vastuta litsentsiandja mitte mingil juhul litsentsi või teose kasutamise tagajärjel tekkinud mistahes otsese või kaudse, varalise või moraalse kahju eest, muu hulgas maineväärtuse langusest tekkinud kahju, tööseisakute, arvutirikke ja talitlushäirete, andmete kadumise ja ärikahju eest, isegi juhul kui litsentsiandjat on sellise kahju tekkimise võimalikkusest teavitatud. Litsentsiandja vastutab siiski vastavalt tootevastutust käsitlevatele õigusaktidele niivõrd, kuivõrd need õigusaktid on teose suhtes kohaldatavad.
+
+9. Lisakokkulepped
+Teose levitamisel võite Te sõlmida lisakokkuleppe, milles määratakse kindlaks käesoleva litsentsiga vastavuses olevad kohustused või teenused. Kuid kui olete nõus võtma kohustusi, võite Te tegutseda ainult iseenda nimel ja vastutusel, mitte esialgse litsentsiandja või teiste edasiarendajate nimel, ja ainult juhul, kui Te nõustute vabastama edasiarendajad vastutusest, kaitsma ja hoidma neid kahju tekkimise eest vastutuse või nõuete osas, mida nende vastu võidakse esitada selle tagajärjel, et Teie pakute garantiid või võtate lisavastutuse.
+
+10. Litsentsiga nõustumine
+Käesoleva litsentsi sätetega saab nõustuda, klõpsates ikoonile „Nõustun“ litsentsi teksti näitava akna all või väljendades nõusolekut muul sarnasel viisil vastavalt kehtivatele õigusaktidele. Sellele ikoonile klõpsates väljendate selgelt ja pöördumatult oma nõusolekut käesoleva litsentsi ja kõigi selle tingimuste suhtes.
+
+Samuti nõustute pöördumatult käesoleva litsentsi ja kõigi selle tingimustega, kui teostate Teile käesoleva litsentsi artikliga 2 antud õigusi, näiteks kasutate teost, loote tuletatud teose või levitate või edastate teost või selle koopiaid.
+
+11. Üldsuse teavitamine
+Juhul, kui Te kasutate teose levitamiseks või edastamiseks elektroonilisi sidevahendeid (näiteks võimaldate teose allalaadimist veebisaidilt), tuleb levitamiskanalil või andmekandjal (näiteks veebisaidil) teha üldsusele kättesaadavaks vähemalt kohaldatava õiguse alusel kohustuslik teave litsentsiandja ja litsentsi kohta ning selle kohta, kuidas see on litsentsisaajale kättesaadav, litsentsilepingu sõlmimise kohta ja selle kohta, kuidas litsentsisaaja saab litsentsi säilitada ja reprodutseerida.
+
+12. Litsentsi lõppemine
+Litsents ja sellega antud õigused lõppevad automaatselt juhul, kui litsentsisaaja rikub litsentsi tingimusi.
+
+Sellise lõppemise korral ei lõpe ühegi sellise isiku litsents, kes sai teose litsentsisaajalt vastavalt litsentsi tingimustele, juhul kui see isik täidab jätkuvalt litsentsi tingimusi.
+
+13. Muud sätted
+Ilma et see piiraks litsentsi artikli 9 kohaldamist, sisaldab litsents kogu kokkulepet, mis osapoolte vahel seose teosega on.
+
+Kui mõni litsentsi säte on vastavalt kohaldatavatele õigusaktidele kehtetu või seda ei ole võimalik jõustada, ei mõjuta see litsentsi kui terviku kehtivust ega jõustatavust. Sellist sätet tõlgendatakse või muudetakse nii nagu vaja, et see kehtiks ja saaks tagada selle täitmise.
+
+Euroopa Komisjon võib avaldada käesoleva litsentsi muid keeleversioone või uusi versioone või lisa uuendatud versioone, kuivõrd see on vajalik ja mõistlik, vähendamata sellega litsentsiga antavate õiguste ulatust. Litsentsi uued versioonid avaldatakse kordumatu versiooninumbriga.
+
+Käesoleva litsentsi kõik keeleversioonid, mille Euroopa Komisjon on heaks kiitnud, on võrdväärsed. Osapooled võivad kasutada enda valitud keeleversiooni.
+
+14. Kohtualluvus
+Ilma et see piiraks konkreetse osapooltevahelise kokkuleppe kohaldamist,
+
+— kuuluvad käesoleva litsentsi tõlgendamisest tulenevad kohtuvaidlused Euroopa Liidu institutsioonide, organite, büroode või asutuste kui litsentsiandja ja mistahes litsentsisaaja vahel Euroopa Liidu Kohtu pädevusse, nagu on sätestatud Euroopa Liidu toimimise lepingu artiklis 272,
+
+— kuuluvad käesoleva litsentsi tõlgendamisest tulenevad kohtuvaidlused muude osapoolte vahel selle pädeva kohtu ainupädevusse, kelle tööpiirkonnas asub litsentsiandja elukoht või peamine tegevuskoht.
+
+15. Kohaldatav õigus
+Ilma et see piiraks konkreetse osapooltevahelise kokkuleppe kohaldamist,
+
+— kohaldatakse käesoleva litsentsi suhtes selle Euroopa Liidu liikmesriigi õigust, kus paikneb litsentsiandja peakorter, elukoht või asukoht,
+
+— kohaldatakse litsentsi suhtes Belgia õigust, kui litsentsiandja peakorter, elukoht või asukoht asub väljaspool Euroopa Liidu liikmesriike.
+
+Liide
+Euroopa Liidu tarkvara vaba kasutuse litsentsi artiklis 5 osutatud „ühilduvad litsentsid“ on järgmised:
+
+— GNU General Public License (GPL) v. 2, v. 3
+
+— GNU Affero General Public License (AGPL) v. 3
+
+— Open Software License (OSL) v. 2.1, v. 3.0
+
+— Eclipse Public License (EPL) v. 1.0
+
+— CeCILL v. 2.0, v. 2.1
+
+— Mozilla Public Licence (MPL) v. 2
+
+— GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3
+
+— Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) muude teoste puhul peale tarkvara
+
+— European Union Public Licence (EUPL) v. 1.1, v. 1.2
+
+— Québec Free and Open-Source Licence – Reciprocity (LiLiQ-R) or Strong Reciprocity (LiLiQ-R+)
+
+Euroopa Komisjon võib käesolevat lisa ajakohastada loetletud litsentside hilisemate versioonidega ilma, et peaks selleks koostama EUPLi uue versiooni, eeldusel et nende litsentsidega tagatakse käesoleva litsentsi artiklis 2 sätestatud õigused ja kaitstakse hõlmatud lähtekoodi eksklusiivse omastamise eest.
+
+Kõigi muude käesoleva liite muudatuste või täienduste jaoks on vaja koostada EUPLi uus versioon.

package/LICENSE.MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2011-2019, 2024 Andris Reinman and Zone Media OÜ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# @depup/zone-eu__mailsplit
+
+> Dependency-bumped version of [@zone-eu/mailsplit](https://www.npmjs.com/package/@zone-eu/mailsplit)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/zone-eu__mailsplit
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [@zone-eu/mailsplit](https://www.npmjs.com/package/@zone-eu/mailsplit) @ 5.4.16 |
+| Processed | 2026-09-13 |
+| Smoke test | passed |
+| Deps updated | 0 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/@zone-eu/mailsplit
+
+License inherited from the original package.

package/changes.json

@@ -0,0 +1,5 @@
+{
+  "bumped": {},
+  "timestamp": "2026-09-13T00:56:35.730Z",
+  "totalUpdated": 0
+}

package/index.d.ts

@@ -0,0 +1,97 @@
+/// <reference types="node" />
+
+import Splitter = require('./lib/message-splitter');
+import Joiner = require('./lib/message-joiner');
+import Rewriter = require('./lib/node-rewriter');
+import Streamer = require('./lib/node-streamer');
+import ChunkedPassthrough = require('./lib/chunked-passthrough');
+import Headers = require('./lib/headers');
+import MimeNode = require('./lib/mime-node');
+
+export {
+    /** Splits raw message bytes into MIME node and content chunks. */
+    Splitter,
+
+    /** Joins MIME node and content chunks back into raw message bytes. */
+    Joiner,
+
+    /** Rewrites body content for MIME nodes selected by a filter function. */
+    Rewriter,
+
+    /** Streams decoded body content for MIME nodes selected by a filter function. */
+    Streamer,
+
+    /** Buffers byte input and emits larger Buffer chunks. */
+    ChunkedPassthrough,
+
+    /** Parses, mutates, and rebuilds message header blocks. */
+    Headers,
+
+    /** Represents one parsed MIME node and its header/body metadata. */
+    MimeNode
+};
+
+export type {
+    /** Value that is either present as `T` or explicitly unavailable as `false`. */
+    Maybe,
+
+    /** Single item in an IMAP-style MIME part number. */
+    PartNumberItem,
+
+    /** IMAP-style path to a MIME part. */
+    PartNumber,
+
+    /** Options passed through to libmime instances. */
+    LibmimeOptions,
+
+    /** Configuration for `Splitter` and MIME node parsing. */
+    SplitterOptions,
+
+    /** Configuration for `ChunkedPassthrough`. */
+    ChunkedPassthroughOptions,
+
+    /** Configuration for format=flowed decoding. */
+    FlowedDecoderOptions,
+
+    /** Parsed raw header line with a normalized lookup key. */
+    HeaderLine,
+
+    /** Decoded structured header value. */
+    DecodedHeader,
+
+    /** Data or body bytes emitted by `Splitter`. */
+    MessageChunk,
+
+    /** Sentinel input used internally by rewriter/streamer transforms. */
+    EmptyChunk,
+
+    /** Object emitted by `Splitter`. */
+    SplitterChunk,
+
+    /** Object accepted by rewriter and streamer transforms. */
+    RewriterInput,
+
+    /** Predicate used to select MIME nodes. */
+    FilterFunc,
+
+    /** Error object that may include a Node-style string code. */
+    ErrorWithCode,
+
+    /** Callback that resumes processing after a selected node stream ends. */
+    ContinueCallback,
+
+    /** Content transform stream used for decoded or encoded node bodies. */
+    ContentStream,
+
+    /** Decoder stream with an internal readable-state guard. */
+    DecoderStream,
+
+    /** Internal splitter grouping state. */
+    SplitterGroup,
+
+    /** Payload emitted with `Rewriter`'s `node` event. */
+    RewriterNode,
+
+    /** Payload emitted with `Streamer`'s `node` event. */
+    StreamerNode
+} from './lib/types';

package/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const MessageSplitter = require('./lib/message-splitter');
+const MessageJoiner = require('./lib/message-joiner');
+const NodeRewriter = require('./lib/node-rewriter');
+const NodeStreamer = require('./lib/node-streamer');
+const Headers = require('./lib/headers');
+const ChunkedPassthrough = require('./lib/chunked-passthrough');
+const MimeNode = require('./lib/mime-node');
+
+/** @type {typeof import('.')} */
+module.exports = {
+    Splitter: MessageSplitter,
+    Joiner: MessageJoiner,
+    Rewriter: NodeRewriter,
+    Streamer: NodeStreamer,
+    ChunkedPassthrough,
+    Headers,
+    MimeNode
+};

package/lib/chunked-passthrough.d.ts

@@ -0,0 +1,59 @@
+import { Transform } from 'node:stream';
+import type { ChunkedPassthroughOptions } from './types';
+
+/** Transform stream that buffers byte input and emits larger Buffer chunks. */
+declare class ChunkedPassthrough extends Transform {
+    /**
+     * Creates a chunking passthrough transform that accepts Buffer input and emits Buffer chunks.
+     *
+     * @param options Optional chunk size configuration.
+     */
+    constructor(options?: ChunkedPassthroughOptions);
+
+    /**
+     * Registers a listener for buffered byte chunks.
+     *
+     * @param event Event name.
+     * @param listener Receives each buffered Buffer chunk.
+     * @returns This passthrough instance.
+     */
+    on(event: 'data', listener: (data: Buffer) => void): this;
+
+    /**
+     * Registers a one-time listener for the next buffered byte chunk.
+     *
+     * @param event Event name.
+     * @param listener Receives the next buffered Buffer chunk.
+     * @returns This passthrough instance.
+     */
+    once(event: 'data', listener: (data: Buffer) => void): this;
+
+    /**
+     * Adds a listener for buffered byte chunks.
+     *
+     * @param event Event name.
+     * @param listener Receives each buffered Buffer chunk.
+     * @returns This passthrough instance.
+     */
+    addListener(event: 'data', listener: (data: Buffer) => void): this;
+
+    /**
+     * Prepends a listener for buffered byte chunks.
+     *
+     * @param event Event name.
+     * @param listener Receives each buffered Buffer chunk.
+     * @returns This passthrough instance.
+     */
+    prependListener(event: 'data', listener: (data: Buffer) => void): this;
+
+    /**
+     * Emits a buffered byte chunk.
+     *
+     * @param event Event name.
+     * @param data Buffer chunk to emit.
+     * @returns `true` when the event had listeners.
+     */
+    emit(event: 'data', data: Buffer): boolean;
+}
+
+export = ChunkedPassthrough;

package/lib/chunked-passthrough.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { Transform } = require('stream');
+
+/**
+ * Transform stream that buffers byte input and emits larger Buffer chunks.
+ */
+class ChunkedPassthrough extends Transform {
+    /**
+     * @param {import('..').ChunkedPassthroughOptions} [options]
+     */
+    constructor(options = {}) {
+        let config = {
+            readableObjectMode: true,
+            writableObjectMode: false
+        };
+        super(config);
+        this.chunkSize = options.chunkSize || 64 * 1024; // 64KB default
+        this.buffer = Buffer.alloc(0);
+    }
+
+    /**
+     * @param {Buffer} chunk
+     * @param {BufferEncoding} encoding
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
+    _transform(chunk, encoding, callback) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+
+        if (this.buffer.length >= this.chunkSize) {
+            this.push(this.buffer);
+            this.buffer = Buffer.alloc(0);
+        }
+
+        callback();
+    }
+
+    /**
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
+    _flush(callback) {
+        // Send remaining data
+        if (this.buffer.length > 0) {
+            this.push(this.buffer);
+            this.buffer = Buffer.alloc(0);
+        }
+        callback();
+    }
+}
+
+module.exports = ChunkedPassthrough;

package/lib/flowed-decoder.d.ts

@@ -0,0 +1,59 @@
+import { Transform } from 'node:stream';
+import type { FlowedDecoderOptions } from './types';
+
+/** Transform stream that decodes `text/plain; format=flowed` content. */
+declare class FlowedDecoder extends Transform {
+    /**
+     * Creates a flowed text decoder that accepts encoded text bytes and emits decoded Buffer chunks.
+     *
+     * @param config Optional flowed text and charset decoding settings.
+     */
+    constructor(config?: FlowedDecoderOptions);
+
+    /**
+     * Registers a listener for decoded flowed text bytes.
+     *
+     * @param event Event name.
+     * @param listener Receives decoded Buffer chunks.
+     * @returns This decoder instance.
+     */
+    on(event: 'data', listener: (data: Buffer) => void): this;
+
+    /**
+     * Registers a one-time listener for the next decoded flowed text chunk.
+     *
+     * @param event Event name.
+     * @param listener Receives the next decoded Buffer chunk.
+     * @returns This decoder instance.
+     */
+    once(event: 'data', listener: (data: Buffer) => void): this;
+
+    /**
+     * Adds a listener for decoded flowed text bytes.
+     *
+     * @param event Event name.
+     * @param listener Receives decoded Buffer chunks.
+     * @returns This decoder instance.
+     */
+    addListener(event: 'data', listener: (data: Buffer) => void): this;
+
+    /**
+     * Prepends a listener for decoded flowed text bytes.
+     *
+     * @param event Event name.
+     * @param listener Receives decoded Buffer chunks.
+     * @returns This decoder instance.
+     */
+    prependListener(event: 'data', listener: (data: Buffer) => void): this;
+
+    /**
+     * Emits a decoded flowed text chunk.
+     *
+     * @param event Event name.
+     * @param data Buffer chunk to emit.
+     * @returns `true` when the event had listeners.
+     */
+    emit(event: 'data', data: Buffer): boolean;
+}
+
+export = FlowedDecoder;

package/lib/flowed-decoder.js

@@ -0,0 +1,72 @@
+'use strict';
+
+// Helper class to decode format=flowed text nodes
+
+const Transform = require('stream').Transform;
+const libmime = require('libmime');
+
+/** @typedef {import('..').FlowedDecoderOptions} FlowedDecoderOptions */
+
+const Libmime = /** @type {any} */ (libmime.Libmime);
+
+/**
+ * Transform stream that decodes text/plain format=flowed content.
+ *
+ * @param {FlowedDecoderOptions} [config] Flowed text and charset decoding settings.
+ */
+class FlowedDecoder extends Transform {
+    /**
+     * @param {FlowedDecoderOptions} [config] Flowed text and charset decoding settings.
+     */
+    constructor(config) {
+        super();
+        this.config = config || {};
+
+        /** @type {Buffer[]} */
+        this.chunks = [];
+        this.chunklen = 0;
+
+        this.libmime = new Libmime({ Iconv: this.config.Iconv });
+    }
+
+    /**
+     * @param {Buffer | string} chunk
+     * @param {BufferEncoding} encoding
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
+    _transform(chunk, encoding, callback) {
+        if (!chunk || !chunk.length) {
+            return callback();
+        }
+
+        if (typeof chunk === 'string') {
+            chunk = Buffer.from(chunk, encoding);
+        }
+
+        this.chunks.push(chunk);
+        this.chunklen += chunk.length;
+
+        callback();
+    }
+
+    /**
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
+    _flush(callback) {
+        if (this.chunklen) {
+            let currentBody = Buffer.concat(this.chunks, this.chunklen);
+
+            if (this.config.encoding === 'base64') {
+                currentBody = Buffer.from(currentBody.toString('binary'), 'base64');
+            }
+
+            let content = this.libmime.decodeFlowed(currentBody.toString('binary'), this.config.delSp);
+            this.push(Buffer.from(content, 'binary'));
+        }
+        return callback();
+    }
+}
+
+module.exports = FlowedDecoder;