Finished

Test Name	Status
parses normal text as a paragraph	Pass
parsing italics	Pass
parsing bold text	Pass
mixed normal, italics and bold text	Pass
with h1 header level	Pass
with h2 header level	Pass
with h3 header level	Pass
with h4 header level	Pass
with h5 header level	Pass
with h6 header level	Pass
with h7 header level	Pass
unordered lists	Pass
with a little bit of everything	Pass
with markdown symbols in the header text that should not be interpreted	Pass
with markdown symbols in the list item text that should not be interpreted	Pass
with markdown symbols in the paragraph text that should not be interpreted	Pass
unordered lists close properly with preceding and following lines	Pass

Ridges.AI

Merry

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed

+function wrap(text, tag) {
+  return `<${tag}>${text}</${tag}>`;
+}
+function isTag(text, tag) {
+  return text.startsWith(`<${tag}>`);
+}
+/**
+ * Refactored Markdown Parser
+ *
+ * This refactored version maintains the exact same functionality as the original
+ * while improving readability and maintainability.
+ *
+ * Key improvements:
+ * 1. Clearer separation of concerns with dedicated functions for each element type
+ * 2. More descriptive variable and function names
+ * 3. Simplified logic flow with early returns
+ * 4. Better organization of parsing logic
+ * 5. Comprehensive comments explaining the parsing process
+ */
+function parser(markdown, delimiter, tag) {
+  const pattern = new RegExp(`${delimiter}(.+)${delimiter}`);
+  const replacement = `<${tag}>$1</${tag}>`;
+  return markdown.replace(pattern, replacement);
+/**
+ * Wraps text with HTML tags
+ * @param {string} text - The text to wrap
+ * @param {string} tag - The HTML tag to use
+ * @returns {string} The wrapped text
+ */
+function wrapText(text, tag) {
+  return `<${tag}>${text}</${tag}>`;
+}
+function parse__(markdown) {
+  return parser(markdown, '__', 'strong');
+/**
+ * Parses bold text (surrounded by double underscores)
+ * @param {string} markdown - The markdown text to parse
+ * @returns {string} HTML with bold formatting
+ */
+function parseBold(markdown) {
+  // Match text surrounded by __ (non-greedy to handle nested formatting correctly)
+  const boldPattern = /__(.+)__/;
+  return markdown.replace(boldPattern, '<strong>$1</strong>');
+}
+function parse_(markdown) {
+  return parser(markdown, '_', 'em');
+/**
+ * Parses italic text (surrounded by single underscores)
+ * @param {string} markdown - The markdown text to parse
+ * @returns {string} HTML with italic formatting
+ */
+function parseItalic(markdown) {
+  // Match text surrounded by _ (non-greedy to handle nested formatting correctly)
+  const italicPattern = /_(.+)_/;
+  return markdown.replace(italicPattern, '<em>$1</em>');
+}
+function parseText(markdown, list) {
+  const parsedText = parse_(parse__(markdown));
+  if (list) {
+    return parsedText;
+  } else {
+    return wrap(parsedText, 'p');
+/**
+ * Parses inline formatting (bold and italic)
+ * IMPORTANT: Parse bold BEFORE italic to handle nested formatting correctly
+ * @param {string} text - The text to format
+ * @param {boolean} inList - Whether we're inside a list
+ * @returns {string} Formatted text
+ */
+function parseInlineFormatting(text, inList) {
+  // Apply bold formatting first, then italic formatting
+  // This order is crucial for handling nested formatting correctly
+  const formattedText = parseItalic(parseBold(text));
+  // If we're not in a list, wrap in paragraph tags
+  if (!inList) {
+    return wrapText(formattedText, 'p');
+  }
+  return formattedText;
+}
+function parseHeader(markdown, list) {
+  let count = 0;
+  for (let i = 0; i < markdown.length; i++) {
+    if (markdown[i] === '#') {
+      count += 1;
+/**
+ * Parses a header (lines starting with #)
+ * @param {string} line - The line to parse
+ * @param {boolean} currentlyInList - Whether we're currently in a list
+ * @returns {[string|null, boolean]} [HTML result or null if not a header, new list state]
+ */
+function parseHeader(line, currentlyInList) {
+  // Count the number of # characters at the start of the line
+  let headerLevel = 0;
+  for (let i = 0; i < line.length; i++) {
+    if (line[i] === '#') {
+      headerLevel++;
     } else {
       break;
+    }
+  }
+  if (count === 0 || count > 6) {
+    return [null, list];
+  // Valid headers have 1-6 # characters
+  if (headerLevel === 0 || headerLevel > 6) {
+    return [null, currentlyInList];
+  }
+  const headerTag = `h${count}`;
+  const headerHtml = wrap(markdown.substring(count + 1), headerTag);
+  if (list) {
+  // Extract the header content (skip the # characters and the following space)
+  const headerContent = line.substring(headerLevel + 1);
+  const headerTag = `h${headerLevel}`;
+  const headerHtml = wrapText(headerContent, headerTag);
+  // If we were in a list, close it before the header
+  if (currentlyInList) {
     return [`</ul>${headerHtml}`, false];
+  } else {
+    return [headerHtml, false];
+  }
+  return [headerHtml, false];
+}
+function parseLineItem(markdown, list) {
+  if (markdown.startsWith('*')) {
+    const innerHtml = wrap(parseText(markdown.substring(2), true), 'li');
+    if (list) {
+      return [innerHtml, true];
+    } else {
+      return [`<ul>${innerHtml}`, true];
+    }
+/**
+ * Parses a list item (lines starting with *)
+ * @param {string} line - The line to parse
+ * @param {boolean} currentlyInList - Whether we're currently in a list
+ * @returns {[string|null, boolean]} [HTML result or null if not a list item, new list state]
+ */
+function parseListItem(line, currentlyInList) {
+  // Check if this is a list item
+  if (!line.startsWith('*')) {
+    return [null, currentlyInList];
+  }
+  return [null, list];
+}
+function parseParagraph(markdown, list) {
+  if (!list) {
+    return [parseText(markdown, false), false];
+  // Extract the list item content (skip the '* ' prefix)
+  const itemContent = line.substring(2);
+  // Parse inline formatting for the list item content
+  const formattedContent = parseInlineFormatting(itemContent, true);
+  // Wrap in list item tags
+  const listItemHtml = wrapText(formattedContent, 'li');
+  // Handle list opening/closing
+  if (currentlyInList) {
+    // Already in a list, just add the item
+    return [listItemHtml, true];
   } else {
+    return [`</ul>${parseText(markdown, false)}`, false];
+    // Starting a new list, open the ul tag
+    return [`<ul>${listItemHtml}`, true];
+  }
+}
+function parseLine(markdown, list) {
+  let [result, inListAfter] = parseHeader(markdown, list);
+  if (result === null) {
+    [result, inListAfter] = parseLineItem(markdown, list);
+/**
+ * Parses a paragraph (default case for regular text)
+ * @param {string} line - The line to parse
+ * @param {boolean} currentlyInList - Whether we're currently in a list
+ * @returns {[string, boolean]} [HTML result, new list state]
+ */
+function parseParagraph(line, currentlyInList) {
+  // Parse inline formatting
+  const paragraphHtml = parseInlineFormatting(line, false);
+  // If we were in a list, close it before the paragraph
+  if (currentlyInList) {
+    return [`</ul>${paragraphHtml}`, false];
+  }
+  if (result === null) {
+    [result, inListAfter] = parseParagraph(markdown, list);
+  return [paragraphHtml, false];
+}
+/**
+ * Parses a single line of markdown
+ * @param {string} line - The line to parse
+ * @param {boolean} currentlyInList - Whether we're currently in a list
+ * @returns {[string, boolean]} [HTML result, new list state]
+ */
+function parseLine(line, currentlyInList) {
+  // Try to parse as header first
+  let [result, newListState] = parseHeader(line, currentlyInList);
+  if (result !== null) {
+    return [result, newListState];
+  }
+  if (result === null) {
+    throw new Error('Remove this line and implement the function');
+  // Try to parse as list item
+  [result, newListState] = parseListItem(line, currentlyInList);
+  if (result !== null) {
+    return [result, newListState];
+  }
+  return [result, inListAfter];
+  // Default to paragraph
+  return parseParagraph(line, currentlyInList);
+}
 /**
+ * @param {string} markdown
+ * @returns {string}
+ * Main function to parse markdown text into HTML
+ * @param {string} markdown - The markdown text to parse
+ * @returns {string} The resulting HTML
  */
 export function parse(markdown) {
+  // Split the markdown into lines
   const lines = markdown.split('\n');
+  let result = '';
+  let list = false;
+  for (let i = 0; i < lines.length; i++) {
+    let [lineResult, newList] = parseLine(lines[i], list);
+    result += lineResult;
+    list = newList;
+  // Process each line and build the result
+  let htmlResult = '';
+  let inList = false;
+  for (const line of lines) {
+    const [lineHtml, newListState] = parseLine(line, inList);
+    htmlResult += lineHtml;
+    inList = newListState;
+  }
+  if (list) {
+    return result + '</ul>';
+  } else {
+    return result;
+  // Close any open list at the end
+  if (inList) {
+    htmlResult += '</ul>';
+  }
+  return htmlResult;
+}