@heartlandone/vega 2.75.0 → 2.76.0

package/dist/collection/components/vega-progress-tracker/vega-progress-tracker.js

@@ -220,9 +220,14 @@ export class VegaProgressTracker {
       "type": "unknown",
       "mutable": false,
       "complexType": {
-        "original": "string[]",
-        "resolved": "string[]",
-        "references": {}
+        "original": "string[] | VegaProgressTrackerStepItem[]",
+        "resolved": "VegaProgressTrackerStepItem[] | string[]",
+        "references": {
+          "VegaProgressTrackerStepItem": {
+            "location": "import",
+            "path": "./type"
+          }
+        }
       },
       "required": false,
       "optional": false,

package/dist/collection/components/vega-rich-text-content/vega-rich-text-content.js

@@ -11,7 +11,7 @@ import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/
 import { VegaRichTextContentRenderer } from './slimmers/renderers/vega-rich-text-content-renderer';
 import { VegaRichTextContentStateController } from './slimmers/controllers/vega-rich-text-content-state-controller';
 import { findParent } from '../../utils/ui';
-import { waitForComponentDidRender } from '../../helpers/common';
+import { waitForComponentDidRender } from '../../helpers/common/wait-for-component-did-render';
 import { RTEExtensionStylesController } from './slimmers/controllers/vega-rich-text-content-extensions-styles-controller';
 /**
  * @vegaVersion 2.34.0

package/dist/collection/components/vega-rich-text-editor/dto/blocks/html-block.js

@@ -53,6 +53,12 @@ export class RTEHtmlBlock extends RTEBlock {
   toHtml() {
     const BlockTag = this.htmlTag;
     const attrStr = super.generateAttributeString();
+    // Handle void/self-closing tags (hr, input, col, etc.)
+    // Uses HTML5 syntax without self-closing slash for consistency with img and br tags
+    if (RTEHtmlBlock.VOID_TAGS.has(this.htmlTag)) {
+      return `<${BlockTag}${attrStr}>`;
+    }
+    // Handle normal tags with children
     return [
       `<${BlockTag}${attrStr}>`,
       this.children.map((block) => block.toHtml()).join(''),
@@ -66,3 +72,13 @@ export class RTEHtmlBlock extends RTEBlock {
     return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: this.type, htmlTag: this.htmlTag, children: this.children.map((child) => child.toJSON()) });
   }
 }
+/**
+ * Void/self-closing tags that don't have closing tags and don't contain children.
+ * These tags should be rendered as <tag> or <tag/> instead of <tag></tag>.
+ *
+ * Based on canHandleTags from html-block-strategy.ts, the following are void tags:
+ * - HR: horizontal rule
+ * - INPUT: form input
+ * - COL: table column
+ */
+RTEHtmlBlock.VOID_TAGS = new Set(['hr', 'input', 'col']);

package/dist/collection/components/vega-rich-text-editor/dto/content-state.js

@@ -21,6 +21,7 @@ import { VegaInternalRichTextEditorFlushChanges } from '../../../helpers/event-m
 import './setup';
 import { StylePreservator } from '../../../helpers/csp/styles-preservator';
 import { LogUtility } from '../../../utils/log';
+import { HTMLContentCleaner } from '../slimmers/controllers/html-cleaner';
 /**
  * Class representing the content state of the rich text editor.
  */
@@ -83,28 +84,8 @@ export class VegaRTEContent {
    * @returns {VegaRTEContent} The converted content state.
    */
   static fromHtml(html, options = { autoMatchFormat: true, skipCustomAnnotations: false }) {
-    /**
-     * remove redundant spaces between tags, for example:
-     * case1:
-     * '<p>\n\t <span>test</span>\n\t </p>' will be formatted into '<p><span>test</span></p>'
-     * '<p>
-     * 		test
-     * 	</p>' will be formatted into '<p>test</p>'
-     *
-     * case2:
-     * <h1>
-     * _test&*....
-     * </h1> will be formatted into <h1>_test&*....</h1>
-     *
-     * The blank space between individual tags should be preserved:
-     * <span> </span>
-     */
-    const formattedHtml = html
-      .replace(/>\s+<\/?/g, (match) => {
-      return match.endsWith('</') ? match : '><';
-    })
-      .replace(/(>)[\n\t]+(?=[a-zA-Z0-9_\W])/g, '$1')
-      .replace(/([a-zA-Z0-9_\W])[\n\t]+(?=<)/g, '$1');
+    const cleaner = new HTMLContentCleaner();
+    const formattedHtml = cleaner.clean(html);
     const context = StylePreservator.preserve(formattedHtml);
     const safeHtml = context.getProcessedHtml();
     const body = new DOMParser().parseFromString(safeHtml, 'text/html').body;

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/html-cleaner/html-content-cleaner.js

@@ -0,0 +1,59 @@
+import { RemoveWhitespaceBetweenTagsProcessor } from './processors/remove-whitespace-between-tags-processor';
+import { RemoveWhitespaceAfterOpeningTagProcessor } from './processors/remove-whitespace-after-opening-tag-processor';
+import { RemoveWhitespaceBeforeClosingTagProcessor } from './processors/remove-whitespace-before-closing-tag-processor';
+/**
+ * Main HTML content cleaner that orchestrates multiple cleaning processors.
+ *
+ * This class implements a chain of responsibility pattern where each processor
+ * handles a specific aspect of HTML cleaning. The processors are applied in sequence
+ * and the entire chain is repeated until no more changes occur.
+ *
+ * Processors (in order):
+ * 1. RemoveWhitespaceBetweenTagsProcessor - Removes whitespace between non-matching tags
+ * 2. RemoveWhitespaceAfterOpeningTagProcessor - Removes \n and \t after opening tags
+ * 3. RemoveWhitespaceBeforeClosingTagProcessor - Removes \n and \t before closing tags
+ */
+export class HTMLContentCleaner {
+  constructor() {
+    this.processors = [
+      new RemoveWhitespaceBetweenTagsProcessor(),
+      new RemoveWhitespaceAfterOpeningTagProcessor(),
+      new RemoveWhitespaceBeforeClosingTagProcessor(),
+    ];
+  }
+  /**
+   * Cleans HTML by applying all processors in the chain repeatedly until no changes occur.
+   *
+   * The cleaning process:
+   * 1. Applies each processor in sequence
+   * 2. Compares the result with the input
+   * 3. If changes were made, repeats the process
+   * 4. Returns the final cleaned HTML
+   *
+   * Examples of transformations:
+   * - `<p>\n\t <span>test</span>\n\t </p>` → `<p><span>test</span></p>`
+   * - `<p>\n\tHello</p>` → `<p>Hello</p>`
+   * - `<p>Hello\n\t</p>` → `<p>Hello</p>`
+   * - `<span> </span>` → `<span> </span>` (preserved - matching tags)
+   * - `<p>Hello  World</p>` → `<p>Hello  World</p>` (preserved - regular spaces)
+   *
+   * @param {string} html - The HTML string to clean.
+   * @returns {string} The cleaned HTML string.
+   */
+  clean(html) {
+    if (!html || html.trim().length === 0) {
+      return html;
+    }
+    let result = html;
+    let previousResult;
+    // Keep processing until no more changes occur
+    do {
+      previousResult = result;
+      // Apply each processor in the chain
+      for (const processor of this.processors) {
+        result = processor.process(result);
+      }
+    } while (result !== previousResult);
+    return result;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/html-cleaner/index.js

@@ -0,0 +1,4 @@
+export { HTMLContentCleaner } from './html-content-cleaner';
+export { RemoveWhitespaceBetweenTagsProcessor } from './processors/remove-whitespace-between-tags-processor';
+export { RemoveWhitespaceAfterOpeningTagProcessor } from './processors/remove-whitespace-after-opening-tag-processor';
+export { RemoveWhitespaceBeforeClosingTagProcessor } from './processors/remove-whitespace-before-closing-tag-processor';

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/html-cleaner/processors/remove-whitespace-after-opening-tag-processor.js

@@ -0,0 +1,21 @@
+/**
+ * Removes `\n` and `\t` characters after opening tags (before text content).
+ *
+ * Transforms patterns like `>[\n\t]+(text)` to `>(text)`.
+ *
+ * Examples:
+ * - `<p>\n\tHello` → `<p>Hello`
+ * - `<div>\n\n\tWorld` → `<div>World`
+ */
+export class RemoveWhitespaceAfterOpeningTagProcessor {
+  /**
+   * Process the HTML string to remove `\n` and `\t` after opening tags.
+   *
+   * @param {string} html - The HTML string to process.
+   * @returns {string} The processed HTML string.
+   */
+  process(html) {
+    // Pattern: `>[\n\t]+(text)` → `>(text)`
+    return html.replace(/(>)[\n\t]+(?=.)/g, '$1');
+  }
+}

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/html-cleaner/processors/remove-whitespace-before-closing-tag-processor.js

@@ -0,0 +1,21 @@
+/**
+ * Removes `\n` and `\t` characters before closing tags (after text content).
+ *
+ * Transforms patterns like `(text)[\n\t]+<` to `(text)<`.
+ *
+ * Examples:
+ * - `World\n\t</p>` → `World</p>`
+ * - `Hello\n</div>` → `Hello</div>`
+ */
+export class RemoveWhitespaceBeforeClosingTagProcessor {
+  /**
+   * Process the HTML string to remove `\n` and `\t` before closing tags.
+   *
+   * @param {string} html - The HTML string to process.
+   * @returns {string} The processed HTML string.
+   */
+  process(html) {
+    // Pattern: `(text)[\n\t]+<` → `(text)<`
+    return html.replace(/(.?)[\n\t]+(?=<)/g, '$1');
+  }
+}

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/html-cleaner/processors/remove-whitespace-between-tags-processor.js

@@ -0,0 +1,77 @@
+/**
+ * Removes whitespace between tags, except preserves ALL whitespace between matching opening/closing tag pairs.
+ *
+ * This processor scans for patterns of `<tag>(whitespace)<tag>` and:
+ * - If the first tag is an opening tag and the second tag is its matching closing tag (e.g., `<span> </span>`),
+ *   preserves ALL the whitespace between them (including spaces, tabs, newlines)
+ * - Otherwise, removes all the whitespace between the tags
+ *
+ * Examples:
+ * - `</p>\n\t<div>` → `</p><div>` (different tags: closing p, opening div - whitespace removed)
+ * - `<div>\n\t<span>` → `<div><span>` (different tags: opening div, opening span - whitespace removed)
+ * - `<span> </span>` → `<span> </span>` (matching tags: opening span, closing span - space preserved)
+ * - `<span>  </span>` → `<span>  </span>` (matching tags - multiple spaces preserved)
+ * - `<span>\n\t</span>` → `<span>\n\t</span>` (matching tags - \n\t preserved)
+ * - `<code> </code>` → `<code> </code>` (matching tags - space preserved)
+ * - `</div> <p>` → `</div><p>` (different tags: closing div, opening p - whitespace removed)
+ */
+export class RemoveWhitespaceBetweenTagsProcessor {
+  /**
+   * Process the HTML string to remove whitespace between non-matching tags.
+   *
+   * @param {string} html - The HTML string to process.
+   * @returns {string} The processed HTML string.
+   */
+  process(html) {
+    return html.replace(/(<[^>]+>)(\s+)(<[^>]+>)/g, (_match, tag1, whitespace, tag2) => {
+      const openingTagName = this.extractOpeningTagName(tag1);
+      const closingTagName = this.extractClosingTagName(tag2);
+      // Preserve all whitespace if tags match (e.g., <span> </span>)
+      if (openingTagName && closingTagName && openingTagName === closingTagName) {
+        return `${tag1}${whitespace}${tag2}`;
+      }
+      // Remove whitespace for non-matching tags
+      return `${tag1}${tag2}`;
+    });
+  }
+  /**
+   * Extracts the tag name from an opening HTML tag.
+   *
+   * Supports standard HTML tags (div, span, h1, etc.) and custom elements with hyphens (my-component).
+   *
+   * Examples:
+   * - `<span>` → `span`
+   * - `<div class="test">` → `div`
+   * - `<my-component id="123">` → `my-component`
+   * - `</span>` → `null` (not an opening tag)
+   *
+   * @param {string} tag - The tag string to extract from (e.g., '<span>', '<div class="test">').
+   * @returns {string | null} The tag name or null if not an opening tag.
+   * @private
+   */
+  extractOpeningTagName(tag) {
+    // Pattern: <(tag name) where tag name starts with letter, followed by letters/numbers/hyphens
+    const match = tag.match(/<(\w[\w-]*)/);
+    return match ? match[1] : null;
+  }
+  /**
+   * Extracts the tag name from a closing HTML tag.
+   *
+   * Supports standard HTML tags (div, span, h1, etc.) and custom elements with hyphens (my-component).
+   *
+   * Examples:
+   * - `</span>` → `span`
+   * - `</div>` → `div`
+   * - `</my-component>` → `my-component`
+   * - `<span>` → `null` (not a closing tag)
+   *
+   * @param {string} tag - The tag string to extract from (e.g., '</span>', '</div>').
+   * @returns {string | null} The tag name or null if not a closing tag.
+   * @private
+   */
+  extractClosingTagName(tag) {
+    // Pattern: </(tag name) where tag name starts with letter, followed by letters/numbers/hyphens
+    const match = tag.match(/<\/(\w[\w-]*)/);
+    return match ? match[1] : null;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/value-controller.js

@@ -13,7 +13,7 @@ import { VegaInternalRichTextEditorFlushChanges } from '../../../../helpers/even
 import { Observer } from '../../../../helpers/change-manager/observer/observer';
 import { debounce } from '../../../../utils/timer';
 import { VegaRTEContent } from '../../dto/content-state';
-import { waitForComponentDidRender } from '../../../../helpers/common';
+import { waitForComponentDidRender } from '../../../../helpers/common/wait-for-component-did-render';
 import { RTEEditorState } from '../../dto/editor-state';
 import { RTESelectionState } from '../../dto/selection-state';
 import stateEntityRenderingRegistry from './state-entity-rendering-registry';

package/dist/collection/components/vega-rich-text-editor/slimmers/renderers/tools/link-toolbar-button-slimmer.js

@@ -14,7 +14,7 @@ import { LinkAnnotationAction } from '../../../dto/actions/link-annotation-actio
 import { NodeAnnotationTypeEnum } from '../../../dto/annotations/node-annotation.abstract';
 import { SelectionChangeAction } from '../../../dto/actions/selection-change-action';
 import { generateUUID } from '../../../../../utils/misc';
-import { waitForComponentDidRender } from '../../../../../helpers/common';
+import { waitForComponentDidRender } from '../../../../../helpers/common/wait-for-component-did-render';
 import { VisualModeToolbarButtonSlimmer } from './visual-mode-toolbar-button-slimmer.abstract';
 export class LinkToolbarButtonSlimmer extends VisualModeToolbarButtonSlimmer {
   constructor() {

package/dist/collection/components/vega-rich-text-editor/test/dto/blocks/html-block.test.js

@@ -39,6 +39,45 @@ describe('HTMLBlock', () => {
         ],
       }, { autoMatchFormat: false }).toHtml()).toMatchSnapshot();
     });
+    it('toHtml should handle self-closing hr tag correctly', () => {
+      const hrBlock = RTEHtmlBlock.from({
+        id: 'hr-1',
+        type: 'html-block',
+        htmlTag: 'hr',
+        children: [],
+      }, { autoMatchFormat: false });
+      expect(hrBlock.toHtml()).toBe('<hr>');
+    });
+    it('toHtml should handle self-closing hr tag with attributes correctly', () => {
+      const hrBlock = RTEHtmlBlock.from({
+        id: 'hr-1',
+        type: 'html-block',
+        htmlTag: 'hr',
+        annotations: { customClass: ['divider'] },
+        children: [],
+      }, { autoMatchFormat: false });
+      expect(hrBlock.toHtml()).toBe('<hr class="divider">');
+    });
+    it('toHtml should handle self-closing input tag correctly', () => {
+      const inputBlock = RTEHtmlBlock.from({
+        id: 'input-1',
+        type: 'html-block',
+        htmlTag: 'input',
+        annotations: { customAttribute: { type: 'text', placeholder: 'Enter text' } },
+        children: [],
+      }, { autoMatchFormat: false });
+      expect(inputBlock.toHtml()).toBe('<input type="text" placeholder="Enter text">');
+    });
+    it('toHtml should handle self-closing col tag correctly', () => {
+      const colBlock = RTEHtmlBlock.from({
+        id: 'col-1',
+        type: 'html-block',
+        htmlTag: 'col',
+        annotations: { customAttribute: { span: '2' } },
+        children: [],
+      }, { autoMatchFormat: false });
+      expect(colBlock.toHtml()).toBe('<col span="2">');
+    });
   });
   describe('public methods', () => {
     let htmlBlock;

package/dist/collection/components/vega-rich-text-editor/test/dto/content-state.test.js

@@ -1,4 +1,5 @@
 import { VegaRTEContent } from '../../dto/content-state';
+import { HTMLContentCleaner } from '../../slimmers/controllers/html-cleaner';
 import { RTETextBlock } from '../../dto/blocks/text-block';
 import { RTEImageBlock } from '../../dto/blocks/image-block';
 import { RTEListBlock } from '../../dto/blocks/list-block';
@@ -2613,7 +2614,7 @@ describe('content state', () => {
       </footer>
     </article>
     <address>ADDRESS: 123 Main St, City, Country</address>
-    <blockquote cite="https://example.com">BLOCKQUOTE: “This is a quoted text.”ote>
+    <blockquote cite="https://example.com">BLOCKQUOTE: “This is a quoted text.”</blockquote>
     <details>
       <summary>DETAILS / SUMMARY Example</summary>
       <p>Extra information shown when expanded.</p>
@@ -2955,4 +2956,168 @@ Line 1
       });
     });
   });
+  describe('cleanHtmlWhitespace', () => {
+    const cleaner = new HTMLContentCleaner();
+    const cleanHtmlWhitespace = (html) => {
+      return cleaner.clean(html);
+    };
+    it('should inline a table by removing all whitespace between tags', () => {
+      const input = `<table style="width: 400px; border-collapse: collapse;">   <thead>     <tr>       ` +
+        `<th style="padding: 12px; text-align: left; font-weight: bold;">Header 1</th>       ` +
+        `<th style="padding: 12px; text-align: left; font-weight: bold;">Header 2</th>       ` +
+        `<th style="padding: 12px; text-align: left; font-weight: bold;">Header 3</th>     ` +
+        `</tr>   </thead>   <tbody>     <tr>       <td style="padding: 12px;">Cell 1-1</td>       ` +
+        `<td style="padding: 12px;">Cell 1-2</td>       <td style="padding: 12px;">Cell 1-3</td>     ` +
+        `</tr>     <tr>       <td style="padding: 12px;">Cell 2-1</td>       <td style="padding: 12px;">Cell 2-2</td>       ` +
+        `<td style="padding: 12px;">Cell 2-3</td>     </tr>     <tr>       <td style="padding: 12px;">Cell 3-1</td>       ` +
+        `<td style="padding: 12px;">Cell 3-2</td>       <td style="padding: 12px;">Cell 3-3</td>     ` +
+        `</tr>   </tbody> </table>`;
+      const expected = `<table style="width: 400px; border-collapse: collapse;"><thead><tr>` +
+        `<th style="padding: 12px; text-align: left; font-weight: bold;">Header 1</th>` +
+        `<th style="padding: 12px; text-align: left; font-weight: bold;">Header 2</th>` +
+        `<th style="padding: 12px; text-align: left; font-weight: bold;">Header 3</th>` +
+        `</tr></thead><tbody><tr>` +
+        `<td style="padding: 12px;">Cell 1-1</td>` +
+        `<td style="padding: 12px;">Cell 1-2</td>` +
+        `<td style="padding: 12px;">Cell 1-3</td>` +
+        `</tr><tr>` +
+        `<td style="padding: 12px;">Cell 2-1</td>` +
+        `<td style="padding: 12px;">Cell 2-2</td>` +
+        `<td style="padding: 12px;">Cell 2-3</td>` +
+        `</tr><tr>` +
+        `<td style="padding: 12px;">Cell 3-1</td>` +
+        `<td style="padding: 12px;">Cell 3-2</td>` +
+        `<td style="padding: 12px;">Cell 3-3</td>` +
+        `</tr></tbody></table>`;
+      expect(cleanHtmlWhitespace(input)).toBe(expected);
+    });
+    it('should remove \\n\\t after opening tag and before closing tag', () => {
+      const input = '<p>\n\t <span>test</span>\n\t </p>';
+      expect(cleanHtmlWhitespace(input)).toBe('<p><span>test</span></p>');
+    });
+    it('should remove all \\n and \\t characters', () => {
+      const input = '<p>\n\ttest\n</p>';
+      expect(cleanHtmlWhitespace(input)).toBe('<p>test</p>');
+    });
+    it('should preserve space between matching tags', () => {
+      const input = '<span> </span>';
+      expect(cleanHtmlWhitespace(input)).toBe('<span> </span>');
+    });
+    it('should preserve space with text between matching tags', () => {
+      const input = '<span> test </span>';
+      expect(cleanHtmlWhitespace(input)).toBe('<span> test </span>');
+    });
+    it('should preserve multiple spaces between matching tags', () => {
+      const input = '<span>  </span>';
+      expect(cleanHtmlWhitespace(input)).toBe('<span>  </span>');
+    });
+    it('should remove whitespace between opening tags', () => {
+      const input = '<div>\n\t<p></p></div>';
+      expect(cleanHtmlWhitespace(input)).toBe('<div><p></p></div>');
+    });
+    it('should remove \\n\\t after opening tag but preserve regular spaces', () => {
+      const input = '<p>\n\t  Hello</p>';
+      expect(cleanHtmlWhitespace(input)).toBe('<p>  Hello</p>');
+    });
+    it('should remove whitespace between multiple closing tags', () => {
+      const input = '<table><tbody><tr></tr> </tbody> </table>';
+      expect(cleanHtmlWhitespace(input)).toBe('<table><tbody><tr></tr></tbody></table>');
+    });
+    it('should remove whitespace between multiple opening tags', () => {
+      const input = '<div> <span></span></div>';
+      expect(cleanHtmlWhitespace(input)).toBe('<div><span></span></div>');
+    });
+    it('should handle complex nested structure', () => {
+      const input = '<div>\n\t<p>\n\t\t<span>Hello</span>\n\t</p>\n</div>';
+      expect(cleanHtmlWhitespace(input)).toBe('<div><p><span>Hello</span></p></div>');
+    });
+    it('should preserve regular spaces within text content', () => {
+      const input = '<p>Hello World</p>';
+      expect(cleanHtmlWhitespace(input)).toBe('<p>Hello World</p>');
+    });
+    it('should preserve multiple spaces in text content', () => {
+      const input = '<p>Hello  World</p>';
+      expect(cleanHtmlWhitespace(input)).toBe('<p>Hello  World</p>');
+    });
+    it('should not remove \\n between words in text content', () => {
+      const input = '<p>Hello\nWorld</p>';
+      expect(cleanHtmlWhitespace(input)).toBe('<p>Hello\nWorld</p>');
+    });
+    it('should not remove \\n between words with space in text content', () => {
+      const input = '<p>Hello\n World</p>';
+      expect(cleanHtmlWhitespace(input)).toBe('<p>Hello\n World</p>');
+    });
+    it('should remove newline after img tag', () => {
+      const input = '<div><img id="image-id" class="img-class" style="vertical-align: bottom; width: 25%; padding: 20px" alt="test alt" src="data:image/svg+xml;base64,xxx=" data-size="sm">\n</div>';
+      const expected = '<div><img id="image-id" class="img-class" style="vertical-align: bottom; width: 25%; padding: 20px" alt="test alt" src="data:image/svg+xml;base64,xxx=" data-size="sm"></div>';
+      expect(cleanHtmlWhitespace(input)).toBe(expected);
+    });
+    it('should handle 4-level deep nesting', () => {
+      const input = '<div>\n\t<section>\n\t\t<article>\n\t\t\t<p>Text</p>\n\t\t</article>\n\t</section>\n</div>';
+      expect(cleanHtmlWhitespace(input)).toBe('<div><section><article><p>Text</p></article></section></div>');
+    });
+    it('should handle 5-level deep nesting', () => {
+      const input = '<div>\n\t<section>\n\t\t<article>\n\t\t\t<main>\n\t\t\t\t<p>Text</p>\n\t\t\t</main>\n\t\t</article>\n\t</section>\n</div>';
+      expect(cleanHtmlWhitespace(input)).toBe('<div><section><article><main><p>Text</p></main></article></section></div>');
+    });
+    it('should handle 6-level deep nesting', () => {
+      const input = '<div>\n\t<section>\n\t\t<article>\n\t\t\t<main>\n\t\t\t\t<aside>\n\t\t\t\t\t<p>Text</p>\n\t\t\t\t</aside>\n\t\t\t</main>\n\t\t</article>\n\t</section>\n</div>';
+      expect(cleanHtmlWhitespace(input)).toBe('<div><section><article><main><aside><p>Text</p></aside></main></article></section></div>');
+    });
+    it('should remove whitespace after br and hr tags', () => {
+      const input1 = '<div><br>\n</div>';
+      expect(cleanHtmlWhitespace(input1)).toBe('<div><br></div>');
+      const input2 = '<div><hr>\n\t</div>';
+      expect(cleanHtmlWhitespace(input2)).toBe('<div><hr></div>');
+      const input3 = '<div><input type="text">\n</div>';
+      expect(cleanHtmlWhitespace(input3)).toBe('<div><input type="text"></div>');
+    });
+    it('should remove multiple consecutive \\n characters', () => {
+      const input = '<p>\n\n\n\nHello</p>';
+      expect(cleanHtmlWhitespace(input)).toBe('<p>Hello</p>');
+    });
+    it('should remove multiple consecutive \\t characters', () => {
+      const input = '<p>\t\t\tHello</p>';
+      expect(cleanHtmlWhitespace(input)).toBe('<p>Hello</p>');
+    });
+    it('should preserve empty matching tags', () => {
+      const input = '<span></span>';
+      expect(cleanHtmlWhitespace(input)).toBe('<span></span>');
+    });
+    it('should handle mixed spaces, tabs, and newlines', () => {
+      const input = '<div> \n\t <p>Text</p> \n\t </div>';
+      expect(cleanHtmlWhitespace(input)).toBe('<div><p>Text</p></div>');
+    });
+    it('should preserve spaces in attribute values', () => {
+      const input = '<p class="my custom class">Text</p>';
+      expect(cleanHtmlWhitespace(input)).toBe('<p class="my custom class">Text</p>');
+    });
+    it('should remove newlines after br tags', () => {
+      const input = '<p>Line 1<br>\nLine 2</p>';
+      expect(cleanHtmlWhitespace(input)).toBe('<p>Line 1<br>Line 2</p>');
+    });
+    it('should preserve spaces in code blocks between matching tags', () => {
+      const input = '<code>  const x = 1;  </code>';
+      expect(cleanHtmlWhitespace(input)).toBe('<code>  const x = 1;  </code>');
+    });
+    it('should handle empty string', () => {
+      expect(cleanHtmlWhitespace('')).toBe('');
+    });
+    it('should preserve plain text without tags', () => {
+      const input = 'Hello World';
+      expect(cleanHtmlWhitespace(input)).toBe('Hello World');
+    });
+    it('should remove whitespace between different inline elements', () => {
+      const input = '<span>text</span>\n\t<strong>bold</strong>';
+      expect(cleanHtmlWhitespace(input)).toBe('<span>text</span><strong>bold</strong>');
+    });
+    it('should remove \\t\\n combination', () => {
+      const input = '<p>\t\nHello</p>';
+      expect(cleanHtmlWhitespace(input)).toBe('<p>Hello</p>');
+    });
+    it('should remove complex \\n\\t\\n patterns', () => {
+      const input = '<p>\n\t\n\t\nHello</p>';
+      expect(cleanHtmlWhitespace(input)).toBe('<p>Hello</p>');
+    });
+  });
 });