@mtkruto/browser 0.6.1 → 0.119.0

package/script/client/0_html.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * MTKruto - Cross-runtime JavaScript library for building Telegram clients
- * Copyright (C) 2023-2024 Roj <https://roj.im/>
+ * Copyright (C) 2023-2026 Roj <https://roj.im/>
  *
  * This file is part of MTKruto.
  *
@@ -20,86 +20,425 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseHtml = parseHtml;
-const _0_deps_js_1 = require("../0_deps.js");
+exports.parseAttributes = parseAttributes;
 const _0_errors_js_1 = require("../0_errors.js");
-function parseHtml(html) {
-    html = html.trim();
+const _3_types_js_1 = require("../3_types.js");
+const TAG_NAMES = [
+    "a",
+    "b",
+    "strong",
+    "i",
+    "em",
+    "s",
+    "strike",
+    "del",
+    "u",
+    "ins",
+    "tg-spoiler",
+    "tg-emoji",
+    "span",
+    "pre",
+    "code",
+    "blockquote",
+];
+const ENTITY_TYPES = [
+    "textLink",
+    "bold",
+    "bold",
+    "italic",
+    "italic",
+    "strikethrough",
+    "strikethrough",
+    "strikethrough",
+    "underline",
+    "underline",
+    "spoiler",
+    "customEmoji",
+    "spoiler",
+    "code",
+    "code",
+    "blockquote",
+];
+function parseHtml(html_) {
+    html_ = html_.trim();
     let text = "";
-    const entities = new Array();
-    const stack = new Array();
-    const parser = new _0_deps_js_1.Parser({
-        onopentag(name, attribs) {
-            switch (name) {
-                case "b":
-                case "strong":
-                    stack.push({ type: "bold", offset: text.length, length: 0 });
-                    break;
-                case "em":
-                case "i":
-                    stack.push({ type: "italic", offset: text.length, length: 0 });
-                    break;
-                case "code":
-                    stack.push({ type: "code", offset: text.length, length: 0 });
-                    break;
-                case "pre": {
-                    const language = attribs.language ?? "";
-                    stack.push({ type: "pre", offset: text.length, length: 0, language });
-                    break;
-                }
-                case "a": {
-                    const url = attribs.href;
-                    if (!url) {
-                        throw new _0_errors_js_1.InputError("Missing attribute: href");
+    let entities = new Array();
+    const entityTags = new Array();
+    const tagStack = new Array();
+    const html = Array.from(html_);
+    for (let i = 0; i < html.length; ++i) {
+        const c = html[i];
+        if (c === "&") {
+            const result = decodeEntity(html, i);
+            [text, i] = [text + result[0], i + result[1]];
+            continue;
+        }
+        else if (c !== "<") {
+            text += c;
+            continue;
+        }
+        ++i;
+        let closing = false;
+        let end = i;
+        if (html[end] && html[end] === "/") {
+            closing = true;
+            ++i;
+            ++end;
+        }
+        while (html[end] && html[end] !== ">") {
+            ++end;
+        }
+        const tagName_ = html.slice(i, end);
+        let tagName = tagName_.join("");
+        let attributes;
+        if (closing) {
+            tagName = tagName.trim().toLowerCase();
+        }
+        else {
+            const index = tagName_.indexOf(" ");
+            if (index !== -1) {
+                attributes = parseAttributes(tagName_.slice(index));
+                tagName = tagName.slice(0, index).toLowerCase();
+            }
+            else {
+                tagName = tagName.toLowerCase();
+            }
+        }
+        if (closing && !tagName.length && tagStack.length) {
+            tagName = tagStack[tagStack.length - 1].tagName;
+        }
+        if (!tagName.length) {
+            throw new _0_errors_js_1.InputError(`Invalid tag at offset ${i}.`);
+        }
+        else if (!TAG_NAMES.includes(tagName)) {
+            throw new _0_errors_js_1.InputError(`Unsupported HTML tag at offset ${i}: ${tagName}`);
+        }
+        else if (closing) {
+            const openTag = tagStack.pop();
+            if (openTag?.tagName !== tagName) {
+                throw new _0_errors_js_1.InputError(`Unexpected closing tag at offset ${i}.`);
+            }
+            const offset = openTag.openedAt;
+            const length = text.length - openTag.openedAt;
+            if (openTag.time !== undefined) {
+                entities.push({
+                    type: "dateTime",
+                    offset,
+                    length,
+                    dateTime: openTag.time,
+                    format: openTag.timeFormat,
+                });
+            }
+            else if (openTag.userId !== undefined) {
+                entities.push({
+                    type: "textMention",
+                    offset,
+                    length,
+                    userId: openTag.userId,
+                });
+                entityTags.push(openTag);
+            }
+            else if (tagName === "a") {
+                let url = openTag.url;
+                if (!url) {
+                    const text_ = text.slice(offset, offset + length);
+                    try {
+                        url = new URL(text_).href;
                     }
-                    stack.push({ type: "textLink", offset: text.length, length: 0, url });
-                    break;
+                    catch {
+                        if (!Array.from(text).some(isSpace)) {
+                            try {
+                                url = new URL(`http://${text_}`).href;
+                            }
+                            catch {
+                                //
+                            }
+                        }
+                    }
+                }
+                if (url) {
+                    entities.push({
+                        type: "textLink",
+                        offset,
+                        length,
+                        url,
+                    });
+                    entityTags.push(openTag);
+                }
+            }
+            else if (tagName === "pre") {
+                const lastEntity = entities[entities.length - 1];
+                const entityTag = entityTags[entityTags.length - 1];
+                if (lastEntity && lastEntity.type === "code" && lastEntity.offset === offset && lastEntity.length === length && entityTag.language) {
+                    entities[entities.length - 1] = {
+                        type: "pre",
+                        offset: lastEntity.offset,
+                        length: lastEntity.length,
+                        language: entityTag.language,
+                    };
+                }
+                else {
+                    entities.push({
+                        type: "pre",
+                        offset,
+                        length,
+                        language: "",
+                    });
+                    entityTags.push(openTag);
                 }
-                case "ins":
-                case "u":
-                    stack.push({ type: "underline", offset: text.length, length: 0 });
-                    break;
-                case "del":
-                case "strike":
-                    stack.push({ type: "strikethrough", offset: text.length, length: 0 });
-                    break;
-                case "span":
-                    if (attribs.class != "tg-spoiler") {
-                        throw new _0_errors_js_1.InputError('The class attribute must be "tg-spoiler."');
+            }
+            else if (tagName === "code") {
+                const lastEntity = entities[entities.length - 1];
+                if (lastEntity && lastEntity.type === "pre" && lastEntity.offset === offset && lastEntity.length === length && openTag.language) {
+                    lastEntity.language = openTag.language;
+                }
+                else {
+                    entities.push({
+                        type: "code",
+                        offset,
+                        length,
+                    });
+                    entityTags.push(openTag);
+                }
+            }
+            else if (tagName === "blockquote") {
+                const entity = {
+                    type: "blockquote",
+                    offset,
+                    length,
+                };
+                if (openTag.collapsible) {
+                    entity.collapsible = true;
+                }
+                entities.push(entity);
+                entityTags.push(openTag);
+                if (openTag.collapsible) {
+                    entities[entities.length - 1].collapsible = true;
+                }
+            }
+            else if (openTag.customEmojiId !== undefined) {
+                entities.push({
+                    type: "customEmoji",
+                    offset,
+                    length,
+                    customEmojiId: openTag.customEmojiId,
+                });
+                entityTags.push(openTag);
+            }
+            else {
+                entities.push({
+                    type: ENTITY_TYPES[TAG_NAMES.indexOf(openTag.tagName)],
+                    offset,
+                    length,
+                });
+                entityTags.push(openTag);
+            }
+        }
+        else if (tagName === "span" && attributes?.class !== "tg-spoiler") {
+            throw new _0_errors_js_1.InputError(`Invalid or missing attribute class for tag span at offset ${i}.`);
+        }
+        else {
+            let url;
+            let language;
+            let userId;
+            let collapsible;
+            let time;
+            let timeFormat;
+            let customEmojiId;
+            if (tagName === "a") {
+                url = attributes?.href;
+                if (url) {
+                    let url_;
+                    try {
+                        url_ = new URL(url);
+                    }
+                    catch {
+                        try {
+                            url_ = new URL(`http://${url}`);
+                            url = url_.href;
+                        }
+                        catch {
+                            throw new _0_errors_js_1.InputError(`Invalid URL specified for tag a at offset ${i}.`);
+                        }
                     }
-                /* falls through */
-                case "tg-spoiler":
-                    stack.push({ type: "spoiler", offset: text.length, length: 0 });
-                    break;
-                case "tg-emoji":
-                    if (!attribs["emoji-id"]) {
-                        throw new _0_errors_js_1.InputError("Missing attribute: emoji-id");
+                    if (url_.protocol !== "tg:" && url_.protocol !== "ton:" && url_.protocol !== "http:" && url_.protocol !== "https:") {
+                        throw new _0_errors_js_1.InputError(`Unsupported URL protocol at offset ${i}: ${url_.protocol}`);
                     }
-                    stack.push({ type: "spoiler", offset: text.length, length: 0 });
-                    break;
-                case "blockquote":
-                    stack.push({ type: "blockquote", offset: text.length, length: 0 });
-                    if (attribs.collapsible) {
-                        stack[stack.length - 1].collapsible = true;
+                    if (url_.protocol === "tg:" && url_.hostname === "user") {
+                        const id = Number(url_.searchParams.get("id"));
+                        if (!isNaN(id) && id > 0) {
+                            userId = id;
+                            url = undefined;
+                        }
+                        else {
+                            throw new _0_errors_js_1.InputError(`Invalid ID specified for mention at offset ${i}.`);
+                        }
                     }
+                    if (url_.protocol === "tg:" && url_.hostname === "time") {
+                        time = Number(url_.searchParams.get("unix"));
+                        if (!isNaN(time) && time > 0) {
+                            timeFormat = url_.searchParams.get("format") ?? undefined;
+                            url = undefined;
+                        }
+                        else {
+                            throw new _0_errors_js_1.InputError(`Invalid time specified at offset ${i}.`);
+                        }
+                    }
+                }
             }
-        },
-        ontext(data) {
-            if (!text.length) {
-                data = data.trimStart();
-            }
-            text += data;
-            for (const item of stack) {
-                item.length += data.length;
-            }
-        },
-        onclosetag() {
-            const lastItem = stack.pop();
-            if (lastItem) {
-                entities.push(lastItem);
-            }
-        },
-    });
-    parser.write(html);
-    parser.end();
+            else if (tagName === "code") {
+                language = attributes?.class?.replace("language-", "");
+            }
+            else if (tagName === "blockquote" && attributes?.expandable !== undefined) {
+                collapsible = true;
+            }
+            else if (tagName === "tg-emoji") {
+                customEmojiId = attributes?.["emoji-id"];
+                let isValid;
+                try {
+                    isValid = BigInt(customEmojiId ?? "") !== 0n;
+                }
+                catch {
+                    isValid = false;
+                }
+                if (!isValid) {
+                    throw new _0_errors_js_1.InputError(`Invalid emoji-id specified for tag tg-emoji at offset ${i}.`);
+                }
+            }
+            tagStack.push({ tagName, openedAt: text.length, url, language, userId, collapsible, customEmojiId, time, timeFormat });
+        }
+        i += end - i;
+    }
+    entities = entities.filter((v) => v.length);
+    entities = (0, _3_types_js_1.sortMessageEntities)(entities);
     return [text, entities];
 }
+function parseAttributes(attributes) {
+    const parsed = {};
+    for (let i = 0; i < attributes.length; ++i) {
+        const c = attributes[i];
+        if (isSpace(c)) {
+            continue;
+        }
+        let end = i;
+        while (attributes[end] && !isSpace(attributes[end]) && attributes[end] !== "=") {
+            ++end;
+        }
+        const name = attributes.slice(i, end);
+        while (attributes[end] && isSpace(attributes[end])) {
+            ++end;
+        }
+        let value = new Array();
+        if (attributes[end] === "=") {
+            ++end;
+            while (attributes[end] && isSpace(attributes[end])) {
+                ++end;
+            }
+            if (attributes[end]) {
+                const isQuote = attributes[end] === '"' || attributes[end] === "'";
+                if (!isQuote) {
+                    const valueStart = end;
+                    ++end;
+                    while (attributes[end] && !isSpace(attributes[end])) {
+                        ++end;
+                    }
+                    value = attributes.slice(valueStart, end);
+                }
+                else {
+                    const quote = attributes[end];
+                    ++end;
+                    const valueStart = end;
+                    while (attributes[end] && attributes[end] !== quote) {
+                        ++end;
+                    }
+                    value = attributes.slice(valueStart, end);
+                }
+            }
+        }
+        let value_ = "";
+        for (let i = 0; i < value.length; ++i) {
+            const c = value[i];
+            if (c === "&") {
+                const result = decodeEntity(value, i);
+                [value_, i] = [value_ + result[0], i + result[1]];
+            }
+            else {
+                value_ += c;
+            }
+        }
+        parsed[name.join("")] = value_;
+        i += end - i;
+    }
+    return parsed;
+}
+function decodeEntity(html, i) {
+    let text = "";
+    let end = i + 1;
+    let fallback = false;
+    if (html[end] === "#") {
+        ++end;
+        let code;
+        if (html[end] === "x") {
+            ++end;
+            while (isHex(html[end])) {
+                ++end;
+            }
+            const hex = html.slice(i + 3, end).join("");
+            code = parseInt(hex, 16);
+        }
+        else {
+            while (isDigit(html[end])) {
+                ++end;
+            }
+            const code_ = html.slice(i + 2, end).join("");
+            code = parseInt(code_);
+        }
+        if (!isNaN(code) && code !== 0 && code < 0x10ffff && end - i < 10) {
+            text = String.fromCharCode(code);
+        }
+        else {
+            fallback = true;
+        }
+    }
+    else {
+        while (isAlpha(html[end])) {
+            ++end;
+        }
+        const name = html.slice(i + 1, end).join("");
+        switch (name) {
+            case "amp":
+                text = "&";
+                break;
+            case "quot":
+                text = '"';
+                break;
+            case "lt":
+                text = "<";
+                break;
+            case "gt":
+                text = ">";
+                break;
+            default:
+                fallback = true;
+        }
+    }
+    if (html[end] === ";") {
+        ++end;
+    }
+    if (fallback) {
+        text = html.slice(i, end).join("");
+    }
+    return [text, end - i - 1];
+}
+function isAlpha(string) {
+    return "a" <= string && string <= "z";
+}
+function isDigit(string) {
+    return "0" <= string && string <= "9";
+}
+function isHex(string) {
+    return isDigit(string) || ("a" <= string && string <= "f");
+}
+function isSpace(string) {
+    return string === " " || string === "\t" || string === "\r" || string === "\n" || string === "\0" || string === "\v";
+}

package/script/client/0_markdown.d.ts

@@ -1,6 +1,6 @@
 /**
  * MTKruto - Cross-runtime JavaScript library for building Telegram clients
- * Copyright (C) 2023-2024 Roj <https://roj.im/>
+ * Copyright (C) 2023-2026 Roj <https://roj.im/>
  *
  * This file is part of MTKruto.
  *
@@ -17,7 +17,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-import { MessageEntity } from "../3_types.js";
+import { type MessageEntity } from "../3_types.js";
 export declare const CODEPOINTS: {
     "\t": number;
     "\r": number;

package/script/client/0_markdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"0_markdown.d.ts","sourceRoot":"","sources":["../../src/client/0_markdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAOH,OAAO,EAAE,aAAa,EAA0C,MAAM,eAAe,CAAC;AAMtF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;CAkBtB,CAAC;AAsDF,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC,CA6PtE"}
+{"version":3,"file":"0_markdown.d.ts","sourceRoot":"","sources":["../../src/client/0_markdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAOH,OAAO,EAAE,KAAK,aAAa,EAA+C,MAAM,eAAe,CAAC;AAIhG,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;CAkBtB,CAAC;AAqEF,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC,CAiQtE"}