@globalpayments/vega 2.73.0 → 2.75.1

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.
  */
@@ -53,22 +54,27 @@ export class VegaRTEContent {
   /**
    * Create an empty content state
    *
+   * @param {VegaRTETransformOptions} options - Optional transformation options.
    * @returns {VegaRTEContent} An empty content state
    */
-  static createEmptyContent() {
+  static createEmptyContent(options = { autoMatchFormat: true }) {
     return VegaRTEContent.fromJSON([
       {
         id: generateUUID(),
         type: 'paragraph',
+        annotations: {
+          internalWrapper: !options.autoMatchFormat,
+        },
         nodes: [
           {
             id: generateUUID(),
+            annotations: { plainText: !options.autoMatchFormat },
             type: 'text',
             text: '',
           },
         ],
       },
-    ]);
+    ], options);
   }
   /**
    * Converts HTML content to a VegaRTEContent instance.
@@ -78,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;
@@ -141,8 +127,19 @@ export class VegaRTEContent {
     if (options) {
       LogUtility.warn(`The 'options' parameter in toHtml method is deprecated and will be removed in the future.`);
     }
+    if (this.isEmpty()) {
+      return '';
+    }
     return this.children.map((block) => block.toHtml()).join('');
   }
+  /**
+   * Checks if the content state is empty.
+   *
+   * @returns {boolean} True if the content state is empty, false otherwise.
+   */
+  isEmpty() {
+    return this.children.length === 0 || (this.children.length === 1 && !this.children[0].isNotEmpty());
+  }
   /**
    * Internal method to add the block item, remove the block item
    *

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

@@ -90,7 +90,7 @@ __decorate([
   MapToComponentField()
 ], RTEExtensionController.prototype, "selectionController", void 0);
 __decorate([
-  MapToComponentMethod('connectedCallback')
+  MapToComponentMethod('componentDidLoad')
 ], RTEExtensionController.prototype, "initialExtensionContext", null);
 __decorate([
   MapToComponentMethod('watchExtensions')

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

@@ -0,0 +1 @@
+export {};

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

@@ -50,11 +50,12 @@ export class ValueController extends VegaSlimmer {
    * Watches the value of the editor and updates the internal value.
    */
   watchValueUpdate() {
+    const autoMatchFormat = this.sourceEditConfig.autoMatchFormat;
     if (this.value && !(this.value instanceof VegaRTEContent)) {
-      this.value = VegaRTEContent.fromJSON(this.value);
+      this.value = VegaRTEContent.fromJSON(this.value, { autoMatchFormat });
     }
     else if (!this.value || this.value.children.length === 0) {
-      this.value = VegaRTEContent.createEmptyContent();
+      this.value = VegaRTEContent.createEmptyContent({ autoMatchFormat });
     }
     else {
       this.changeEventEmitter.emit(this.value);
@@ -114,6 +115,9 @@ __decorate([
 __decorate([
   MapToComponentField()
 ], ValueController.prototype, "selectionController", void 0);
+__decorate([
+  MapToComponentField()
+], ValueController.prototype, "sourceEditConfig", void 0);
 __decorate([
   MapToComponentMethod('connectedCallback')
 ], ValueController.prototype, "connectedCallback", null);

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

@@ -37,6 +37,9 @@ export class SourceEditToolbarButtonSlimmer extends ToolbarButtonSlimmer {
   }
   async saveSourceCode() {
     const sourceViewValue = this.vegaRichTextEditorRenderer.getSourceCode();
+    if (!sourceViewValue && this.value.isEmpty()) {
+      return;
+    }
     if (typeof sourceViewValue === 'string') {
       await this.valueController.flushChanges(VegaRTEContent.fromHtml(sourceViewValue, {
         autoMatchFormat: this.sourceEditConfig.autoMatchFormat,
@@ -62,3 +65,6 @@ __decorate([
 __decorate([
   MapToComponentField()
 ], SourceEditToolbarButtonSlimmer.prototype, "sourceEditConfig", void 0);
+__decorate([
+  MapToComponentField()
+], SourceEditToolbarButtonSlimmer.prototype, "value", void 0);

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>
@@ -2797,6 +2798,11 @@ Line 1
       const paragraph = content.children[0];
       expect(paragraph.children[1].text).toEqual(' ');
     });
+    it('should convert empty value as expect', async () => {
+      const emptyContent = VegaRTEContent.fromHtml('', { autoMatchFormat: false });
+      expect(emptyContent.toHtml()).toEqual('');
+      expect(emptyContent.toJSON()).toEqual([]);
+    });
   });
   describe('fromJSON', () => {
     it('should translate the paragraph as expect JSON', () => {
@@ -2950,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>');
+    });
+  });
 });