@mtcute/markdown-parser 0.16.3 → 0.16.9

package/README.md

@@ -129,10 +129,10 @@ You can interpolate one of the following:
 - `number` - will be converted to string and appended to plain text as-is
 - `TextWithEntities` or `MessageEntity` - will add the text and its entities to the output. This is the type returned by `md` itself:
   ```ts
-    const bold = md`**bold**`
-    const text = md`Hello, ${bold}!`
+  const bold = md`**bold**`
+  const text = md`Hello, ${bold}!`
   ```
 - falsy value (i.e. `null`, `undefined`, `false`) - will be ignored
 
 Because of interpolation, you almost never need to think about escaping anything,
-since the values are not even parsed as Markdown, and are appended to the output as-is.
+since the values are not even parsed as Markdown, and are appended to the output as-is.

package/index.cjs

@@ -0,0 +1,352 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/markdown-parser] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/markdown-parser] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Long = require("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
+});
+exports.md = md;

package/{cjs/index.d.ts → index.d.cts}

@@ -1,5 +1,5 @@
-import Long from 'long';
-import type { InputText, MessageEntity, TextWithEntities } from '@mtcute/core';
+import { default as Long } from 'long';
+import { InputText, MessageEntity, TextWithEntities } from '@mtcute/core';
 /**
  * Escape a string to be safely used in Markdown.
  *

package/index.d.ts

@@ -1 +1,47 @@
-export * from './esm/index.js'
+import { default as Long } from 'long';
+import { InputText, MessageEntity, TextWithEntities } from '@mtcute/core';
+/**
+ * Escape a string to be safely used in Markdown.
+ *
+ * > **Note**: this function is in most cases not needed, as `md` function
+ * > handles all `string`s passed to it automatically as plain text.
+ */
+declare function escape(str: string): string;
+/**
+ * Add Markdown formatting to the text given the plain text and entities contained in it.
+ */
+declare function unparse(input: InputText): string;
+export declare const md: {
+    /**
+     * Tagged template based Markdown-to-entities parser function
+     *
+     * Additionally, `md` function has two static methods:
+     * - `md.escape` - escape a string to be safely used in Markdown
+     *   (should not be needed in most cases, as `md` function itself handles all `string`s
+     *   passed to it automatically as plain text)
+     * - `md.unparse` - add Markdown formatting to the text given the plain text and entities contained in it
+     *
+     * @example
+     * ```typescript
+     * const text = md`**${user.displayName}**`
+     * ```
+     */
+    (strings: TemplateStringsArray, ...sub: (InputText | MessageEntity | Long | boolean | number | undefined | null)[]): TextWithEntities;
+    /**
+     * A variant taking a plain JS string as input
+     * and parsing it.
+     *
+     * Useful for cases when you already have a string
+     * (e.g. from some server) and want to parse it.
+     *
+     * @example
+     * ```typescript
+     * const string = '**hello**'
+     * const text = md(string)
+     * ```
+     */
+    (string: string): TextWithEntities;
+    escape: typeof escape;
+    unparse: typeof unparse;
+};
+export {};