@globalpayments/vega 2.58.0 → 2.59.1

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/block-to-rte-block-strategy.abstract.js

@@ -1,9 +1,15 @@
-import { generateUUID } from '../../../../../../utils/misc';
-import { rgbToHex } from '../../../../../../utils/ui';
-import { RTE_TEXT_COLORS } from '../../../../constants/constant';
+import { RTETextNode } from '../../../../dto/nodes/text-node';
+import htmlElementToAnnotationGenerator from './annotation-handler/html-element-to-annotation-generator';
 import { ElementToDTOStrategy } from './element-to-dto-strategy.abstract';
+import { TextStyleAnnotationHandler } from './annotation-handler/text-style-annotation-handler';
+import ElementToDTOClassStrategyManager from '../../../../../../helpers/rte-manager/element-dto-class-strategy-manager';
+import { isHTMLElement } from '../../../../../../utils/ui';
 /** Abstract class for block html element to RTE block dto */
 export class BlockToRTEBlockStrategyAbstract extends ElementToDTOStrategy {
+  constructor() {
+    super(...arguments);
+    this.annotationHandler = new TextStyleAnnotationHandler();
+  }
   /**
    * Generate child nodes of block element, this will inherit all annotations from parent to text node and
    *   flat the child nodes.
@@ -11,258 +17,58 @@ export class BlockToRTEBlockStrategyAbstract extends ElementToDTOStrategy {
    * Example:
    *   <li>
    *     <u><i>text1</i></u>
+   *     <span></span>
    *     <span style='font-weight: bold;'><span>text2</span></span>
    *     text3
    *   </li>
    * will tranform to:
    *   <li>
    *     <span>text1</span> // with underline and italic annotations
+   *     <span></span>      // empty span
    *     <span>text2</span> // with bold annotations
    *     <span>text3</span> // no annotations
    *   </li>
    *
    * @param {HTMLElement[]} elements - Child elements.
-   * @param {VegaRTETextAnnotations | VegaRTECodeAnnotations} annotations - Parent annotations.
+   * @param {VegaRTETextAnnotations} annotations - Parent annotations.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {VegaRTETextNode[]} - Text node DTO.
    */
-  generateChildNodes(elements, annotations = {}) {
+  generateChildNodes(elements, annotations, options) {
     const childNodes = [];
+    const disableAutoMatchFormat = !!(options && options.autoMatchFormat === false);
+    const parentAnnotations = Object.assign({}, annotations);
     elements.forEach((child) => {
-      if (child.nodeType === Node.TEXT_NODE) {
-        if (this.isInvalidTextNode(child))
-          return;
-        childNodes.push({
-          id: generateUUID(),
-          type: 'text',
-          text: String(child.textContent),
-          annotations: annotations,
-        });
+      const strategy = ElementToDTOClassStrategyManager.getElementToNodeStrategies().find((item) => item.canHandle([child], 0, options) > 0);
+      let textNodeJson = null;
+      if (strategy) {
+        textNodeJson = strategy.handle([child], options, parentAnnotations);
+      }
+      if (textNodeJson) {
+        childNodes.push(textNodeJson);
       }
-      else {
-        childNodes.push(...this.generateChildNodes(Array.from(child.childNodes), Object.assign({}, annotations, this.generateTextNodeAnnotations(child, annotations))));
+      else if (isHTMLElement(child) && child.childNodes.length > 0) {
+        const curAnnotations = htmlElementToAnnotationGenerator.generate(RTETextNode, child, Object.assign({ parentAnnotations: disableAutoMatchFormat
+            ? {
+              inlineHtml: parentAnnotations.inlineHtml,
+              link: parentAnnotations.link,
+              code: parentAnnotations.code,
+            }
+            : annotations }, options));
+        childNodes.push(...this.generateChildNodes(Array.from(child.childNodes), curAnnotations, options));
       }
     });
     return childNodes;
   }
   /**
-   * Generate annotations map for block element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {VegaRTEBlockAnnotations} - Text block annotations.
-   */
-  generateBlockAnnotations(element) {
-    const annotations = {};
-    const textAlign = this.getTextAlign(element);
-    const indent = this.getIndent(element);
-    if (textAlign)
-      annotations.textAlign = textAlign;
-    if (indent)
-      annotations.indent = indent;
-    return annotations;
-  }
-  /**
-   * Generate annotations map for text node element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @param {VegaRTETextAnnotations | VegaRTECodeAnnotations} parentAnnotations - parent annotations
-   * @returns {VegaRTETextAnnotations | VegaRTECodeAnnotations} - Text node annotations.
-   */
-  generateTextNodeAnnotations(element, parentAnnotations = {}) {
-    if (this.isCode(element))
-      return { code: true };
-    const annotations = {
-      bold: this.isBold(element),
-      italic: this.isItalic(element),
-      underline: this.isUnderline(element),
-      strikethrough: this.isStrikethrough(element),
-    };
-    parentAnnotations.bold && (annotations.bold = true);
-    parentAnnotations.underline && (annotations.underline = true);
-    parentAnnotations.italic && (annotations.italic = true);
-    parentAnnotations.strikethrough && (annotations.strikethrough = true);
-    const color = this.getColor(element);
-    const link = this.getLink(element);
-    if (color)
-      annotations.textColor = color;
-    if (link)
-      annotations.link = link;
-    return annotations;
-  }
-  /**
-   * Check is a invalid text node.
-   *
-   * @param {HTMLElement} element - Current node element.
-   * @returns {boolean} - boolean.
-   */
-  isInvalidTextNode(element) {
-    if (element.nodeValue && element.nodeValue.includes('\t')) {
-      const value = element.nodeValue.replace(/\n|\t/gm, '');
-      if (value.length === 0)
-        return true;
-    }
-    return false;
-  }
-  /**
-   * Is code element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
-   */
-  isCode(element) {
-    return (element.classList.contains('v-rte--code') ||
-      element.nodeName === 'CODE' ||
-      element.style.fontFamily === 'monospace');
-  }
-  /**
-   * Is bold element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
-   */
-  isBold(element) {
-    return (element.nodeName === 'STRONG' ||
-      element.nodeName === 'B' ||
-      element.style.fontWeight === 'bold' ||
-      element.style.fontWeight === '700');
-  }
-  /**
-   * Is italic element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
-   */
-  isItalic(element) {
-    return element.nodeName === 'I' || element.style.fontStyle === 'italic' || element.nodeName === 'EM';
-  }
-  /**
-   * Is underline element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
-   */
-  isUnderline(element) {
-    return (element.style.textDecoration.includes('underline') ||
-      element.nodeName === 'U' ||
-      element.nodeName === 'INS' ||
-      element.classList.contains('v-rte--underline'));
-  }
-  /**
-   * Is strikethrough element.
+   * Get the node type of element. The element type is determined in the following
+   * order: "data-type" attribute, node name, font size and class name.
    *
-   * @param {HTMLElement} element - current element.
-   * @returns {boolean} - boolean.
+   * @param {HTMLElement} element - element.
+   * @returns {VegaRTETextBlockType} - Block type.
    */
-  isStrikethrough(element) {
-    return (element.style.textDecoration.includes('line-through') ||
-      element.nodeName === 'S' ||
-      element.nodeName === 'DEL' ||
-      element.classList.contains('v-rte--strikethrough'));
-  }
-  /**
-   * Get current color of element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {Nullable<string>} - color.
-   */
-  getColor(element) {
+  matchTextBlockType(element) {
     var _a;
-    const color = element.style.color;
-    const hexColor = (_a = rgbToHex(color)) === null || _a === void 0 ? void 0 : _a.toUpperCase();
-    if (hexColor) {
-      const colorSchema = RTE_TEXT_COLORS.find((schema) => schema.light === hexColor || schema.dark === hexColor);
-      if (colorSchema)
-        return colorSchema.key;
-      return null;
-    }
-    else {
-      for (const color of RTE_TEXT_COLORS) {
-        if (element.style.color.includes(color.key)) {
-          return color.key;
-        }
-      }
-      return null;
-    }
-  }
-  /**
-   * Get current link of element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {Nullable<VegaRTELink>} - link.
-   */
-  getLink(element) {
-    if (element.nodeName === 'A') {
-      return {
-        href: element.href,
-        groupKey: generateUUID(),
-      };
-    }
-    return null;
-  }
-  /**
-   * Get text align of current element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {Nullable<VegaRTEBlockAlignment>} - Text align.
-   */
-  getTextAlign(element) {
-    const classList = element.classList;
-    if (classList.contains(`v-rte--horizontal-alignment-left`)) {
-      return 'left';
-    }
-    else if (classList.contains(`v-rte--horizontal-alignment-center`)) {
-      return 'center';
-    }
-    else if (classList.contains(`v-rte--horizontal-alignment-right`)) {
-      return 'right';
-    }
-    else if (classList.contains(`v-rte--horizontal-alignment-justify`)) {
-      return 'justify';
-    }
-    const style = element.style;
-    switch (style.textAlign) {
-      case 'center':
-        return 'center';
-      case 'right':
-        return 'right';
-      case 'justify':
-        return 'justify';
-      case 'left':
-        return 'left';
-      default:
-        return null;
-    }
-  }
-  /**
-   * Get indent of current element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {Nullable<number>} - Indent.
-   */
-  getIndent(element) {
-    const style = element.style;
-    let marginLeft;
-    if (style.marginLeft) {
-      marginLeft = style.marginLeft;
-    }
-    else if (style.margin) {
-      const margins = style.margin.split(' ');
-      switch (margins.length) {
-        case 4:
-          marginLeft = margins[3];
-          break;
-        case 2:
-        case 3:
-          marginLeft = margins[1];
-          break;
-        default:
-          marginLeft = margins[0];
-          break;
-      }
-    }
-    else {
-      return null;
-    }
-    const marginLeftNumber = Number(marginLeft.replace('px', ''));
-    return marginLeftNumber && marginLeftNumber >= 0 ? Math.floor(marginLeftNumber / 16) : null;
+    return (_a = this.annotationHandler.handle(element).textStyle) !== null && _a !== void 0 ? _a : 'paragraph';
   }
 }

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/continue-inline-to-rte-text-block-strategy.js

@@ -1,6 +1,9 @@
 import { generateUUID } from '../../../../../../utils/misc';
 import { RTETextBlock } from '../../../../dto/blocks/text-block';
+import { RTETextNode } from '../../../../dto/nodes/text-node';
+import htmlElementToAnnotationGenerator from './annotation-handler/html-element-to-annotation-generator';
 import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
+import { InlineHtmlAnnotationHandler } from './annotation-handler/inline-html-annotation-handler';
 /** Transform continue inline block elements to text block DTO */
 export class ContinueInlineToRTETextBlockStrategy extends BlockToRTEBlockStrategyAbstract {
   /**
@@ -29,19 +32,24 @@ export class ContinueInlineToRTETextBlockStrategy extends BlockToRTEBlockStrateg
    * Parse to a text block.
    *
    * @param {HTMLElement[]} elementsArray - Current elements.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {Nullable<RTEContentBlock>} - Text block.
    */
-  handle(elementsArray) {
+  handle(elementsArray, options) {
     const parent = elementsArray[0].parentElement;
-    const nodes = this.generateChildNodes(elementsArray, this.generateTextNodeAnnotations(parent));
-    if (nodes.length === 0)
-      return null;
-    return RTETextBlock.from({
-      id: generateUUID(),
-      type: 'paragraph',
-      nodes: nodes,
-      annotations: this.generateBlockAnnotations(parent),
-    });
+    const autoMatchFormat = options && options.autoMatchFormat;
+    const nodes = this.generateChildNodes(elementsArray, autoMatchFormat
+      ? htmlElementToAnnotationGenerator.generate(RTETextNode, parent, Object.assign(Object.assign({}, options), { skipCustomAnnotations: true }))
+      : {}, options);
+    const blockType = autoMatchFormat
+      ? super.matchTextBlockType(parent)
+      : this.matchTextBlockTypeByTagName(parent);
+    const internalWrapper = !autoMatchFormat && !blockType;
+    return RTETextBlock.from(Object.assign({ id: generateUUID(), type: blockType || 'paragraph', nodes: nodes }, (internalWrapper
+      ? { annotations: { internalWrapper: internalWrapper } }
+      : {
+        annotations: htmlElementToAnnotationGenerator.generate(RTETextBlock, parent, options),
+      })), options);
   }
   /* istanbul ignore next */
   /**
@@ -57,18 +65,25 @@ export class ContinueInlineToRTETextBlockStrategy extends BlockToRTEBlockStrateg
   shouldProceedToElementChildren() {
     return false;
   }
+  /**
+   * Match the block type by tag name.
+   *
+   * @param {HTMLElement} element - Target element.
+   * @returns {Nullable<VegaRTETextBlockType>} - Block type.
+   */
+  matchTextBlockTypeByTagName(element) {
+    switch (element.nodeName) {
+      case 'P':
+        return 'paragraph';
+      default:
+        return null;
+    }
+  }
 }
 ContinueInlineToRTETextBlockStrategy.canHandleTags = [
-  'SPAN',
-  'STRONG',
+  ...InlineHtmlAnnotationHandler.canHandleTags,
   'CODE',
-  'I',
-  'EM',
-  'S',
-  'U',
   'A',
   'VEGA-RICH-TEXT-LINK-EDITOR',
-  'B',
-  'INS',
-  'DEL',
+  'BR',
 ];

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy-processor.js

@@ -1,51 +1,28 @@
 import { ElementToDTOStrategyOutput } from './element-to-dto-strategy.abstract';
-import { ContinueInlineToRTETextBlockStrategy } from './continue-inline-to-rte-text-block-strategy';
-import { UlToRTEListBlockStrategy } from './ul-to-rte-list-block-strategy';
-import { LiToRTEListItemBlockStrategy } from './li-to-rte-list-item-block-strategy';
-import { InlineBlockToRTETextBlockStrategy } from './inline-block-to-rte-text-block-strategy';
-import { ImgToRTEImageBlockStrategy } from './img-to-rte-image-block-strategy';
-import { VegaImageToRTEImageBlockStrategy } from './vega-image-to-rte-image-block-strategy';
-import { OlToRTEListBlockStrategy } from './ol-to-rte-list-block-strategy';
-import { SpanImageToRTEImageBlockStrategy } from './span-img-to-rte-image-block-strategy';
-import { ULNotLiChildToRTEListItemBlockStrategy } from './ul-not-li-child-to-rte-list-item-block';
-import { VegaCodeBlockToRTECodeBlockStrategy } from './vega-code-block-to-rte-code-block-strategy';
-import { JiraCodeToRTECodeBlockStrategy } from './jira-code-to-rte-code-block-strategy';
+import ElementToDTOClassStrategyManager from '../../../../../../helpers/rte-manager/element-dto-class-strategy-manager';
 /** Element to DTO processor */
-export class ElementToDtoStrategyProcessor {
-  constructor() {
-    this.elementStrategies = [
-      new UlToRTEListBlockStrategy(),
-      new OlToRTEListBlockStrategy(),
-      new ULNotLiChildToRTEListItemBlockStrategy(),
-      new LiToRTEListItemBlockStrategy(),
-      new VegaCodeBlockToRTECodeBlockStrategy(),
-      new JiraCodeToRTECodeBlockStrategy(),
-      new InlineBlockToRTETextBlockStrategy(),
-      new ImgToRTEImageBlockStrategy(),
-      new VegaImageToRTEImageBlockStrategy(),
-      new SpanImageToRTEImageBlockStrategy(),
-      new ContinueInlineToRTETextBlockStrategy(),
-    ];
-  }
+class ElementToDtoStrategyProcessor {
   /**
    * Transform process.
    *
    * @param {HTMLElement[]} elements - Current elements.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {ElementToDTOStrategyOutput[]} - outputs.
    */
-  process(elements) {
+  process(elements, options = { autoMatchFormat: true, skipCustomAnnotations: true }) {
+    const strategies = this.getElementToBlockStrategies();
     const outputs = [];
     for (let i = 0; i < elements.length; i++) {
       if (this.isInvalidElement(elements[i]))
         continue;
       let canHandledCount = 0;
-      for (const strategy of this.elementStrategies) {
-        canHandledCount = strategy.canHandle(elements, i);
+      for (const strategy of strategies) {
+        canHandledCount = strategy.canHandle(elements, i, options);
         if (canHandledCount > 0) {
           const handledElements = elements.slice(i, i + canHandledCount);
           const output = new ElementToDTOStrategyOutput(strategy, handledElements);
           if (canHandledCount === 1 && strategy.shouldProceedToElementChildren()) {
-            output.setChildrenOutput(this.process(Array.from(handledElements[0].childNodes)));
+            output.setChildrenOutput(this.process(Array.from(handledElements[0].childNodes), options));
           }
           outputs.push(output);
           i += canHandledCount - 1;
@@ -54,7 +31,7 @@ export class ElementToDtoStrategyProcessor {
       }
       if (canHandledCount === 0 && i < elements.length) {
         const elementChildren = Array.from(elements[i].childNodes);
-        const childrenOutputs = this.process(Array.from(elementChildren));
+        const childrenOutputs = this.process(Array.from(elementChildren), options);
         if (childrenOutputs.length > 0) {
           outputs.push(...childrenOutputs);
         }
@@ -71,6 +48,15 @@ export class ElementToDtoStrategyProcessor {
   isInvalidElement(element) {
     if (element.nodeType === Node.COMMENT_NODE)
       return true;
-    return ['META', 'BUTTON', 'STYLE'].includes(element.nodeName);
+    return ['META', 'STYLE'].includes(element.nodeName);
+  }
+  /**
+   * Get the register element to block strategies.
+   *
+   * @returns {ElementToDTOStrategy[]} - The register element to block strategies.
+   */
+  getElementToBlockStrategies() {
+    return ElementToDTOClassStrategyManager.getElementToBlockStrategies();
   }
 }
+export default new ElementToDtoStrategyProcessor();

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract.js

@@ -24,13 +24,14 @@ export class ElementToDTOStrategyOutput {
   /**
    * Transform current output and children output to DTO
    *
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {Nullable<RTEContentBlock>} - DTO.
    */
-  toDto() {
-    const currentBlock = this.currentStrategy.handle(this.currentElements);
+  toDto(options = { autoMatchFormat: true, skipCustomAnnotations: true }) {
+    const currentBlock = this.currentStrategy.handle(this.currentElements, options);
     if (this.childrenOutput.length > 0 && currentBlock) {
       this.currentStrategy.appendChildBlocks(currentBlock, this.childrenOutput
-        .map((childOutput) => childOutput.toDto())
+        .map((childOutput) => childOutput.toDto(options))
         .filter(isNonNullable));
     }
     return currentBlock;

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/element-to-rte-image-block-strategy.abstract.js

@@ -0,0 +1,33 @@
+import { generateUUID } from '../../../../../../utils/misc';
+import { RTEImageBlock } from '../../../../dto/blocks/image-block';
+import { RTEImageNode } from '../../../../dto/nodes/image-node';
+import htmlElementToAnnotationGenerator from './annotation-handler/html-element-to-annotation-generator';
+import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
+/** Abstract class for block html element to RTE block dto */
+export class ElementToRTEImageBlockStrategyAbstract extends BlockToRTEBlockStrategyAbstract {
+  /**
+   * Create a RTE Image block according to the img element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
+   * @returns {RTEImageBlock} -RTE Image block.
+   */
+  createRTEImageBlock(element, options) {
+    // RTEImageBlock is also wrapped by a div, should not as internal wrapper if the parent is a div.
+    const isInternalWrapper = !(options && options.autoMatchFormat) &&
+      !!(element.parentNode && element.parentNode.nodeName !== 'DIV');
+    return RTEImageBlock.from({
+      id: generateUUID(),
+      type: 'image',
+      nodes: [
+        {
+          id: generateUUID(),
+          type: 'image',
+          url: element.src,
+          annotations: htmlElementToAnnotationGenerator.generate(RTEImageNode, element, options),
+        },
+      ],
+      annotations: Object.assign(Object.assign({}, htmlElementToAnnotationGenerator.generate(RTEImageBlock, element.parentElement, options)), { internalWrapper: isInternalWrapper }),
+    }, options);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/element-to-text-node-strategy.js

@@ -0,0 +1,33 @@
+import { generateUUID } from '../../../../../../utils/misc';
+import { ElementToDTOStrategy } from './element-to-dto-strategy.abstract';
+/**
+ * Class to handle text node elements and convert them to text node DTOs
+ */
+export class ElementToTextNodeStrategy extends ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren() {
+    return false;
+  }
+  /**
+   * @inheritDoc
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  appendChildBlocks() { }
+  /**
+   * Generate text node DTO object
+   *
+   * @param {string} text - text content.
+   * @param {VegaRTETextAnnotations} annotations - Current annotations.
+   * @returns {VegaRTETextNode} - Text node DTO.
+   */
+  generateTextNode(text, annotations) {
+    return {
+      id: generateUUID(),
+      type: 'text',
+      text: text,
+      annotations: annotations,
+    };
+  }
+}

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/html-block-strategy.js

@@ -0,0 +1,99 @@
+import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
+import { RTEHtmlBlock } from '../../../../dto/blocks/html-block';
+import { generateUUID } from '../../../../../../utils/misc';
+import htmlElementToAnnotationGenerator from './annotation-handler/html-element-to-annotation-generator';
+/**
+ * Converting HTML block elements into RTE blocks.
+ */
+export class HtmlBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray, currentIndex, options) {
+    const element = elementsArray[currentIndex];
+    // - div + img should be handled by RTEImageBlock
+    const isCustomContainer = element.nodeName === 'DIV'
+      ? element.childNodes.length > 0 && element.childNodes[0].nodeName !== 'IMG'
+      : true;
+    return !options.autoMatchFormat &&
+      isCustomContainer &&
+      HtmlBlockStrategy.canHandleTags.includes(elementsArray[currentIndex].nodeName)
+      ? 1
+      : 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray, options) {
+    const element = elementsArray[0];
+    return RTEHtmlBlock.from(this.generateHtmlBlock(element, options), options);
+  }
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock, childBlocks) {
+    currentBlock.children = childBlocks.map((block) => {
+      block.parent = currentBlock;
+      return block;
+    });
+  }
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren() {
+    return true;
+  }
+  /**
+   * Generate HTML block DTO from an HTML element.
+   *
+   * @param {HTMLElement} element - HTML element to convert.
+   * @param {VegaRTETransformOptions} options - Options for transformation.
+   * @returns {VegaRTEHtmlBlock} - HTML block DTO.
+   */
+  generateHtmlBlock(element, options) {
+    return {
+      id: generateUUID(),
+      type: 'html-block',
+      htmlTag: element.nodeName.toLowerCase(),
+      annotations: htmlElementToAnnotationGenerator.generate(RTEHtmlBlock, element, options),
+      children: [],
+    };
+  }
+}
+HtmlBlockStrategy.canHandleTags = [
+  'ADDRESS',
+  'ARTICLE',
+  'ASIDE',
+  'BLOCKQUOTE',
+  'BUTTON',
+  'CAPTION',
+  'COL',
+  'COLGROUP',
+  'DIV',
+  'DD',
+  'DETAILS',
+  'DL',
+  'DT',
+  'FIELDSET',
+  'FIGCAPTION',
+  'FIGURE',
+  'FOOTER',
+  'FORM',
+  'HEADER',
+  'HR',
+  'HX',
+  'INPUT',
+  'LEGEND',
+  'MAIN',
+  'NAV',
+  'PRE',
+  'SECTION',
+  'SUMMARY',
+  'TABLE',
+  'TBODY',
+  'TD',
+  'TFOOT',
+  'TH',
+  'THEAD',
+  'TR',
+];