@mtcute/markdown-parser 0.16.7 → 0.17.0

package/index.js

@@ -1 +1,347 @@
-export * from './esm/index.js'
+import Long from "long";
+const MENTION_REGEX = /^tg:\/\/user\?id=(\d+)(?:&hash=(-?[0-9a-fA-F]+)(?:&|$)|&|$)/;
+const EMOJI_REGEX = /^tg:\/\/emoji\?id=(-?\d+)/;
+const TAG_BOLD = "**";
+const TAG_ITALIC = "__";
+const TAG_UNDERLINE = "--";
+const TAG_STRIKE = "~~";
+const TAG_SPOILER = "||";
+const TAG_CODE = "`";
+const TAG_PRE = "```";
+const TO_BE_ESCAPED = /[*_\-~`[\\\]|]/g;
+function escape(str) {
+  return str.replace(TO_BE_ESCAPED, (s) => `\\${s}`);
+}
+function unparse(input) {
+  if (typeof input === "string") return escape(input);
+  let text = input.text;
+  const entities = input.entities ?? [];
+  const escaped = [];
+  text = text.replace(TO_BE_ESCAPED, (s, pos) => {
+    escaped.push(pos);
+    return `\\${s}`;
+  });
+  const hasEscaped = escaped.length > 0;
+  const insert = [];
+  for (const entity of entities) {
+    const type = entity._;
+    let start = entity.offset;
+    let end = start + entity.length;
+    if (start > text.length) continue;
+    if (start < 0) start = 0;
+    if (end > text.length) end = text.length;
+    if (hasEscaped) {
+      let escapedPos = 0;
+      while (escapedPos < escaped.length && escaped[escapedPos] < start) {
+        escapedPos += 1;
+      }
+      start += escapedPos;
+      while (escapedPos < escaped.length && escaped[escapedPos] <= end) {
+        escapedPos += 1;
+      }
+      end += escapedPos;
+    }
+    let startTag;
+    let endTag;
+    switch (type) {
+      case "messageEntityBold":
+        startTag = endTag = TAG_BOLD;
+        break;
+      case "messageEntityItalic":
+        startTag = endTag = TAG_ITALIC;
+        break;
+      case "messageEntityUnderline":
+        startTag = endTag = TAG_UNDERLINE;
+        break;
+      case "messageEntityStrike":
+        startTag = endTag = TAG_STRIKE;
+        break;
+      case "messageEntitySpoiler":
+        startTag = endTag = TAG_SPOILER;
+        break;
+      case "messageEntityCode":
+        startTag = endTag = TAG_CODE;
+        break;
+      case "messageEntityPre":
+        startTag = TAG_PRE;
+        if (entity.language) {
+          startTag += entity.language;
+        }
+        startTag += "\n";
+        endTag = `
+${TAG_PRE}`;
+        break;
+      case "messageEntityTextUrl":
+        startTag = "[";
+        endTag = `](${entity.url})`;
+        break;
+      case "messageEntityMentionName":
+        startTag = "[";
+        endTag = `](tg://user?id=${entity.userId})`;
+        break;
+      case "messageEntityCustomEmoji":
+        startTag = "[";
+        endTag = `](tg://emoji?id=${entity.documentId.toString()})`;
+        break;
+      default:
+        continue;
+    }
+    insert.push([start, startTag]);
+    insert.push([end, endTag]);
+  }
+  insert.sort((a, b) => b[0] - a[0]);
+  for (const [offset, tag] of insert) {
+    text = text.substr(0, offset) + tag + text.substr(offset);
+  }
+  return text;
+}
+function parse(strings, ...sub) {
+  const entities = [];
+  let result = "";
+  const stacks = {};
+  let insideCode = false;
+  let insidePre = false;
+  let insideLink = false;
+  let insideLinkUrl = false;
+  let pendingLinkUrl = "";
+  function feed(text) {
+    const len = text.length;
+    let pos = 0;
+    while (pos < len) {
+      const c = text[pos];
+      if (c === "\\") {
+        if (insideLinkUrl) {
+          pendingLinkUrl += text[pos + 1];
+        } else {
+          result += text[pos + 1];
+        }
+        pos += 2;
+        continue;
+      }
+      if (insideCode) {
+        if (c === "`") {
+          const ent = stacks.code.pop();
+          ent.length = result.length - ent.offset;
+          entities.push(ent);
+          insideCode = false;
+          pos += 1;
+        } else {
+          pos += 1;
+          result += c;
+        }
+        continue;
+      }
+      if (insidePre) {
+        if (c === "`" || c === "\n" && text[pos + 1] === "`") {
+          if (c === "\n") pos += 1;
+          if (text[pos + 1] === "`" && text[pos + 2] === "`") {
+            const ent = stacks.pre.pop();
+            ent.length = result.length - ent.offset;
+            entities.push(ent);
+            insidePre = false;
+            pos += 3;
+            continue;
+          } else if (c === "\n") {
+            pos -= 1;
+          }
+        }
+        pos += 1;
+        result += c;
+        continue;
+      }
+      if (insideLink && c === "]") {
+        const ent = stacks.link.pop();
+        if (text[pos + 1] !== "(") {
+          result = `${result.substr(0, ent.offset)}[${result.substr(ent.offset)}]`;
+          pos += 1;
+          insideLink = false;
+          continue;
+        }
+        pos += 2;
+        insideLink = false;
+        insideLinkUrl = true;
+        stacks.link.push(ent);
+        continue;
+      }
+      if (insideLinkUrl) {
+        pos += 1;
+        if (c !== ")") {
+          pendingLinkUrl += c;
+          continue;
+        }
+        const ent = stacks.link.pop();
+        let url = pendingLinkUrl;
+        pendingLinkUrl = "";
+        insideLinkUrl = false;
+        if (!url.length) continue;
+        ent.length = result.length - ent.offset;
+        let m = url.match(MENTION_REGEX);
+        if (m) {
+          const userId = Number.parseInt(m[1]);
+          const accessHash = m[2];
+          if (accessHash) {
+            ent._ = "inputMessageEntityMentionName";
+            ent.userId = {
+              _: "inputUser",
+              userId,
+              accessHash: Long.fromString(accessHash, false, 16)
+            };
+          } else {
+            ent._ = "messageEntityMentionName";
+            ent.userId = userId;
+          }
+        } else if (m = EMOJI_REGEX.exec(url)) {
+          ent._ = "messageEntityCustomEmoji";
+          ent.documentId = Long.fromString(m[1]);
+        } else {
+          if (url.match(/^\/\//)) url = `http:${url}`;
+          ent._ = "messageEntityTextUrl";
+          ent.url = url;
+        }
+        entities.push(ent);
+        continue;
+      }
+      if (c === "[" && !insideLink) {
+        pos += 1;
+        insideLink = true;
+        if (!("link" in stacks)) stacks.link = [];
+        stacks.link.push({
+          offset: result.length,
+          length: 0
+        });
+        continue;
+      }
+      if (c === "`") {
+        const isPre = text[pos + 1] === "`" && text[pos + 2] === "`";
+        if (isPre) {
+          pos += 3;
+          let language = "";
+          while (pos < text.length && text[pos] !== "\n") {
+            language += text[pos++];
+          }
+          pos += 1;
+          if (pos > text.length) {
+            throw new Error("Malformed PRE entity, expected LF after ```");
+          }
+          if (!("pre" in stacks)) stacks.pre = [];
+          stacks.pre.push({
+            _: "messageEntityPre",
+            offset: result.length,
+            length: 0,
+            language
+          });
+          insidePre = true;
+        } else {
+          pos += 1;
+          if (!("code" in stacks)) stacks.code = [];
+          stacks.code.push({
+            _: "messageEntityCode",
+            offset: result.length,
+            length: 0
+          });
+          insideCode = true;
+        }
+        continue;
+      }
+      if (c === text[pos + 1]) {
+        let type = null;
+        switch (c) {
+          case "_":
+            type = "Italic";
+            break;
+          case "*":
+            type = "Bold";
+            break;
+          case "-":
+            type = "Underline";
+            break;
+          case "~":
+            type = "Strike";
+            break;
+          case "|":
+            type = "Spoiler";
+            break;
+        }
+        if (type) {
+          if (!(type in stacks)) stacks[type] = [];
+          const isBegin = stacks[type].length === 0;
+          if (isBegin) {
+            stacks[type].push({
+              _: `messageEntity${type}`,
+              offset: result.length,
+              length: 0
+            });
+          } else {
+            const ent = stacks[type].pop();
+            ent.length = result.length - ent.offset;
+            entities.push(ent);
+          }
+          pos += 2;
+          continue;
+        }
+      }
+      if (c === "\n") {
+        if (pos !== 0) {
+          result += "\n";
+        }
+        const nonWhitespace = text.slice(pos + 1).search(/[^ \t]/);
+        if (nonWhitespace !== -1) {
+          pos += nonWhitespace + 1;
+        } else {
+          pos = len;
+          result = result.trimEnd();
+        }
+        continue;
+      }
+      result += c;
+      pos += 1;
+    }
+  }
+  if (typeof strings === "string") strings = [strings];
+  sub.forEach((it, idx) => {
+    feed(strings[idx]);
+    if (typeof it === "boolean" || !it) return;
+    if (insideLinkUrl) {
+      if (typeof it === "string" || typeof it === "number") {
+        pendingLinkUrl += it;
+      } else if (Long.isLong(it)) {
+        pendingLinkUrl += it.toString(10);
+      } else {
+        pendingLinkUrl += it.text;
+      }
+      return;
+    }
+    if (typeof it === "string" || typeof it === "number") {
+      result += it;
+    } else if (Long.isLong(it)) {
+      result += it.toString(10);
+    } else {
+      const text = it.text;
+      const innerEntities = "raw" in it ? [it.raw] : it.entities;
+      const baseOffset = result.length;
+      result += text;
+      if (innerEntities) {
+        for (const ent of innerEntities) {
+          entities.push({ ...ent, offset: ent.offset + baseOffset });
+        }
+      }
+    }
+  });
+  feed(strings[strings.length - 1]);
+  for (const [name, stack] of Object.entries(stacks)) {
+    if (stack.length) {
+      throw new Error(`Unterminated ${name} entity`);
+    }
+  }
+  return {
+    text: result,
+    entities
+  };
+}
+const md = Object.assign(parse, {
+  escape,
+  unparse
+});
+export {
+  md
+};

package/markdown-parser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,27 +1,31 @@
 {
-  "name": "@mtcute/markdown-parser",
-  "type": "module",
-  "version": "0.16.7",
-  "description": "Markdown entities parser for mtcute",
-  "author": "alina sireneva <alina@tei.su>",
-  "license": "MIT",
-  "sideEffects": false,
-  "exports": {
-    ".": {
-      "import": "./esm/index.js",
-      "require": "./cjs/index.js"
+    "name": "@mtcute/markdown-parser",
+    "type": "module",
+    "version": "0.17.0",
+    "description": "Markdown entities parser for mtcute",
+    "author": "alina sireneva <alina@tei.su>",
+    "license": "MIT",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./index.d.ts",
+                "default": "./index.js"
+            },
+            "require": {
+                "types": "./index.d.cts",
+                "default": "./index.cjs"
+            }
+        }
+    },
+    "scripts": {},
+    "dependencies": {
+        "@mtcute/core": "^0.17.0",
+        "long": "5.2.3"
+    },
+    "homepage": "https://mtcute.dev",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/mtcute/mtcute"
     }
-  },
-  "scripts": {},
-  "dependencies": {
-    "@mtcute/core": "^0.16.7",
-    "long": "5.2.3"
-  },
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
-  "homepage": "https://mtcute.dev",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/mtcute/mtcute"
-  }
 }