@heartlandone/vega 2.75.0 → 2.76.0

package/dist/cjs/{date-required-rule-30ee62d0.js → date-required-rule-912469e0.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const typeGuard = require('./type-guard-a0f026d8.js');
+const typeGuard = require('./type-guard-407ba0b8.js');
 const internalFormFieldValidationRule_abstract = require('./internal-form-field-validation-rule.abstract-07cdff46.js');
 
 /**

package/dist/cjs/{design-token-cbc01283.js → design-token-41baf118.js}

@@ -1,9 +1,9 @@
 'use strict';
 
-const typeGuard = require('./type-guard-a0f026d8.js');
+const typeGuard = require('./type-guard-407ba0b8.js');
 const breakpoints = require('./breakpoints-ebde4837.js');
 const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
-const responsiveFormatFacade = require('./responsive-format-facade-f71d399c.js');
+const responsiveFormatFacade = require('./responsive-format-facade-ea59bdcd.js');
 const typography = require('./typography-4560e7f1.js');
 const ui = require('./ui-32e69595.js');
 

package/dist/cjs/dom-node-subject-observer-factory-c62823de.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const changeManager = require('./change-manager-a297e4d2.js');
+const observer = require('./observer-f49483e8.js');
+const ui = require('./ui-234ea151.js');
+
+/** The DomNodeSubject class represents a subject related to DOM nodes. */
+class DomNodeSubject {
+  /**
+   * The constructor function takes a SubjectTitle parameter and assigns it to the private title property.
+   *
+   * @param {SubjectTitle} title - The "title" parameter is a private property of the class that is of type "SubjectTitle".
+   * @param {HTMLElement} host - The `host` parameter is an HTMLElement that represents the container or
+   * parent element where the subject title will be displayed. It is used to specify the location where
+   * the title will be rendered on the web page.
+   */
+  constructor(title, host) {
+    this.title = title;
+    this.host = host;
+  }
+  /**
+   * The getDescription function returns the title of an object as a string.
+   *
+   * @returns {string} The title of the object.
+   */
+  getDescription() {
+    return `, this is a dom nodes subject of ${this.title}.(class name:${this.host.className}, id:${this.host.id})`;
+  }
+}
+
+/** The `DomNodesSubjectFactory` class is responsible for managing and caching `DomNodeSubject` objects associated with HTML elements. */
+class DomNodeSubjectFactory {
+  constructor() {
+    this.cache = new Map();
+  }
+  /**
+   * The function `getSubject` returns the subject associated with a given node and event ID, either from the cache or by setting it if it doesn't exist.
+   *
+   * @param {HTMLElement} node - The `node` parameter is an HTMLElement, which represents an element in the HTML document.
+   * @param {VegaEventIDInterface} eventId - The `eventId` parameter is of type `VegaEventIDInterface`. It represents the ID of the event for which we want to get the subject.
+   * @returns {DomNodeSubject} a `DomNodeSubject` object.
+   */
+  getSubject(node, eventId) {
+    if (this.isExist(node, eventId)) {
+      return this.cache.get(node).get(eventId);
+    }
+    else {
+      return this.setSubject(node, eventId);
+    }
+  }
+  /**
+   * The function checks if a given node exists in the cache and if it has a specific event ID.
+   *
+   * @param {HTMLElement} node - The "node" parameter is an HTMLElement, which represents an HTML element in the DOM (Document Object Model). It could be any HTML element such as a div, span, button, etc.
+   * @param {VegaEventIDInterface} eventId - The `eventId` parameter is of type `VegaEventIDInterface`. It represents an event ID that is used to identify a specific event.
+   * @returns {boolean} a boolean value.
+   */
+  isExist(node, eventId) {
+    if (node) {
+      return (this.cache.has(node) &&
+        this.cache.get(node) !== undefined &&
+        this.cache.get(node).has(eventId));
+    }
+    return false;
+  }
+  /**
+   * The function find if the parent of a given node exists in the cache and if it has a specific event ID.
+   *
+   * @param {HTMLElement} childNode - Child node.
+   * @param {VegaEventIDInterface} eventId - eventId.
+   * @returns {Nullable<DomNodeSubject>} - Parent node subject.
+   */
+  getSubjectFromParentNodeByEventId(childNode, eventId) {
+    let subject;
+    for (const entry of this.cache) {
+      if (ui.isParent(childNode, entry[0]) && entry[1].has(eventId)) {
+        subject = entry[1].get(eventId);
+        break;
+      }
+    }
+    return subject;
+  }
+  /**
+   * The function `setSubject` creates a new `DomNodeSubject` and associates it with a given `node` and `eventId`, and then returns the created subject.
+   *
+   * @param {HTMLElement} node - The `node` parameter is an HTMLElement object representing an HTML element in the DOM (Document Object Model).
+   * @param {VegaEventIDInterface} eventId - The `eventId` parameter is of type `VegaEventIDInterface`. It represents the ID of a Vega event.
+   * @returns {DomNodeSubject} dom node subject object
+   */
+  setSubject(node, eventId) {
+    const subjectTitle = `${node.tagName}:${eventId.getName()}`;
+    const subject = new DomNodeSubject(subjectTitle, node);
+    if (!this.cache.get(node)) {
+      this.cache.set(node, new Map());
+    }
+    this.cache.get(node).set(eventId, subject);
+    return subject;
+  }
+}
+const domNodeSubjectFactory = new DomNodeSubjectFactory();
+
+/**
+ * The function `domAcceptableHandle` always returns `true`.
+ *
+ * @returns {boolean} true
+ */
+const domAcceptableHandle = () => {
+  return true;
+};
+/** The `DomNodeSubjectObserverFactory` class provides methods to add and remove observers to HTML element nodes. */
+class DomNodeSubjectObserverFactory {
+  /**
+   * add observer to a given HTML element node
+   *
+   * @param {HTMLElement} node the node ref
+   * @param {VegaEventIDInterface} eventId The `eventId` parameter is of type `VegaEventIDInterface`. It represents the ID of a Vega event.
+   * @param {(input?: unknown) => void} callback the callback handle
+   * @param {(input?: unknown) => boolean} acceptableHandle the acceptable handle
+   */
+  static addUniqueObserverToNode(node, eventId, callback, acceptableHandle) {
+    if (node) {
+      const domNodesObserver = new observer.Observer(typeof acceptableHandle === 'function' ? acceptableHandle.bind(null) : domAcceptableHandle, callback);
+      DomNodeSubjectObserverFactory.removeUniqueObserverFromNode(node, eventId);
+      changeManager.ChangeManager.register(domNodeSubjectFactory.getSubject(node, eventId), domNodesObserver);
+    }
+  }
+  /**
+   * The function removes observers from a given HTML element node.
+   *
+   * @param {HTMLElement} node - The `node` parameter is an `HTMLElement` object representing an HTML element in the DOM (Document Object Model).
+   * @param {VegaEventIDInterface} eventId The `eventId` parameter is of type `VegaEventIDInterface`. It represents the ID of a Vega event.
+   */
+  static removeUniqueObserverFromNode(node, eventId) {
+    if (domNodeSubjectFactory.isExist(node, eventId)) {
+      changeManager.ChangeManager.clearObserversBySubject(domNodeSubjectFactory.getSubject(node, eventId));
+    }
+  }
+}
+
+exports.DomNodeSubjectObserverFactory = DomNodeSubjectObserverFactory;
+exports.domNodeSubjectFactory = domNodeSubjectFactory;

package/dist/cjs/{dto-renderer-manager-2fc24151.js → dto-renderer-manager-809c947b.js}

@@ -1,13 +1,13 @@
 'use strict';
 
-const codeBlock = require('./code-block-c1d2e6a8.js');
-const createPublicApiRuntimeMetricsSlimmer = require('./create-public-api-runtime-metrics-slimmer-e2e274e1.js');
-const typeGuard = require('./type-guard-a0f026d8.js');
+const codeBlock = require('./code-block-f1480ec3.js');
+const misc = require('./misc-3d30df91.js');
+const typeGuard = require('./type-guard-407ba0b8.js');
 const changeManager = require('./change-manager-a297e4d2.js');
-const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-b5e71bf6.js');
+const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-c62823de.js');
 const vegaInternalEventId = require('./vega-internal-event-id-f2465f1b.js');
 const string = require('./string-39438062.js');
-const ui = require('./ui-9e181079.js');
+const ui = require('./ui-234ea151.js');
 const object = require('./object-e2e28e3d.js');
 const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
 
@@ -128,7 +128,7 @@ class RTEListItemBlock extends codeBlock.RTETextBlock {
    * @inheritDoc
    */
   cloneWithNodes(nodes) {
-    const block = new RTEListItemBlock(createPublicApiRuntimeMetricsSlimmer.generateUUID());
+    const block = new RTEListItemBlock(misc.generateUUID());
     block.children = [];
     block.apply(new codeBlock.AppendChildrenAction(nodes));
     return block;
@@ -149,7 +149,7 @@ class RTEListItemBlock extends codeBlock.RTETextBlock {
    * @returns {RTEListItemBlock} - A list item block.
    */
   createNewListItem() {
-    return new RTEListItemBlock(createPublicApiRuntimeMetricsSlimmer.generateUUID());
+    return new RTEListItemBlock(misc.generateUUID());
   }
   /**
    * @inheritDoc
@@ -258,7 +258,7 @@ class ListTransformToParagraphStrategy extends codeBlock.ActionHandleStrategy {
    * @returns {RTETextBlock} Returns a `RTETextBlock`.
    */
   toParagraph(block) {
-    const textBlock = new codeBlock.RTETextBlock(createPublicApiRuntimeMetricsSlimmer.generateUUID(), 'paragraph');
+    const textBlock = new codeBlock.RTETextBlock(misc.generateUUID(), 'paragraph');
     textBlock.apply(new codeBlock.AppendChildrenAction(block['children']));
     textBlock['annotationMap'] = block['annotationMap'];
     return textBlock;
@@ -455,7 +455,7 @@ class BlockTransformToCodeBlockStrategy extends codeBlock.ActionHandleStrategy {
    */
   handleAction(action, target) {
     const selectedBlocks = action.selectedBlocks;
-    const codeBlock$1 = new codeBlock.RTECodeBlock(createPublicApiRuntimeMetricsSlimmer.generateUUID(), this.getCodeContent(selectedBlocks), 'plainText');
+    const codeBlock$1 = new codeBlock.RTECodeBlock(misc.generateUUID(), this.getCodeContent(selectedBlocks), 'plainText');
     target.apply(new codeBlock.InsertChildrenBeforeAction(selectedBlocks[0], codeBlock$1));
     action.newCodeBlock = codeBlock$1;
     this.removeSelectBlocks(selectedBlocks, target);
@@ -1028,14 +1028,14 @@ class ImageInsertLineBreakWithBlocksStrategy extends codeBlock.ActionHandleStrat
    */
   lineBreakMultipleBlocks(selectedBlocks, target) {
     const newParagraph = codeBlock.RTETextBlock.from({
-      id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+      id: misc.generateUUID(),
       type: 'paragraph',
-      nodes: [{ id: createPublicApiRuntimeMetricsSlimmer.generateUUID(), type: 'text', text: '\n' }],
+      nodes: [{ id: misc.generateUUID(), type: 'text', text: '\n' }],
     });
     target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, newParagraph));
     const afterNodes = this.concatBlocksNodes(selectedBlocks.slice(1));
     if (afterNodes.length === 0 || (afterNodes[0] && afterNodes[0].text === '')) {
-      afterNodes.push(new codeBlock.RTETextNode(createPublicApiRuntimeMetricsSlimmer.generateUUID(), '\n', newParagraph));
+      afterNodes.push(new codeBlock.RTETextNode(misc.generateUUID(), '\n', newParagraph));
     }
     newParagraph.apply(new codeBlock.AppendChildrenAction(afterNodes));
     return newParagraph['children'][0];
@@ -1145,7 +1145,7 @@ class RTEImageBlock extends codeBlock.RTEBlock {
    * @returns {RTEImageBlock} - The empty image block.
    */
   createNewImageBlock() {
-    return new RTEImageBlock(createPublicApiRuntimeMetricsSlimmer.generateUUID());
+    return new RTEImageBlock(misc.generateUUID());
   }
   /**
    * @inheritDoc
@@ -1222,6 +1222,12 @@ class RTEHtmlBlock extends codeBlock.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(''),
@@ -1235,6 +1241,16 @@ class RTEHtmlBlock extends codeBlock.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']);
 
 /**
  * Merge the two blocks node into first block if the two blocks nodes type is same(text node or image node)
@@ -1626,7 +1642,7 @@ class ListItemInsertNewParagraphStrategy extends codeBlock.ActionHandleStrategy
       const parentParent = target.parent.parent;
       if (parentParent['type'] !== 'list-item') {
         const newParagraph = codeBlock.RTETextBlock.from({
-          id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+          id: misc.generateUUID(),
           type: 'paragraph',
           nodes: [],
         });
@@ -2181,7 +2197,7 @@ class LinkAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
   generateLinkAnnotations(element) {
     const annotations = {
       href: element.getAttribute('href') || '',
-      groupKey: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+      groupKey: misc.generateUUID(),
     };
     this.handlers.forEach((handler) => {
       Object.assign(annotations, handler.handle(element));
@@ -2692,7 +2708,7 @@ class HtmlBlockStrategy extends BlockToRTEBlockStrategyAbstract {
    */
   generateHtmlBlock(element, options) {
     return {
-      id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+      id: misc.generateUUID(),
       type: 'html-block',
       htmlTag: element.nodeName.toLowerCase(),
       annotations: htmlElementToAnnotationGenerator.generate(RTEHtmlBlock, element, options),
@@ -2761,7 +2777,7 @@ class UlToRTEListBlockStrategy extends BlockToRTEBlockStrategyAbstract {
     if (elementsArray[0].childNodes.length === 0)
       return null;
     return RTEListBlock.from({
-      id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+      id: misc.generateUUID(),
       type: 'bullet-list',
       blocks: [],
       annotations: htmlElementToAnnotationGenerator.generate(RTEListBlock, elementsArray[0], options),
@@ -2810,7 +2826,7 @@ class OlToRTEListBlockStrategy extends BlockToRTEBlockStrategyAbstract {
     if (elementsArray[0].childNodes.length === 0)
       return null;
     return RTEListBlock.from({
-      id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+      id: misc.generateUUID(),
       type: 'number-list',
       blocks: [],
       annotations: htmlElementToAnnotationGenerator.generate(RTEListBlock, elementsArray[0], options),
@@ -2865,7 +2881,7 @@ class ULNotLiChildToRTEListItemBlockStrategy extends BlockToRTEBlockStrategyAbst
   handle(elementsArray, options) {
     const nodes = this.generateChildNodes(elementsArray, {}, options);
     return RTEListItemBlock.from({
-      id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+      id: misc.generateUUID(),
       type: 'list-item',
       nodes: nodes,
       annotations: {},
@@ -2954,7 +2970,7 @@ class LiToRTEListItemBlockStrategy extends BlockToRTEBlockStrategyAbstract {
    */
   generateWithListBlock(elements, options) {
     return RTEListBlock.from({
-      id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+      id: misc.generateUUID(),
       type: 'bullet-list',
       blocks: elements.map((item) => {
         return this.generateListItemBlockDTO(item, options);
@@ -2970,7 +2986,7 @@ class LiToRTEListItemBlockStrategy extends BlockToRTEBlockStrategyAbstract {
    */
   generateListItemBlockDTO(element, options) {
     return {
-      id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+      id: misc.generateUUID(),
       type: 'list-item',
       annotations: htmlElementToAnnotationGenerator.generate(RTEListItemBlock, element, options),
       nodes: this.generateChildNodes(Array.from(element.childNodes.length ? element.childNodes : [element]).filter((item) => {
@@ -3009,7 +3025,7 @@ class JiraCodeToRTECodeBlockStrategy extends BlockToRTEBlockStrategyAbstract {
       const language = codeRef.dataset
         .language;
       return codeBlock.RTECodeBlock.from({
-        id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+        id: misc.generateUUID(),
         type: 'code-block',
         content,
         language,
@@ -3137,7 +3153,7 @@ class InlineBlockToRTETextBlockStrategy extends BlockToRTEBlockStrategyAbstract
     if (nodes.length === 0)
       return null;
     return codeBlock.RTETextBlock.from({
-      id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+      id: misc.generateUUID(),
       type: super.matchTextBlockType(elementsArray[0]),
       nodes: nodes,
       annotations: htmlElementToAnnotationGenerator.generate(codeBlock.RTETextBlock, elementsArray[0], options),
@@ -3173,11 +3189,11 @@ class ElementToRTEImageBlockStrategyAbstract extends BlockToRTEBlockStrategyAbst
     const isInternalWrapper = !(options && options.autoMatchFormat) &&
       !!(element.parentNode && element.parentNode.nodeName !== 'DIV');
     return RTEImageBlock.from({
-      id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+      id: misc.generateUUID(),
       type: 'image',
       nodes: [
         {
-          id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+          id: misc.generateUUID(),
           type: 'image',
           url: element.src,
           annotations: htmlElementToAnnotationGenerator.generate(RTEImageNode, element, options),
@@ -3251,11 +3267,11 @@ class VegaImageToRTEImageBlockStrategy extends ElementToRTEImageBlockStrategyAbs
     const image = element.querySelector('img');
     if (typeGuard.isNonNullable(image)) {
       return RTEImageBlock.from({
-        id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+        id: misc.generateUUID(),
         type: 'image',
         nodes: [
           {
-            id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+            id: misc.generateUUID(),
             type: 'image',
             url: image.src,
             annotations: htmlElementToAnnotationGenerator.generate(RTEImageNode, element, options),
@@ -3366,7 +3382,7 @@ class ContinueInlineToRTETextBlockStrategy extends BlockToRTEBlockStrategyAbstra
       ? super.matchTextBlockType(parent)
       : this.matchTextBlockTypeByTagName(parent);
     const internalWrapper = !autoMatchFormat && !blockType;
-    return codeBlock.RTETextBlock.from(Object.assign({ id: createPublicApiRuntimeMetricsSlimmer.generateUUID(), type: blockType || 'paragraph', nodes: nodes }, (internalWrapper
+    return codeBlock.RTETextBlock.from(Object.assign({ id: misc.generateUUID(), type: blockType || 'paragraph', nodes: nodes }, (internalWrapper
       ? { annotations: { internalWrapper: internalWrapper } }
       : {
         annotations: htmlElementToAnnotationGenerator.generate(codeBlock.RTETextBlock, parent, options),
@@ -3433,7 +3449,7 @@ class ElementToTextNodeStrategy extends ElementToDTOStrategy {
    */
   generateTextNode(text, annotations) {
     return {
-      id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+      id: misc.generateUUID(),
       type: 'text',
       text: text,
       annotations: annotations,
@@ -3631,6 +3647,185 @@ class StylePreservationContext {
   }
 }
 
+/**
+ * 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)
+ */
+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;
+  }
+}
+
+/**
+ * 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`
+ */
+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');
+  }
+}
+
+/**
+ * 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>`
+ */
+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');
+  }
+}
+
+/**
+ * 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
+ */
+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;
+  }
+}
+
 /**
  * Class representing the content state of the rich text editor.
  */
@@ -3669,14 +3864,14 @@ class VegaRTEContent {
   static createEmptyContent(options = { autoMatchFormat: true }) {
     return VegaRTEContent.fromJSON([
       {
-        id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+        id: misc.generateUUID(),
         type: 'paragraph',
         annotations: {
           internalWrapper: !options.autoMatchFormat,
         },
         nodes: [
           {
-            id: createPublicApiRuntimeMetricsSlimmer.generateUUID(),
+            id: misc.generateUUID(),
             annotations: { plainText: !options.autoMatchFormat },
             type: 'text',
             text: '',
@@ -3693,28 +3888,8 @@ 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;
@@ -3804,7 +3979,7 @@ class VegaRTEContent {
    */
   toListItem(block) {
     block.children.map((node) => node.apply(new codeBlock.SyncUpSelectionAction()));
-    const listItemBlock = new RTEListItemBlock(createPublicApiRuntimeMetricsSlimmer.generateUUID());
+    const listItemBlock = new RTEListItemBlock(misc.generateUUID());
     listItemBlock.apply(new codeBlock.AppendChildrenAction(block['children']));
     listItemBlock['annotationMap'] = block['annotationMap'];
     return listItemBlock;
@@ -3816,7 +3991,7 @@ class VegaRTEContent {
    * @returns {RTEListBlock} list block dto.
    */
   createList(type) {
-    return new RTEListBlock(createPublicApiRuntimeMetricsSlimmer.generateUUID(), type);
+    return new RTEListBlock(misc.generateUUID(), type);
   }
   /**
    * Finds a node by its ID in the content.