fix: handle mixed-case HTML tags correctly

HTML is case-insensitive by spec, but the library was failing to process
tags with mixed case (e.g., <Br>, <DIV>, <Strong>). This caused translation
to stop prematurely, resulting in data loss.

Root cause: The HTML parser with lowerCaseTagName: false would preserve the
original case, but wouldn't recognize mixed-case void elements like <Br> as
self-closing tags. This caused content after the tag to be incorrectly parsed
as children of that tag.

Solution:
1. Set lowerCaseTagName: true in nodeHtmlParserConfig to normalize all tags
2. Updated visitor.ts to handle tags case-insensitively using toUpperCase()
3. Added comprehensive tests for various mixed-case tag scenarios

All translator lookups and element matching now work regardless of the
original HTML tag casing, preventing data loss when processing HTML with
inconsistent capitalization.

Resolves #63

Author: claude

src/utilities.ts

@@ -128,7 +128,7 @@ export const truthyStr = (v: any, value?: string): string => v ? ((value !== und
  * Note: Do not change - values are tuned for performance
  */
 export const nodeHtmlParserConfig: NodeHtmlParserOptions = {
-  lowerCaseTagName: false,
+  lowerCaseTagName: true,
   comment: false,
   fixNestedATags: true,
   blockTextElements: {

src/visitor.ts

@@ -111,14 +111,15 @@ export class Visitor {
     const { translators } = this.instance;
     (function visit(node: HtmlNode): boolean {
       let res = false
-      if (isTextNode(node) || (isElementNode(node) && contentlessElements.includes(node.tagName))) {
+      if (isTextNode(node) || (isElementNode(node) && contentlessElements.includes((node.tagName || '').toUpperCase()))) {
         res = true;
       }
       else {
         const childNodes = getChildNodes(node);
         if (!childNodes.length) {
-          const translator = translators[(node as ElementNode).tagName];
-          if (translator?.preserveIfEmpty || typeof translator === 'function') res = true;
+          const elementNode = node as ElementNode;
+          const translator = elementNode.tagName ? translators.get(elementNode.tagName) : undefined;
+          if (typeof translator === 'function' || translator?.preserveIfEmpty) res = true;
         }
         else
           for (const child of childNodes) {
@@ -171,11 +172,14 @@ export class Visitor {
     if (textOnly || !isElementNode(node)) return;
 
     /* Handle element node */
-    const translatorCfgOrFactory: TranslatorConfig | TranslatorConfigFactory | undefined =
-      metadata?.translators ? metadata.translators[node.tagName] : this.instance.translators[node.tagName];
+    const tagNameUpper = (node.tagName || '').toUpperCase();
+
+    const translatorCfgOrFactory: TranslatorConfig | TranslatorConfigFactory | undefined = tagNameUpper
+      ? (metadata?.translators ? metadata.translators[tagNameUpper] : this.instance.translators.get(node.tagName))
+      : undefined;
 
     /* Update metadata with list detail */
-    switch (node.tagName) {
+    switch (tagNameUpper) {
       case 'UL':
       case 'OL':
         metadata = {

test/special-cases.test.ts

@@ -101,4 +101,67 @@ describe(`Special Cases`, () => {
     const res = translate(html);
     expect(res).toBe(expected);
   });
+
+  // See: https://github.com/crosstype/node-html-markdown/issues/63
+  describe(`Handles mixed-case HTML tags correctly`, () => {
+    test(`handles mixed-case <Br> tag`, () => {
+      const res = translate('Foo<Br>Bar');
+      expect(res).toBe('Foo  \nBar');
+    });
+
+    test(`handles uppercase <BR> tag`, () => {
+      const res = translate('Hello<BR>World');
+      expect(res).toBe('Hello  \nWorld');
+    });
+
+    test(`handles mixed-case <DIV> tag`, () => {
+      const res = translate('<DIV>content</DIV>');
+      expect(res).toBe('content');
+    });
+
+    test(`handles mixed-case <Div> tag`, () => {
+      const res = translate('<Div>test content</Div>');
+      expect(res).toBe('test content');
+    });
+
+    test(`handles mixed-case <P> tag`, () => {
+      const res = translate('<P>Hello</P>');
+      expect(res).toBe('Hello');
+    });
+
+    test(`handles mixed-case <pArAgRaPh> tag`, () => {
+      const res = translate('<pArAgRaPh>Strange case</pArAgRaPh>');
+      expect(res).toBe('Strange case');
+    });
+
+    test(`handles mixed-case formatting tags`, () => {
+      const res = translate('<Strong>Bold</Strong> and <Em>Italic</Em>');
+      expect(res).toBe('**Bold** and _Italic_');
+    });
+
+    test(`handles mixed-case <Hr> tag`, () => {
+      const res = translate('Before<Hr>After');
+      expect(res).toBe('Before\n\n---\n\nAfter');
+    });
+
+    test(`handles mixed-case list tags`, () => {
+      const res = translate('<Ul><Li>Item 1</Li><Li>Item 2</Li></Ul>');
+      expect(res).toBe('* Item 1\n* Item 2');
+    });
+
+    test(`handles mixed-case heading tags`, () => {
+      const res = translate('<H1>Title</H1><H2>Subtitle</H2>');
+      expect(res).toBe('# Title\n\n## Subtitle');
+    });
+
+    test(`handles completely lowercase tags`, () => {
+      const res = translate('<br><div>content</div><strong>bold</strong>');
+      expect(res).toBe('  \n\ncontent\n\n**bold**');
+    });
+
+    test(`handles mixed-case nested tags without data loss`, () => {
+      const res = translate('<Div><P>Paragraph 1</P><Br><P>Paragraph 2</P></Div>');
+      expect(res).toBe('Paragraph 1\n\n  \nParagraph 2');
+    });
+  });
 });