@social-mail/shared 1.0.3

package/src/mime-parser/encoder/RawBuffer.js

@@ -0,0 +1,60 @@
+const toBuffer = (
+    /** @type {string} */ text
+    ) => {
+    const bytes = new Uint8Array(text.length);
+    for (let index = 0; index < text.length; index++) {
+        bytes[index] = text.charCodeAt(index);
+    }
+    return bytes.buffer;
+};
+
+export const RawBuffer = {
+    decode: (
+        /** @type {string} */ bytesAsString,
+        /** @type {string} */ encoding = "utf-8"
+    ) => {
+        if (!encoding) {
+            return bytesAsString;
+        }
+        const te = new TextDecoder(encoding);
+        return te.decode(toBuffer(bytesAsString));
+    },
+
+    encode: (
+        /** @type {string} */ text,
+        /** @type {string} */ encoding = "utf-8"
+    ) => {
+        if (!(/utf\-?8/i.test(encoding))) {
+            throw new Error(`Encoding ${encoding} not supported`);
+        }
+        const te = new TextEncoder();
+        const array = te.encode(text);
+        const a = [];
+        for (const iterator of array) {
+            a.push(String.fromCharCode(iterator));
+        }
+        return a.join("");
+    },
+
+    toBase64Async(
+        /** @type {Blob} */ blob,
+        asDataUrl = false
+    ) {
+        return new Promise<string>((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onerror = () => {
+            reject(reader.error);
+        };
+        reader.onload = () => {
+            const /** @type {string} */ text = reader.result;
+            if (asDataUrl) {
+                resolve(text);
+                return;
+            }
+            const index = text.indexOf(",");
+            resolve(text.substring(index + 1));
+        };
+        reader.readAsDataURL(blob);
+        });
+    }
+};

package/src/mime-parser/encoder/base64-to-blob.js

@@ -0,0 +1,26 @@
+/**
+ * 
+ * @param {string} base64Data 
+ * @param {string} contentType 
+ * @returns 
+ */
+export function base64toBlob(base64Data, contentType) {
+    contentType = contentType || '';
+    const sliceSize = 1024;
+    const byteCharacters = atob(base64Data);
+    const bytesLength = byteCharacters.length;
+    const slicesCount = Math.ceil(bytesLength / sliceSize);
+    const byteArrays = new Array(slicesCount);
+
+    for (let sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {
+        const begin = sliceIndex * sliceSize;
+        const end = Math.min(begin + sliceSize, bytesLength);
+
+        const bytes = new Array(end - begin);
+        for (let offset = begin, i = 0; offset < end; ++i, ++offset) {
+            bytes[i] = byteCharacters[offset].charCodeAt(0);
+        }
+        byteArrays[sliceIndex] = new Uint8Array(bytes);
+    }
+    return new Blob(byteArrays, { type: contentType });
+}

package/src/mime-parser/encoder/quoted-printable.js

@@ -0,0 +1,118 @@
+// Original Source Code: https://github.com/mathiasbynens/quoted-printable/blob/master/quoted-printable.js
+
+
+const stringFromCharCode = String.fromCharCode;
+const decode = function(input) {
+    return input
+        // https://tools.ietf.org/html/rfc2045#section-6.7, rule 3:
+        // “Therefore, when decoding a `Quoted-Printable` body, any trailing white
+        // space on a line must be deleted, as it will necessarily have been added
+        // by intermediate transport agents.”
+        .replace(/[\t\x20]$/gm, '')
+        // Remove hard line breaks preceded by `=`. Proper `Quoted-Printable`-
+        // encoded data only contains CRLF line  endings, but for compatibility
+        // reasons we support separate CR and LF too.
+        .replace(/=(?:\r\n?|\n|$)/g, '')
+        // Decode escape sequences of the form `=XX` where `XX` is any
+        // combination of two hexidecimal digits. For optimal compatibility,
+        // lowercase hexadecimal digits are supported as well. See
+        // https://tools.ietf.org/html/rfc2045#section-6.7, note 1.
+        .replace(/=([a-fA-F0-9]{2})/g, function($0, $1) {
+            const codePoint = parseInt($1, 16);
+            return stringFromCharCode(codePoint);
+        });
+};
+
+const handleTrailingCharacters =
+    function(
+        /** @type {string} */
+        text) {
+    return text
+        .replace(/\x20$/, '=20') // Handle trailing space.
+        .replace(/\t$/, '=09'); // Handle trailing tab.
+};
+
+const regexUnsafeSymbols = /[\0-\x08\n-\x1F=\x7F-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+const encode = function(text) {
+
+    // Encode symbols that are definitely unsafe (i.e. unsafe in any context).
+    const encoded = text.replace(regexUnsafeSymbols, function(symbol) {
+        if (symbol > '\xFF') {
+            throw RangeError(
+                '`quotedPrintable.encode()` expects extended ASCII input only. ' +
+                'Don\u2019t forget to encode the input first using a character ' +
+                'encoding like UTF-8.'
+            );
+        }
+        const codePoint = symbol.charCodeAt(0);
+        const hexadecimal = codePoint.toString(16).toUpperCase();
+        return '=' + ('0' + hexadecimal).slice(-2);
+    });
+
+    const LINE_LENGTH = 75;
+
+    // Limit lines to 76 characters (not counting the CRLF line endings).
+    const lines = encoded.split(/\r\n?|\n/g);
+    let lineIndex = -1;
+    const lineCount = lines.length;
+    const result = [];
+    let buffer;
+    while (++lineIndex < lineCount) {
+        const line = lines[lineIndex];
+        // Leave room for the trailing `=` for soft line breaks.
+        let index = 0;
+        const length = line.length;
+        while (index < length) {
+            buffer = encoded.slice(index, index + LINE_LENGTH);
+            // If this line ends with `=`, optionally followed by a single uppercase
+            // hexadecimal digit, we broke an escape sequence in half. Fix it by
+            // moving these characters to the next line.
+            if (/=$/.test(buffer)) {
+                buffer = buffer.slice(0, LINE_LENGTH - 1);
+                index += LINE_LENGTH - 1;
+            } else if (/=[A-F0-9]$/.test(buffer)) {
+                buffer = buffer.slice(0, LINE_LENGTH - 2);
+                index += LINE_LENGTH - 2;
+            } else {
+                index += LINE_LENGTH;
+            }
+            result.push(buffer);
+        }
+    }
+
+    // Encode space and tab characters at the end of encoded lines. Note that
+    // with the current implementation, this can only occur at the very end of
+    // the encoded string — every other line ends with `=` anyway.
+    const lastLineLength = buffer.length;
+    if (/[\t\x20]$/.test(buffer)) {
+        // There’s a space or a tab at the end of the last encoded line. Remove
+        // this line from the `result` array, as it needs to change.
+        result.pop();
+        if (lastLineLength + 2 <= LINE_LENGTH + 1) {
+            // It’s possible to encode the character without exceeding the line
+            // length limit.
+            result.push(
+                handleTrailingCharacters(buffer)
+            );
+        } else {
+            // It’s not possible to encode the character without exceeding the line
+            // length limit. Remvoe the character from the line, and insert a new
+            // line that contains only the encoded character.
+            result.push(
+                buffer.slice(0, lastLineLength - 1),
+                handleTrailingCharacters(
+                    buffer.slice(lastLineLength - 1, lastLineLength)
+                )
+            );
+        }
+    }
+
+    // `Quoted-Printable` uses CRLF.
+    return result.join('=\r\n');
+};
+
+export const quotedPrintable = {
+    encode,
+    decode,
+    'version': '1.0.1'
+};

package/src/mime-parser/encoder/word-encoding.js

@@ -0,0 +1,43 @@
+import { RawBuffer } from "./RawBuffer.js";
+
+const isEncodedRegEx = /\=\?([^\?\s]+)\?([^\?\s]{1})\?([^\s\?]+)\?\=\s*/gm;
+
+const hexToUnicode = /(\=([0-9a-f]{2}))|(\_)/gmi;
+
+const decode = (
+    /** @type {string} */ text
+    ) => {
+    return text.replace(isEncodedRegEx, (matched, encoding, format, /** @type {string} */ buffer) => {
+        if (/b/i.test(format)) {
+            return RawBuffer.decode(atob(buffer), encoding);
+        }
+        if (/q/i.test(format)) {
+            const replaced = buffer.replace(hexToUnicode, (m, group, /** @type {string} */ code, ) => {
+                if (m === "_") {
+                    return " ";
+                }
+                return String.fromCharCode(parseInt(code, 16));
+            });
+            return RawBuffer.decode( replaced, encoding);
+        }
+        return matched;
+    });
+};
+
+const isSimpleText = /[0-9a-zA-Z\x20]/;
+
+export const wordEncoding = {
+    decode,
+
+    encode: (/** @type {string} */ word, ifNeeded = false) => {
+
+        if(ifNeeded) {
+            if(isSimpleText.test(word)) {
+                return word;
+            }
+        }
+
+        word = RawBuffer.encode(word);
+        return `=?UTF-8?B?${btoa(word)}?=`;
+    }
+};

package/src/mime-parser/parsePairs.js

@@ -0,0 +1,34 @@
+import { tokenize, tokenizeMax } from "./tokenizer.js";
+
+
+export const parsePairs = (
+    /** @type {string} */ text,
+    /** @type {string} */ emptyName) => {
+    const pairs = {
+        toString() {
+            return text;
+        }
+    };
+    for (const iterator of tokenize(text, ";")) {
+        const trimmed = iterator.trim();
+        if (!trimmed) {
+            break;
+        }
+        const items = tokenizeMax(trimmed, "=", 2).map((x) => x.trim());
+        let [key, value] = items;
+        if (items.length === 1) {
+            value = key;
+            key = emptyName ?? key;
+        }
+        try {
+            if (value.startsWith('"')) {
+                value = JSON.parse(value);
+            }
+        } catch {
+            // ignore
+        }
+        // pairs[key] = wordEncoding.decode(value);
+        pairs[key] = value;
+    }
+    return pairs;
+};

package/src/mime-parser/stream/LineStream.js

@@ -0,0 +1,85 @@
+import { tokenize } from "../tokenizer.js";
+
+export default class LineStream {
+
+    /** @type {AsyncGenerator<string, any, any>} */ g;
+
+    /**
+     * @returns {AsyncGenerator<string, any, any>}
+     */
+    async *read() {
+        const g = this.g ??= this.lines();
+        for(;;) {
+            const { value , done } = await g.next();
+            if (done) {
+                break;
+            }
+            yield value;
+        }
+    }
+
+    /** @returns {AsyncGenerator<string, any,any>} */
+    lines() {
+        throw new Error("Not Implemented");
+    }
+}
+
+export class StringLineStream extends LineStream {
+
+    /** @type {string} */ text;
+
+    constructor( /** @type {string} */ text) {
+        super();
+        this.text = text;
+    }
+
+    /** @returns {AsyncGenerator<string, any, any>} */
+    async *lines() {
+        for (const iterator of tokenize(this.text, "\n")) {
+            yield iterator;
+        }
+    }
+}
+
+export class ReadableLineStream extends LineStream {
+
+    /** @type {ReadableStream} */
+    readable;
+
+    constructor( /** @type {ReadableStream} */ readable) {
+        super();
+        this.readable = readable;
+    }
+
+    /** @returns {AsyncGenerator<string, any, any>} */
+    async *lines() {
+        const utf8Decoder = new TextDecoder("utf-8");
+        const reader = this.readable.getReader();
+        let { value: chunk, done: readerDone } = await reader.read();
+        chunk = chunk ? utf8Decoder.decode(chunk, { stream: true }) : "";
+
+        const re = /\r\n|\n|\r/gm;
+        let startIndex = 0;
+
+        for (;;) {
+            const result = re.exec(chunk);
+            if (!result) {
+                if (readerDone) {
+                    break;
+                }
+                const remainder = chunk.substr(startIndex);
+                ({ value: chunk, done: readerDone } = await reader.read());
+                chunk =
+                    remainder + (chunk ? utf8Decoder.decode(chunk, { stream: true }) : "");
+                startIndex = re.lastIndex = 0;
+                continue;
+            }
+            yield chunk.substring(startIndex, result.index);
+            startIndex = re.lastIndex;
+        }
+        if (startIndex < chunk.length) {
+            // last line didn't end in a newline char
+            yield chunk.substr(startIndex);
+        }
+    }
+}

package/src/mime-parser/stream/TextWriter.js

@@ -0,0 +1,27 @@
+export default class TextWriter {
+
+    writeLine(/** @type {string} */ line) {
+        throw new Error("Not Implemented");
+    }
+
+}
+
+export class BlobWriter extends TextWriter {
+
+    /** @type {string[]} */
+    lines = [];
+
+    writeLine(/** @type {string} */line) {
+        this.lines.push(line);
+    }
+
+    toBlob() {
+        const all = this.lines.join("\n");
+        return new Blob([all], {});
+    }
+
+    toString() {
+        return this.lines.join("\n");
+    }
+
+}

package/src/mime-parser/tokenizer.js

@@ -0,0 +1,37 @@
+export function *tokenize (
+    /** @type {string} */ text,
+    /** @type {string} */ sep = ",") {
+    let start = 0;
+    for(;;) {
+        const index = text.indexOf(sep, start);
+        if (index === -1) {
+            break;
+        }
+        yield text.substring(start, index);
+        start = index + 1;
+    }
+    yield text.substring(start);
+};
+
+
+export function tokenizeMax(
+    /** @type {string} */ text,
+    /** @type {string} */ sep,
+    /** @type {number} */ max = Number.MAX_SAFE_INTEGER) {
+    let start = 0;
+    const items = [];
+    max--;
+    for(;;) {
+        const index = text.indexOf(sep, start);
+        if (index === -1) {
+            break;
+        }
+        items.push(text.substring(start, index));
+        start = index + 1;
+        if (--max === 0) {
+            break;
+        }
+    }
+    items.push(text.substring(start));
+    return items;
+};

package/src/tests/mime/lines-test.js

@@ -0,0 +1,17 @@
+import assert from "assert";
+import { tokenize } from "../../mime-parser/tokenizer.js";
+
+
+export default function () {
+    
+    assert.equal(
+        "a,b",
+        Array.from(tokenize("a\nb", "\n")));
+
+    assert.equal(
+        "a b",
+        Array.from(tokenize("a b", "\n")));
+    assert.equal(
+        "a,,b",
+        Array.from(tokenize("a\n\nb", "\n")));
+}

package/src/tests/mime/message1.js

@@ -0,0 +1,46 @@
+import assert from "assert";
+import { MimeNode } from "../../mime-parser/MimeNode.js";
+import { StringLineStream } from "../../mime-parser/stream/LineStream.js";
+
+const msg1 = `From: Some One <someone@example.com>
+MIME-Version: 1.0
+Content-Type: multipart/mixed;
+        boundary="XXXXboundary text"
+
+This is a multipart message in MIME format.
+
+--XXXXboundary text
+Content-Type: text/plain
+
+this is the body text
+
+--XXXXboundary text
+Content-Type: text/plain;
+Content-Disposition: attachment;
+        filename="test.txt"
+
+this is the attachment text
+
+--XXXXboundary text--
+
+`;
+
+export default async function () {
+    const root = new MimeNode();
+    await root.parse(new StringLineStream(msg1));
+
+    assert.strictEqual("multipart/mixed", root.contentType.type);
+    assert.strictEqual("XXXXboundary text", root.contentType.boundary);
+    assert.strictEqual("Some One <someone@example.com>", root.header("from"));
+    // Assert.strictEqual("This is a multipart message in MIME format.", root.encoded.trim());
+    assert.strictEqual(2, root.children.length);
+
+    const body = root.children[0];
+    assert.strictEqual("text/plain", body.contentType.type);
+    assert.strictEqual("this is the body text", body.encoded.trim());
+
+    const attachment = root.children[1];
+    assert.strictEqual("text/plain", attachment.contentType.type);
+    assert.strictEqual("this is the attachment text", attachment.encoded.trim());
+    assert.strictEqual("test.txt", attachment.contentDisposition.filename);
+}

package/src/tests/mime/message2.js

@@ -0,0 +1,73 @@
+import assert from "assert";
+import { MimeNode } from "../../mime-parser/MimeNode.js";
+import { StringLineStream } from "../../mime-parser/stream/LineStream.js";
+import { BlobWriter } from "../../mime-parser/stream/TextWriter.js";
+
+const msg1 = `From: Some One <someone@example.com>
+MIME-Version: 1.0
+Content-Type: multipart/mixed;
+        boundary="XXXXboundary text"
+
+This is a multipart message in MIME format.
+
+--XXXXboundary text
+Content-Type: text/plain
+
+this is the body text
+
+--XXXXboundary text
+Content-Type: text/html; charset="UTF-8";
+Content-Transfer-Encoding: quoted-printable
+
+<div dir=3D"ltr"><font face=3D"trebuchet ms, sans-serif">Seeking Actors and=
+ Actresses for a micro budget feature. The story revolves around a couple a=
+nd their guests who find themselves in a tense and gripping situation. They=
+ are taken hostage in their own home by a radical gunman who lurks outside.=
+ We are looking for individuals who can bring depth and authenticity to the=
+ir characters. The ability to convey a range of emotions and create believa=
+ble performances is crucial for this project.<br><br>Submit ASAP through:=
+=C2=A0<a href=3D"https://socialmail.in">https://socialmail.in</a><br><br>=
+#newmexicoactors #newmexicocasting=C2=A0</font><br></div>
+
+--XXXXboundary text--
+
+`;
+
+export default async function () {
+    const root = new MimeNode();
+    await root.parse(new StringLineStream(msg1));
+
+    assertAll(root);
+
+    // write and read it again...
+
+    const blob = new BlobWriter();
+    await root.save(blob);
+
+    const encoded = blob.toString();
+
+    // reparse...
+    const root2 = new MimeNode();
+    await root2.parse(new StringLineStream(encoded));
+
+    assertAll(root2);
+}
+
+function assertAll( /** @type {MimeNode} */ root) {
+    assert.strictEqual("multipart/mixed", root.contentType.type);
+    assert.strictEqual("XXXXboundary text", root.contentType.boundary);
+    assert.strictEqual("Some One <someone@example.com>", root.header("from"));
+    // assert.strictEqual("This is a multipart message in MIME format.", root.encoded.trim());
+    assert.strictEqual(2, root.children.length);
+
+    const body = root.children[0];
+    assert.strictEqual("text/plain", body.contentType.type);
+    assert.strictEqual("this is the body text", body.encoded.trim());
+
+    const html = root.children[1];
+    assert.strictEqual("text/html", html.contentType.type);
+    assert.strictEqual("quoted-printable", html.contentTransferEncoding);
+
+    const data = html.text;
+    assert.strictEqual(`<div dir="ltr"><font face="trebuchet ms, sans-serif">Seeking Actors and Actresses for a micro budget feature. The story revolves around a couple and their guests who find themselves in a tense and gripping situation. They are taken hostage in their own home by a radical gunman who lurks outside. We are looking for individuals who can bring depth and authenticity to their characters. The ability to convey a range of emotions and create believable performances is crucial for this project.<br><br>Submit ASAP through: <a href="https://socialmail.in">https://socialmail.in</a><br><br>#newmexicoactors #newmexicocasting </font><br></div>`, data);
+}

package/src/tests/mime/pairs.js

@@ -0,0 +1,38 @@
+import { parsePairs } from "../../mime-parser/parsePairs.js";
+
+const equalJson = (e, t, m)  => {
+    e = JSON.stringify(e);
+    t = JSON.stringify(t);
+    // eslint-disable-next-line eqeqeq
+    if (e !== t) {
+        throw new Error(m ?? `Assertion failed ${e} !== ${t}`);
+    }
+}
+
+export default function() {
+
+    equalJson(
+        parsePairs("multipart/mixed; boundary=--abcd"),
+        {
+            "multipart/mixed": "multipart/mixed",
+            boundary: "--abcd"
+        }
+    );
+
+
+    equalJson(
+        parsePairs("multipart/mixed; boundary=--abcd", "type"),
+        {
+            type: "multipart/mixed",
+            boundary: "--abcd"
+        }
+    );
+
+    equalJson(
+        parsePairs("multipart/mixed;", "type"),
+        {
+            type: "multipart/mixed"
+        }
+    );
+
+}