@lvce-editor/chat-message-parsing-worker 1.0.0 → 1.2.0

package/dist/chatMessageParsingWorkerMain.js

@@ -1066,8 +1066,961 @@ const handleMessagePort = async port => {
   });
 };
 
+const windowsAbsolutePathRegex = /^[a-zA-Z]:[\\/]/;
+const pathSeparatorRegex$1 = /[\\/]/;
+const isPathTraversalAttempt = path => {
+  if (!path) {
+    return false;
+  }
+  if (path.startsWith('/') || path.startsWith('\\')) {
+    return true;
+  }
+  if (path.startsWith('file://')) {
+    return true;
+  }
+  if (windowsAbsolutePathRegex.test(path)) {
+    return true;
+  }
+  const segments = path.split(pathSeparatorRegex$1);
+  return segments.includes('..');
+};
+
+const pathSeparatorRegex = /[\\/]/;
+const normalizeRelativePath = path => {
+  const segments = path.split(pathSeparatorRegex).filter(segment => segment && segment !== '.');
+  if (segments.length === 0) {
+    return '.';
+  }
+  return segments.join('/');
+};
+
+const isAlphaNumeric = value => {
+  if (!value) {
+    return false;
+  }
+  const code = value.codePointAt(0) ?? 0;
+  if (code >= 48 && code <= 57) {
+    return true;
+  }
+  if (code >= 65 && code <= 90) {
+    return true;
+  }
+  return code >= 97 && code <= 122;
+};
+const sanitizeLinkUrl = url => {
+  const trimmedUrl = url.trim();
+  const normalized = url.trim().toLowerCase();
+  if (normalized.startsWith('http://') || normalized.startsWith('https://') || normalized.startsWith('file://') || normalized.startsWith('vscode-references://')) {
+    return trimmedUrl;
+  }
+  if (!trimmedUrl || trimmedUrl.startsWith('#') || trimmedUrl.startsWith('?') || trimmedUrl.startsWith('/') || trimmedUrl.startsWith('\\')) {
+    return '#';
+  }
+  if (trimmedUrl.includes('://') || trimmedUrl.includes(':')) {
+    return '#';
+  }
+  if (isPathTraversalAttempt(trimmedUrl)) {
+    return '#';
+  }
+  const normalizedPath = normalizeRelativePath(trimmedUrl);
+  if (normalizedPath === '.') {
+    return '#';
+  }
+  return `file:///workspace/${normalizedPath}`;
+};
+const sanitizeImageUrl = url => {
+  const normalized = url.trim().toLowerCase();
+  if (normalized.startsWith('http://') || normalized.startsWith('https://')) {
+    return url;
+  }
+  return '#';
+};
+const isOpenBracket = value => {
+  return value === '(' || value === '[' || value === '{';
+};
+const isCloseBracket = value => {
+  return value === ')' || value === ']' || value === '}';
+};
+const findRawUrlEnd = (value, start) => {
+  let index = start;
+  while (index < value.length) {
+    const current = value[index];
+    if (current === ' ' || current === '\n' || current === '\r' || current === '\t' || current === '"' || current === "'" || current === '`' || current === '<' || current === '>') {
+      break;
+    }
+    index++;
+  }
+  return index;
+};
+const trimRawUrlEnd = url => {
+  let end = url.length;
+  while (end > 0) {
+    const current = url[end - 1];
+    if (current === '.' || current === ',' || current === ':' || current === ';' || current === '!' || current === '?') {
+      end--;
+      continue;
+    }
+    if (isCloseBracket(current)) {
+      const inner = url.slice(0, end - 1);
+      let openCount = 0;
+      let closeCount = 0;
+      for (let i = 0; i < inner.length; i++) {
+        if (isOpenBracket(inner[i])) {
+          openCount++;
+        } else if (isCloseBracket(inner[i])) {
+          closeCount++;
+        }
+      }
+      if (closeCount >= openCount) {
+        end--;
+        continue;
+      }
+    }
+    break;
+  }
+  return url.slice(0, end);
+};
+const parseRawLinkToken = (value, start) => {
+  if (!value.startsWith('https://', start) && !value.startsWith('http://', start)) {
+    return undefined;
+  }
+  if (start >= 2 && value[start - 1] === '(' && value[start - 2] === ']') {
+    return undefined;
+  }
+  const end = findRawUrlEnd(value, start);
+  const rawUrl = value.slice(start, end);
+  const href = trimRawUrlEnd(rawUrl);
+  if (!href) {
+    return undefined;
+  }
+  return {
+    length: href.length,
+    node: {
+      href: sanitizeLinkUrl(href),
+      text: href,
+      type: 'link'
+    }
+  };
+};
+const parseLinkToken = (value, start) => {
+  if (value[start] !== '[') {
+    return undefined;
+  }
+  const textEnd = value.indexOf(']', start + 1);
+  if (textEnd === -1) {
+    return undefined;
+  }
+  if (value[textEnd + 1] !== '(') {
+    return undefined;
+  }
+  let depth = 1;
+  let index = textEnd + 2;
+  while (index < value.length) {
+    const current = value[index];
+    if (current === '\n') {
+      return undefined;
+    }
+    if (current === '(') {
+      depth++;
+    } else if (current === ')') {
+      depth--;
+      if (depth === 0) {
+        const text = value.slice(start + 1, textEnd);
+        const href = value.slice(textEnd + 2, index);
+        if (!text || !href) {
+          return undefined;
+        }
+        return {
+          length: index - start + 1,
+          node: {
+            href: sanitizeLinkUrl(href),
+            text,
+            type: 'link'
+          }
+        };
+      }
+    }
+    index++;
+  }
+  return undefined;
+};
+const parseImageToken = (value, start) => {
+  if (value[start] !== '!' || value[start + 1] !== '[') {
+    return undefined;
+  }
+  const textEnd = value.indexOf(']', start + 2);
+  if (textEnd === -1) {
+    return undefined;
+  }
+  if (value[textEnd + 1] !== '(') {
+    return undefined;
+  }
+  let depth = 1;
+  let index = textEnd + 2;
+  while (index < value.length) {
+    const current = value[index];
+    if (current === '\n') {
+      return undefined;
+    }
+    if (current === '(') {
+      depth++;
+    } else if (current === ')') {
+      depth--;
+      if (depth === 0) {
+        const alt = value.slice(start + 2, textEnd);
+        const src = value.slice(textEnd + 2, index);
+        if (!src) {
+          return undefined;
+        }
+        return {
+          length: index - start + 1,
+          node: {
+            alt,
+            src: sanitizeImageUrl(src),
+            type: 'image'
+          }
+        };
+      }
+    }
+    index++;
+  }
+  return undefined;
+};
+const parseBoldToken = (value, start) => {
+  if (value[start] !== '*' || value[start + 1] !== '*') {
+    return undefined;
+  }
+  const end = value.indexOf('**', start + 2);
+  if (end === -1) {
+    return undefined;
+  }
+  const text = value.slice(start + 2, end);
+  if (!text || text.includes('\n')) {
+    return undefined;
+  }
+  return {
+    length: end - start + 2,
+    node: {
+      children: parseInlineNodes(text),
+      type: 'bold'
+    }
+  };
+};
+const parseBoldItalicToken = (value, start) => {
+  if (value[start] !== '*' || value[start + 1] !== '*' || value[start + 2] !== '*') {
+    return undefined;
+  }
+  const end = value.indexOf('***', start + 3);
+  if (end === -1) {
+    return undefined;
+  }
+  const text = value.slice(start + 3, end);
+  if (!text || text.includes('\n')) {
+    return undefined;
+  }
+  return {
+    length: end - start + 3,
+    node: {
+      children: [{
+        children: parseInlineNodes(text),
+        type: 'italic'
+      }],
+      type: 'bold'
+    }
+  };
+};
+const findItalicEnd = (value, start) => {
+  let index = start + 1;
+  while (index < value.length) {
+    if (value[index] !== '*') {
+      index++;
+      continue;
+    }
+    if (value[index + 1] !== '*') {
+      return index;
+    }
+    const boldEnd = value.indexOf('**', index + 2);
+    if (boldEnd === -1) {
+      return -1;
+    }
+    index = boldEnd + 2;
+  }
+  return -1;
+};
+const parseItalicToken = (value, start) => {
+  if (value[start] !== '*' || value[start + 1] === '*') {
+    return undefined;
+  }
+  const end = findItalicEnd(value, start);
+  if (end === -1) {
+    return undefined;
+  }
+  const text = value.slice(start + 1, end);
+  if (!text) {
+    return undefined;
+  }
+  return {
+    length: end - start + 1,
+    node: {
+      children: parseInlineNodes(text),
+      type: 'italic'
+    }
+  };
+};
+const parseStrikethroughToken = (value, start) => {
+  if (value[start] !== '~' || value[start + 1] !== '~') {
+    return undefined;
+  }
+  const end = value.indexOf('~~', start + 2);
+  if (end === -1) {
+    return undefined;
+  }
+  const text = value.slice(start + 2, end);
+  if (!text || text.includes('\n')) {
+    return undefined;
+  }
+  return {
+    length: end - start + 2,
+    node: {
+      children: parseInlineNodes(text),
+      type: 'strikethrough'
+    }
+  };
+};
+const parseInlineCodeToken = (value, start) => {
+  if (value[start] !== '`') {
+    return undefined;
+  }
+  const end = value.indexOf('`', start + 1);
+  if (end === -1) {
+    return undefined;
+  }
+  const codeText = value.slice(start + 1, end);
+  if (!codeText || codeText.includes('\n')) {
+    return undefined;
+  }
+  return {
+    length: end - start + 1,
+    node: {
+      text: codeText,
+      type: 'inline-code'
+    }
+  };
+};
+const parseMathToken = (value, start) => {
+  if (value[start] !== '$') {
+    return undefined;
+  }
+  const delimiterLength = value[start + 1] === '$' ? 2 : 1;
+  const previous = value[start - 1];
+  if (isAlphaNumeric(previous)) {
+    return undefined;
+  }
+  const next = value[start + delimiterLength];
+  if (!next || next === '.') {
+    return undefined;
+  }
+  if (next === '(' && (value[start + delimiterLength + 1] === '"' || value[start + delimiterLength + 1] === "'")) {
+    return undefined;
+  }
+  let index = start + delimiterLength;
+  while (index < value.length) {
+    if (value[index] === '\n') {
+      return undefined;
+    }
+    const isClosed = delimiterLength === 2 ? value.startsWith('$$', index) : value[index] === '$';
+    if (isClosed) {
+      const body = value.slice(start + delimiterLength, index);
+      const following = value[index + delimiterLength];
+      if (!body || isAlphaNumeric(following)) {
+        return undefined;
+      }
+      return {
+        length: index - start + delimiterLength,
+        node: {
+          displayMode: delimiterLength === 2,
+          text: body.trim(),
+          type: 'math-inline'
+        }
+      };
+    }
+    if (value[index] === '\\') {
+      index += 2;
+      continue;
+    }
+    index++;
+  }
+  return undefined;
+};
+const parseInlineToken = (value, start) => {
+  return parseImageToken(value, start) || parseLinkToken(value, start) || parseRawLinkToken(value, start) || parseBoldItalicToken(value, start) || parseBoldToken(value, start) || parseItalicToken(value, start) || parseLinkToken(value, start) || parseBoldItalicToken(value, start) || parseBoldToken(value, start) || parseItalicToken(value, start) || parseStrikethroughToken(value, start) || parseInlineCodeToken(value, start) || parseMathToken(value, start);
+};
+const parseInlineNodes = value => {
+  const nodes = [];
+  let textStart = 0;
+  let index = 0;
+  const pushText = end => {
+    if (end <= textStart) {
+      return;
+    }
+    nodes.push({
+      text: value.slice(textStart, end),
+      type: 'text'
+    });
+  };
+  while (index < value.length) {
+    const parsed = parseInlineToken(value, index);
+    if (!parsed) {
+      index++;
+      continue;
+    }
+    pushText(index);
+    nodes.push(parsed.node);
+    index += parsed.length;
+    textStart = index;
+  }
+  pushText(value.length);
+  if (nodes.length === 0) {
+    return [{
+      text: value,
+      type: 'text'
+    }];
+  }
+  return nodes;
+};
+
+const markdownMathBlockDelimiter = '$$';
+const escapedNewlineRegex = /\\r\\n|\\n/g;
+const lineBreakRegex = /\r?\n/;
+const tableDelimiterRegex = /\|\s*[-:]{3,}/;
+const inlineTableCellRegex = /\|\s+\|/g;
+const normalizeEscapedNewlines = value => {
+  if (value.includes('\\n')) {
+    return value.replaceAll(escapedNewlineRegex, '\n');
+  }
+  return value;
+};
+const normalizeInlineTables = value => {
+  return value.split(lineBreakRegex).map(line => {
+    if (!line.includes('|')) {
+      return line;
+    }
+    if (!tableDelimiterRegex.test(line)) {
+      return line;
+    }
+    return line.replaceAll(inlineTableCellRegex, '|\n|');
+  }).join('\n');
+};
+const parseHeadingLine = line => {
+  const trimmedStart = line.trimStart();
+  let index = 0;
+  while (index < trimmedStart.length && trimmedStart[index] === '#') {
+    index++;
+  }
+  if (index === 0 || index > 6) {
+    return undefined;
+  }
+  if (trimmedStart[index] !== ' ') {
+    return undefined;
+  }
+  const text = trimmedStart.slice(index).trimStart();
+  return {
+    level: index,
+    text
+  };
+};
+const parseOrderedListItemLine = line => {
+  let indentation = 0;
+  while (indentation < line.length && line[indentation] === ' ') {
+    indentation++;
+  }
+  let index = indentation;
+  const firstDigit = index;
+  while (index < line.length && line[index] >= '0' && line[index] <= '9') {
+    index++;
+  }
+  if (index === firstDigit || line[index] !== '.') {
+    return undefined;
+  }
+  index++;
+  if (line[index] !== ' ') {
+    return undefined;
+  }
+  while (index < line.length && line[index] === ' ') {
+    index++;
+  }
+  return {
+    indentation,
+    text: line.slice(index)
+  };
+};
+const parseUnorderedListItemLine = line => {
+  let indentation = 0;
+  while (indentation < line.length && line[indentation] === ' ') {
+    indentation++;
+  }
+  const marker = line[indentation];
+  if (marker !== '-' && marker !== '*') {
+    return undefined;
+  }
+  let index = indentation + 1;
+  if (line[index] !== ' ') {
+    return undefined;
+  }
+  while (index < line.length && line[index] === ' ') {
+    index++;
+  }
+  return {
+    indentation,
+    text: line.slice(index)
+  };
+};
+const parseBlockQuoteLine = line => {
+  const trimmedStart = line.trimStart();
+  if (!trimmedStart.startsWith('>')) {
+    return undefined;
+  }
+  const content = trimmedStart.slice(1);
+  if (!content) {
+    return '';
+  }
+  if (content.startsWith(' ')) {
+    return content.slice(1);
+  }
+  return content;
+};
+const isThematicBreakLine = line => {
+  const trimmedStart = line.trimStart();
+  const leadingSpaces = line.length - trimmedStart.length;
+  if (leadingSpaces > 3) {
+    return false;
+  }
+  const trimmed = trimmedStart.trimEnd();
+  if (!trimmed) {
+    return false;
+  }
+  const marker = trimmed[0];
+  if (marker !== '-' && marker !== '_' && marker !== '*') {
+    return false;
+  }
+  let markerCount = 0;
+  for (let i = 0; i < trimmed.length; i++) {
+    const char = trimmed[i];
+    if (char === marker) {
+      markerCount++;
+      continue;
+    }
+    if (char !== ' ') {
+      return false;
+    }
+  }
+  return markerCount >= 3;
+};
+const isTableRow = line => {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith('|') || !trimmed.endsWith('|')) {
+    return false;
+  }
+  return trimmed.length > 2;
+};
+const getTableCells = line => {
+  const trimmed = line.trim();
+  return trimmed.slice(1, -1).split('|').map(part => part.trim());
+};
+const scanBlockTokens = rawMessage => {
+  const normalizedMessage = normalizeInlineTables(normalizeEscapedNewlines(rawMessage));
+  const lines = normalizedMessage.split(lineBreakRegex);
+  const tokens = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed) {
+      tokens.push({
+        type: 'blank-line'
+      });
+      continue;
+    }
+    const blockQuoteLine = parseBlockQuoteLine(line);
+    if (blockQuoteLine !== undefined) {
+      tokens.push({
+        text: blockQuoteLine,
+        type: 'blockquote-line'
+      });
+      continue;
+    }
+    if (trimmed.startsWith('```')) {
+      const language = trimmed.slice(3).trim();
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].trim().startsWith('```')) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      if (language) {
+        tokens.push({
+          language,
+          text: codeLines.join('\n'),
+          type: 'code-block'
+        });
+      } else {
+        tokens.push({
+          text: codeLines.join('\n'),
+          type: 'code-block'
+        });
+      }
+      continue;
+    }
+    if (trimmed === markdownMathBlockDelimiter) {
+      const endIndex = lines.findIndex((candidate, index) => {
+        if (index <= i) {
+          return false;
+        }
+        return candidate.trim() === markdownMathBlockDelimiter;
+      });
+      if (endIndex !== -1) {
+        tokens.push({
+          text: lines.slice(i + 1, endIndex).join('\n').trim(),
+          type: 'math-block'
+        });
+        i = endIndex;
+        continue;
+      }
+    }
+    const heading = parseHeadingLine(line);
+    if (heading) {
+      tokens.push({
+        level: heading.level,
+        text: heading.text,
+        type: 'heading-line'
+      });
+      continue;
+    }
+    if (isThematicBreakLine(line)) {
+      tokens.push({
+        type: 'thematic-break'
+      });
+      continue;
+    }
+    const ordered = parseOrderedListItemLine(line);
+    if (ordered) {
+      tokens.push({
+        indentation: ordered.indentation,
+        text: ordered.text,
+        type: 'ordered-list-item-line'
+      });
+      continue;
+    }
+    const unordered = parseUnorderedListItemLine(line);
+    if (unordered) {
+      tokens.push({
+        indentation: unordered.indentation,
+        text: unordered.text,
+        type: 'unordered-list-item-line'
+      });
+      continue;
+    }
+    if (isTableRow(line)) {
+      tokens.push({
+        cells: getTableCells(line),
+        line,
+        type: 'table-row-line'
+      });
+      continue;
+    }
+    tokens.push({
+      text: line,
+      type: 'paragraph-line'
+    });
+  }
+  return tokens;
+};
+
+const isTableSeparatorCell = value => {
+  if (!value) {
+    return false;
+  }
+  let index = 0;
+  if (value[index] === ':') {
+    index++;
+  }
+  let dashCount = 0;
+  while (index < value.length && value[index] === '-') {
+    dashCount++;
+    index++;
+  }
+  if (dashCount < 3) {
+    return false;
+  }
+  if (index < value.length && value[index] === ':') {
+    index++;
+  }
+  return index === value.length;
+};
+const isTableSeparatorToken = (token, expectedColumns) => {
+  if (!token || token.type !== 'table-row-line') {
+    return false;
+  }
+  if (token.cells.length !== expectedColumns) {
+    return false;
+  }
+  return token.cells.every(isTableSeparatorCell);
+};
+const toTableCell = value => {
+  return {
+    children: parseInlineNodes(value),
+    type: 'table-cell'
+  };
+};
+const toTableRow = token => {
+  return {
+    cells: token.cells.map(toTableCell),
+    type: 'table-row'
+  };
+};
+const getEmptyTextNode = () => {
+  return [{
+    children: [{
+      text: '',
+      type: 'text'
+    }],
+    type: 'text'
+  }];
+};
+
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const parseBlockTokens = tokens => {
+  if (tokens.length === 0) {
+    return getEmptyTextNode();
+  }
+  const nodes = [];
+  let paragraphLines = [];
+  let listItems = [];
+  let listType = '';
+  let orderedListPathStack = [];
+  const getListItemAtPath = (items, path) => {
+    let currentItems = items;
+    let currentItem;
+    for (const index of path) {
+      currentItem = currentItems[index];
+      if (!currentItem) {
+        return undefined;
+      }
+      currentItems = currentItem.nestedItems || [];
+    }
+    return currentItem;
+  };
+  const appendNestedItemAtPath = (items, path, item, nestedListType) => {
+    if (path.length === 0) {
+      return [...items, item];
+    }
+    const [index, ...rest] = path;
+    const current = items[index];
+    if (!current) {
+      return [...items];
+    }
+    const nextNestedItems = rest.length > 0 ? appendNestedItemAtPath(current.nestedItems || [], rest, item, nestedListType) : [...(current.nestedItems || []), item];
+    const nextItem = {
+      ...current,
+      nestedItems: nextNestedItems,
+      nestedListType
+    };
+    return [...items.slice(0, index), nextItem, ...items.slice(index + 1)];
+  };
+  const flushParagraph = () => {
+    if (paragraphLines.length === 0) {
+      return;
+    }
+    nodes.push({
+      children: parseInlineNodes(paragraphLines.join('\n')),
+      type: 'text'
+    });
+    paragraphLines = [];
+  };
+  const flushList = () => {
+    if (listItems.length === 0) {
+      return;
+    }
+    nodes.push({
+      items: listItems,
+      type: listType || 'ordered-list'
+    });
+    listItems = [];
+    listType = '';
+    orderedListPathStack = [];
+  };
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.type === 'blank-line') {
+      flushParagraph();
+      continue;
+    }
+    if (token.type === 'code-block') {
+      flushList();
+      flushParagraph();
+      if (token.language) {
+        nodes.push({
+          language: token.language,
+          text: token.text,
+          type: 'code-block'
+        });
+      } else {
+        nodes.push({
+          text: token.text,
+          type: 'code-block'
+        });
+      }
+      continue;
+    }
+    if (token.type === 'math-block') {
+      flushList();
+      flushParagraph();
+      nodes.push({
+        text: token.text,
+        type: 'math-block'
+      });
+      continue;
+    }
+    if (token.type === 'thematic-break') {
+      flushList();
+      flushParagraph();
+      nodes.push({
+        type: 'thematic-break'
+      });
+      continue;
+    }
+    if (token.type === 'blockquote-line') {
+      flushList();
+      flushParagraph();
+      const lines = [];
+      while (i < tokens.length && tokens[i].type === 'blockquote-line') {
+        const quoteToken = tokens[i];
+        if (quoteToken.type === 'blockquote-line') {
+          lines.push(quoteToken.text);
+        }
+        i++;
+      }
+      i--;
+      nodes.push({
+        children: parseBlockTokens(scanBlockTokens(lines.join('\n'))),
+        type: 'blockquote'
+      });
+      continue;
+    }
+    if (token.type === 'table-row-line') {
+      const expectedColumns = token.cells.length;
+      if (isTableSeparatorToken(tokens[i + 1], expectedColumns)) {
+        flushList();
+        flushParagraph();
+        const rows = [];
+        i += 2;
+        while (i < tokens.length && tokens[i].type === 'table-row-line') {
+          const rowToken = tokens[i];
+          if (rowToken.type !== 'table-row-line') {
+            break;
+          }
+          if (rowToken.cells.length === expectedColumns) {
+            rows.push(toTableRow(rowToken));
+          }
+          i++;
+        }
+        i--;
+        nodes.push({
+          headers: token.cells.map(toTableCell),
+          rows,
+          type: 'table'
+        });
+        continue;
+      }
+      flushList();
+      paragraphLines.push(token.line);
+      continue;
+    }
+    if (token.type === 'ordered-list-item-line') {
+      if (listType === 'ordered-list' && listItems.length > 0 && token.indentation > 0 && orderedListPathStack.length > 0) {
+        const parentEntry = orderedListPathStack.toReversed().find(entry => entry.indentation < token.indentation);
+        if (parentEntry) {
+          const parentItem = getListItemAtPath(listItems, parentEntry.path);
+          if (parentItem) {
+            const nextItem = {
+              children: parseInlineNodes(token.text),
+              type: 'list-item'
+            };
+            const nextIndex = parentItem.nestedItems?.length || 0;
+            listItems = appendNestedItemAtPath(listItems, parentEntry.path, nextItem, 'ordered-list');
+            const nextPath = [...parentEntry.path, nextIndex];
+            orderedListPathStack = [...orderedListPathStack.filter(entry => entry.indentation < token.indentation), {
+              indentation: token.indentation,
+              path: nextPath
+            }];
+            continue;
+          }
+        }
+      }
+      if (listType && listType !== 'ordered-list') {
+        flushList();
+      }
+      flushParagraph();
+      listType = 'ordered-list';
+      const nextItem = {
+        children: parseInlineNodes(token.text),
+        type: 'list-item'
+      };
+      listItems.push(nextItem);
+      const nextIndex = listItems.length - 1;
+      orderedListPathStack = [...orderedListPathStack.filter(entry => entry.indentation < token.indentation), {
+        indentation: token.indentation,
+        path: [nextIndex]
+      }];
+      continue;
+    }
+    if (token.type === 'unordered-list-item-line') {
+      if (listType === 'ordered-list' && listItems.length > 0 && token.indentation > 0 && orderedListPathStack.length > 0) {
+        const parentEntry = orderedListPathStack.toReversed().find(entry => entry.indentation < token.indentation);
+        if (parentEntry) {
+          const nextItem = {
+            children: parseInlineNodes(token.text),
+            type: 'list-item'
+          };
+          listItems = appendNestedItemAtPath(listItems, parentEntry.path, nextItem, 'unordered-list');
+          continue;
+        }
+      }
+      if (listType && listType !== 'unordered-list') {
+        flushList();
+      }
+      flushParagraph();
+      listType = 'unordered-list';
+      listItems.push({
+        children: parseInlineNodes(token.text),
+        type: 'list-item'
+      });
+      continue;
+    }
+    if (token.type === 'heading-line') {
+      flushList();
+      flushParagraph();
+      nodes.push({
+        children: parseInlineNodes(token.text),
+        level: token.level,
+        type: 'heading'
+      });
+      continue;
+    }
+    flushList();
+    paragraphLines.push(token.text);
+  }
+  flushList();
+  flushParagraph();
+  return nodes.length === 0 ? getEmptyTextNode() : nodes;
+};
+
+const parseMessageContent = rawMessage => {
+  return parseBlockTokens(scanBlockTokens(rawMessage));
+};
+
 const commandMap = {
   ...networkCommandMap,
+  'ChatParser.parseMessageContent': parseMessageContent,
   'HandleMessagePort.handleMessagePort': handleMessagePort
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/chat-message-parsing-worker",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Chat Message Parsing Worker",
   "repository": {
     "type": "git",