Function parseSpan

src/common/markdown-span.ts:5–141

(t: string)

/** Parse a markdown string into tagged text fragments */
export function parseSpan(t: string): TaggedSpan[] {
  let i = 0;
  const spans: TaggedSpan[] = [];

  // const match = (regexp: RegExp) => {
  //   const m = t.slice(i).match(regexp);
  //   if (!m) return;
  //   i += m[0].length;
  //   return m[0];
  // };

  const match = (s: string) => {
    let j = 0;
    while (i + j < t.length && t[i + j] === s[j]) j += 1;

    return j === s.length;
  };

  const peek = () => {
    if (t[i] === '\\' && t[i + 1] !== undefined) {
      // Escape characters
      if ('\\`*_{}[]<>()#+-.!|'.includes(t[i + 1])) {
        i += 1;
        return t[i];
      }
    }
    return t[i];
  };

  const consume = () => {
    const c = peek();
    i += 1;
    return c;
  };

  const parseCode = () => {
    // Note: the caller has not consumed the initial backtick

    // A quintuple backtick is a code span for a single backtick
    if (match('`````')) return { tag: 'code', s: '`' };
    // A triple backtick is also a code span for a single backtick
    if (match('```')) return { tag: 'code', s: '`' };
    i += 1;
    let s = '';

    if (t[i] === '`' && t[i + 1] === '`') {
      // In a double backtick code span, there are no escape sequences
      // and single backticks are preserved verbatim
      i += 2;
      // Inside a code span, characters are not escaped, so don't use consume()
      while (t[i] !== '`' && t[i + 1] !== '`' && i < t.length) {
        s += t[i];
        i += 1;
      }
      i += 2;
      spans.push({ tag: 'code', s });
    }