@globalpayments/vega 2.98.0 → 2.99.0

package/dist/collection/components/vega-rich-text-editor/extensions/functions/element-to-dto-strategies/div-to-function-block-strategy.js

@@ -1,6 +1,8 @@
 import { generateUUID } from '../../../../../utils/misc';
 import { ElementToDTOStrategy } from '../../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
 import { RTEFunctionBlock } from '../dto/function-block';
+import { FUNCTION_BLOCK_CLASS, FUNCTION_SYNTAX_CLASS } from '../constants';
+import { isFunctionBoundaryContainer } from '../utils';
 /**
  * Strategy to convert a div with class 'statement' into an function block.
  */
@@ -10,11 +12,13 @@ export class DivToFunctionBlockStrategy extends ElementToDTOStrategy {
    */
   canHandle(elementsArray, currentIndex) {
     const element = elementsArray[currentIndex];
-    return element &&
-      element.tagName === 'DIV' &&
-      element.classList.contains('statement') &&
+    if (element.nodeType !== Node.ELEMENT_NODE)
+      return 0;
+    const isFunctionBoundary = isFunctionBoundaryContainer(element);
+    return element.tagName === 'DIV' &&
+      isFunctionBoundary &&
       element.childNodes.length &&
-      element.querySelector('.statementsyntax')
+      element.querySelector(`.${FUNCTION_SYNTAX_CLASS}`)
       ? 1
       : 0;
   }
@@ -26,7 +30,7 @@ export class DivToFunctionBlockStrategy extends ElementToDTOStrategy {
       id: generateUUID(),
       type: 'function-block',
       annotations: {
-        customClass: ['statement'],
+        customClass: [FUNCTION_BLOCK_CLASS],
       },
       children: [],
     });

package/dist/collection/components/vega-rich-text-editor/extensions/functions/element-to-dto-strategies/div-to-function-content-strategy.js

@@ -2,13 +2,14 @@ import { generateUUID } from '../../../../../utils/misc';
 import { RTETextBlock } from '../../../dto/blocks/text-block';
 import htmlElementToAnnotationGenerator from '../../../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator';
 import { DivToLogicControlBlockStrategy } from './div-to-logic-control-block-strategy';
+import { FUNCTION_CONTENT_CLASS } from '../constants';
 /**
  * Strategy to convert a div with class 'statementelement' into an function block.
  */
 export class DivToFunctionContentStrategy extends DivToLogicControlBlockStrategy {
   constructor() {
     super(...arguments);
-    this.blockClassName = 'statementelement';
+    this.blockClassName = FUNCTION_CONTENT_CLASS;
   }
   /**
    * @inheritDoc
@@ -16,12 +17,11 @@ export class DivToFunctionContentStrategy extends DivToLogicControlBlockStrategy
   handle(elementsArray, options) {
     const element = elementsArray[0];
     const annotations = htmlElementToAnnotationGenerator.generate(RTETextBlock, element);
-    const nodes = Array.from(elementsArray[0].childNodes);
     return RTETextBlock.from({
       id: generateUUID(),
       type: 'paragraph',
       annotations: Object.assign({ customClass: [this.blockClassName] }, annotations),
-      nodes: this.generateChildNodes(nodes, undefined, options),
+      nodes: this.generateChildNodes(Array.from(elementsArray[0].childNodes), undefined, options),
     });
   }
 }

package/dist/collection/components/vega-rich-text-editor/extensions/functions/element-to-dto-strategies/div-to-logic-control-block-strategy.js

@@ -1,13 +1,15 @@
 import { generateUUID } from '../../../../../utils/misc';
 import { RTELogicControlBlock } from '../dto/logic-control-block';
 import { BlockToRTEBlockStrategyAbstract } from '../../../slimmers/controllers/helper/element-to-dto-strategy/block-to-rte-block-strategy.abstract';
+import { FUNCTION_SYNTAX_CLASS } from '../constants';
+import { isFunctionBoundaryContainer } from '../utils';
 /**
  * Strategy to convert a div with class 'statementsyntax' into an RTELogicControlBlock DTO.
  */
 export class DivToLogicControlBlockStrategy extends BlockToRTEBlockStrategyAbstract {
   constructor() {
     super(...arguments);
-    this.blockClassName = 'statementsyntax';
+    this.blockClassName = FUNCTION_SYNTAX_CLASS;
   }
   /**
    * @inheritDoc
@@ -50,6 +52,6 @@ export class DivToLogicControlBlockStrategy extends BlockToRTEBlockStrategyAbstr
    * @returns {boolean} True if the element is a child of a function block, false otherwise
    */
   isFunctionBlockChild(element) {
-    return !!(element.parentElement && element.parentElement.classList.contains('statement'));
+    return !!(element.parentElement && isFunctionBoundaryContainer(element.parentElement));
   }
 }

package/dist/collection/components/vega-rich-text-editor/extensions/functions/function-extension.js

@@ -10,6 +10,7 @@ import { RTELogicControlBlockRenderer } from './renderers/logic-control-block-re
 import { DivToLogicControlBlockStrategy } from './element-to-dto-strategies/div-to-logic-control-block-strategy';
 import { DivToFunctionBlockStrategy } from './element-to-dto-strategies/div-to-function-block-strategy';
 import { DivToFunctionContentStrategy } from './element-to-dto-strategies/div-to-function-content-strategy';
+import { FunctionBlockContainerStrategy } from './element-to-dto-strategies/div-containing-function-block-strategy';
 import { RTEFunctionBlock } from './dto/function-block';
 import { RTEFunctionBlockRenderer } from './renderers/function-block-renderer';
 import { ModifyContentActionType } from '../../dto/actions/modify-content-action.abstract';
@@ -18,15 +19,18 @@ import { FunctionBlockInsertParagraphStrategy } from './action-handler-strategie
 import { PreventPasteContentInterceptor } from './action-handler-interceptor/prevent-paste-content-interceptor';
 import { PASTE_PLAIN_TEXT } from './actions/paste-plain-text-action';
 import { PastePlainTextStrategy } from './action-handler-strategies/paste-plain-text-strategy';
+import { isFunctionBlockElement } from './utils';
 const convertLogicControlBlockStrategy = new DivToLogicControlBlockStrategy();
 const convertFunctionContentStrategy = new DivToFunctionContentStrategy();
 const convertFunctionBlockStrategy = new DivToFunctionBlockStrategy();
+const convertFunctionBlockContainerStrategy = new FunctionBlockContainerStrategy();
 /**
  * Function extension class for Vega Rich Text Editor.
  */
 export class VegaRTEFunctionExtension extends VegaRTEExtension {
   constructor() {
     super();
+    this.unregisterBlockBoundaryPredicate = null;
     this.registerBlockBasicStrategies(RTELogicControlBlock.name);
     this.registerBlockBasicStrategies(RTEFunctionBlock.name);
     this.preventFunctionBlockDefaultInsertNewParagraph();
@@ -37,11 +41,25 @@ export class VegaRTEFunctionExtension extends VegaRTEExtension {
     this.registerElementToBlockDTOClassStrategy(convertLogicControlBlockStrategy);
     this.registerElementToBlockDTOClassStrategy(convertFunctionContentStrategy);
     this.registerElementToBlockDTOClassStrategy(convertFunctionBlockStrategy);
+    this.registerElementToBlockDTOClassStrategy(convertFunctionBlockContainerStrategy);
   }
   /** @inheritDoc */
   prepareBeforeLoad(host) {
     this.registerToolbarButtonRenderer(VegaRTEFunctionExtension.TOOLBAR_BUTTON_KEY, new FunctionToolbarButtonRenderer(), host);
   }
+  /** @inheritDoc */
+  initialExtensionAfterLoad(context) {
+    var _a;
+    super.initialExtensionAfterLoad(context);
+    (_a = this.unregisterBlockBoundaryPredicate) === null || _a === void 0 ? void 0 : _a.call(this);
+    this.unregisterBlockBoundaryPredicate = this.registerBlockBoundaryPredicate(isFunctionBlockElement);
+  }
+  /** @inheritDoc */
+  destroyExtension() {
+    var _a;
+    (_a = this.unregisterBlockBoundaryPredicate) === null || _a === void 0 ? void 0 : _a.call(this);
+    this.unregisterBlockBoundaryPredicate = null;
+  }
   /**
    * Remove the appen children strategies to prevent default insert new paragraph logic in function block
    */

package/dist/collection/components/vega-rich-text-editor/extensions/functions/renderers/function-block-renderer.js

@@ -1,4 +1,6 @@
 import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { FUNCTION_BLOCK_CLASS } from '../constants';
+import { RTE_BLOCK_BOUNDARY_ATTRIBUTE } from '../../../constants/constant';
 import styles from './function-block-styles.css';
 /**
  * Renderer for Function Block
@@ -11,6 +13,7 @@ export class RTEFunctionBlockRenderer extends VegaRTEExtensionRenderer {
     return createElement('div', {
       key: renderData.id,
       class: this.getElementClassName(renderData),
+      [RTE_BLOCK_BOUNDARY_ATTRIBUTE]: '',
       ref: this.useRef(renderData),
     });
   }
@@ -30,8 +33,8 @@ export class RTEFunctionBlockRenderer extends VegaRTEExtensionRenderer {
    */
   getElementClassName(block) {
     let classes = block.getClasses();
-    if (classes.indexOf('statement') < 0) {
-      classes = 'statement ' + classes;
+    if (classes.indexOf(FUNCTION_BLOCK_CLASS) < 0) {
+      classes = FUNCTION_BLOCK_CLASS + ' ' + classes;
     }
     return classes.trim();
   }

package/dist/collection/components/vega-rich-text-editor/extensions/functions/renderers/logic-control-block-renderer.js

@@ -1,4 +1,5 @@
 import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { FUNCTION_SYNTAX_CLASS } from '../constants';
 /**
  * Renders a logic control block in the rich text editor.
  */
@@ -9,7 +10,7 @@ export class RTELogicControlBlockRenderer extends VegaRTEExtensionRenderer {
   doRender(h, renderData) {
     return h('div', {
       key: renderData.id,
-      class: 'statementsyntax',
+      class: FUNCTION_SYNTAX_CLASS,
       ref: this.useRef(renderData),
     }, h('span', {
       key: `${renderData.id}-1`,

package/dist/collection/components/vega-rich-text-editor/extensions/functions/utils.js

@@ -0,0 +1,36 @@
+import { RTE_BLOCK_BOUNDARY_ATTRIBUTE } from '../../constants/constant';
+import { FUNCTION_BLOCK_CLASS, FUNCTION_ELEMENT_CLASSES } from './constants';
+/**
+ * Returns true when the element belongs to function extension blocks by semantic
+ * boundary attribute or known function element classes.
+ *
+ * Use this helper for broad detection (e.g., extension-level boundary predicate
+ * registration) where both container and child function elements should be
+ * treated as part of the function block structure.
+ *
+ * @param {HTMLElement} element - Element to inspect.
+ * @returns {boolean} Whether the element belongs to a function block structure.
+ * @example
+ * this.registerBlockBoundaryPredicate(isFunctionBlockElement);
+ */
+export const isFunctionBlockElement = (element) => {
+  return (element.hasAttribute(RTE_BLOCK_BOUNDARY_ATTRIBUTE) ||
+    FUNCTION_ELEMENT_CLASSES.some((functionClass) => element.classList.contains(functionClass)));
+};
+/**
+ * Returns true when the element is a function block boundary container.
+ *
+ * Use this helper when conversion logic must identify only the function block
+ * container element (the DIV that maps to RTEFunctionBlock), not function child
+ * elements such as syntax/content nodes.
+ *
+ * @param {HTMLElement} element - Element to inspect.
+ * @returns {boolean} Whether the element is a function block boundary container.
+ * @example
+ * if (isFunctionBoundaryContainer(element)) {
+ *     // map the DIV to RTEFunctionBlock
+ * }
+ */
+export const isFunctionBoundaryContainer = (element) => {
+  return (element.hasAttribute(RTE_BLOCK_BOUNDARY_ATTRIBUTE) || element.classList.contains(FUNCTION_BLOCK_CLASS));
+};

package/dist/collection/components/vega-rich-text-editor/extensions/languages/language-extension.js

@@ -130,6 +130,7 @@ export class VegaRTELanguageExtension extends VegaRTEExtension {
           options = {
             autoMatchFormat: (_a = host.sourceEditConfig.autoMatchFormat) !== null && _a !== void 0 ? _a : true,
             filterInlineStyles: host.sourceEditConfig.filterInlineStyles,
+            blockBoundaryRegistry: this.extensionContext.blockBoundaryRegistry,
           };
         }
         result = VegaRTEContent.fromHtml(codeBlock.value.code, options);

package/dist/collection/components/vega-rich-text-editor/extensions/paste/action-handler-strategies/image-replace-src-strategy.js

@@ -0,0 +1,21 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { PasteImageParser } from '../parse-local-images-helper/paste-image-parser';
+/**
+ * Strategy to handle the `ImageReplaceSrcAction` for replacing the `src` attribute of an `<img>` element in the RTE content.
+ */
+export class ImageReplaceSrcStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const { img, url } = action;
+    img.setAttribute('src', url);
+    img.removeAttribute(PasteImageParser.PREVIEW_IMG_KEY);
+    target.url = url;
+    if (target.annotationMap && target.annotationMap.has('CUSTOM_ATTRIBUTE')) {
+      const customAttributeAnnotation = target.annotationMap.get('CUSTOM_ATTRIBUTE');
+      customAttributeAnnotation.customAttribute.src = url;
+      delete customAttributeAnnotation.customAttribute[PasteImageParser.PREVIEW_IMG_KEY];
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/paste/actions/image-replace-src-action.js

@@ -0,0 +1,13 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+export const REPLACE_IMAGE_SRC = 'REPLACE_IMAGE_SRC';
+/**
+ * Action to replace the `src` attribute of an `<img>` element in the RTE content.
+ */
+export class ImageReplaceSrcAction extends ModifyContentAction {
+  constructor(imageElement, url) {
+    super();
+    this.type = REPLACE_IMAGE_SRC;
+    this.img = imageElement;
+    this.url = url;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/paste/parse-local-images-helper/paste-image-parser.js

@@ -0,0 +1,295 @@
+import { generateUUID } from '../../../../../utils/misc';
+/**
+ * Extracts pasted image files from clipboard payloads and swaps matching
+ * `<img>` elements to local object-URL previews.
+ *
+ * The parser is stateless: callers own the returned {@link PasteImagePreview}
+ * list and decide how to track pending uploads.
+ */
+export class PasteImageParser {
+  /**
+   * Parses local `file://` images from the HTML, swaps matching `<img>`
+   * elements to object-URL previews, and returns the rewritten HTML alongside
+   * the resolved pending previews.
+   *
+   * When no local images are resolved, the original HTML is returned unchanged
+   * with an empty preview list.
+   *
+   * @param {string} html HTML content to parse.
+   * @param {ClipboardFileContent | null} clipboardFileContent Clipboard payload for image extraction.
+   * @returns {ParseLocalImagesResult} Rewritten HTML and resolved previews.
+   */
+  parseLocalImages(html, clipboardFileContent) {
+    if (!html.includes('<img')) {
+      return { html, previews: [] };
+    }
+    const safeHtml = html.replace(/\s+style=/g, ' data-style=');
+    const parser = new DOMParser();
+    const parsedDoc = parser.parseFromString(safeHtml, 'text/html');
+    const localImageElements = Array.from(parsedDoc.querySelectorAll('img')).filter((img) => img.src.startsWith('file://'));
+    if (localImageElements.length === 0) {
+      return { html, previews: [] };
+    }
+    const imageFiles = this.extractImageFiles(clipboardFileContent, localImageElements);
+    if (imageFiles.length === 0) {
+      return { html, previews: [] };
+    }
+    const previews = this.createImagePreviews(localImageElements, imageFiles);
+    const rewrittenHtml = parsedDoc.body.innerHTML.replace(/ data-style=/g, ' style=');
+    return { html: rewrittenHtml, previews };
+  }
+  /**
+   * Swaps each `<img>` src to a local object-URL preview using the provided
+   * image files (paired by order), returning one preview per resolved image.
+   *
+   * Images that live inside a list are dropped instead of being previewed: the
+   * RTE does not support list images. They are removed here (after holding their
+   * position while the RTF images are paired by order) so the remaining images
+   * stay aligned with their files even when a list image is not the last one.
+   *
+   * @param {HTMLImageElement[]} images Placeholder `<img>` elements in document order.
+   * @param {File[]} files Image files to pair with the elements, in the same order.
+   * @returns {PasteImagePreview[]} Previews for the images that were resolved to a file.
+   */
+  createImagePreviews(images, files) {
+    const previews = [];
+    images.forEach((imageElement, index) => {
+      // List images have no editor representation, so drop them here instead of
+      // creating a preview. Removing them at this stage (rather than earlier)
+      // keeps the remaining images aligned with their files.
+      if (this.isListImage(imageElement)) {
+        imageElement.remove();
+        return;
+      }
+      const file = files[index];
+      if (!file) {
+        return;
+      }
+      const objectUrl = URL.createObjectURL(file);
+      imageElement.setAttribute('src', objectUrl);
+      const imageId = generateUUID();
+      imageElement.setAttribute(PasteImageParser.PREVIEW_IMG_KEY, imageId);
+      previews.push({ id: imageId, file, objectUrl });
+    });
+    return previews;
+  }
+  /**
+   * Extracts image files from clipboard data, preferring Word RTF-decoded
+   * images and falling back to the clipboard file list when RTF yields none.
+   *
+   * @param {ClipboardFileContent | null} clipboardFileContent Clipboard payload from a paste event.
+   * @param {HTMLElement[]} images `<img>` elements the files will be paired with.
+   * @returns {File[]} Image files found on the clipboard.
+   */
+  extractImageFiles(clipboardFileContent, images) {
+    let result = [];
+    if (clipboardFileContent) {
+      if (clipboardFileContent.rtf) {
+        result = this.safeExtractWordImages(clipboardFileContent.rtf, images);
+      }
+      if (result.length === 0 && clipboardFileContent.files) {
+        result = clipboardFileContent.files.filter((file) => file.type.startsWith('image/'));
+      }
+    }
+    return result;
+  }
+  /**
+   * Safely extracts image files from Word RTF clipboard data.
+   *
+   * @param {string} rtf Clipboard payload from a paste event.
+   * @param {HTMLElement[]} images Array of `<img>` elements that may be updated with staged previews.
+   * @returns {File[]} Image files found in the clipboard data.
+   */
+  safeExtractWordImages(rtf, images) {
+    // Word defines a list's picture bullet once in the list table
+    // (`{\*\listpicture ...}`) with no rendered counterpart. Drop that
+    // definition so its blip is not counted as a content image; the per-item
+    // `{\listtext ...}` bullet blips are kept because each still pairs with a
+    // preserved bullet placeholder `<img>`.
+    const contentRtf = this.stripListPictureDefinitions(rtf);
+    const fileObjects = [];
+    const imageRegex = /\\pngblip|\\jpegblip/g;
+    const matches = [...contentRtf.matchAll(imageRegex)];
+    matches.forEach((match, index) => {
+      if (index >= images.length || match.index === undefined) {
+        return;
+      }
+      const mimeType = match[0].includes('png') ? 'image/png' : 'image/jpeg';
+      const startIndex = match.index + match[0].length;
+      const bytes = this.extractImageBytes(contentRtf, startIndex);
+      if (bytes.length === 0) {
+        return;
+      }
+      const extension = mimeType.split('/')[1];
+      const file = new File(
+      // eslint-disable-next-line spellcheck/spell-checker
+      [new Uint8Array(bytes)], `word_img_${Date.now()}_${index}.${extension}`, { type: mimeType });
+      fileObjects.push(file);
+    });
+    return fileObjects;
+  }
+  /**
+   * Removes Word list-table picture-bullet definitions from the RTF so they are
+   * not counted as content images.
+   *
+   * Word declares a list's picture bullet once as a `{\*\listpicture ...}`
+   * destination inside the list table. It renders nothing on its own, so its
+   * blip has no matching content `<img>`; leaving it in shifts the ordinal
+   * pairing and makes the first real image resolve to the bullet. The per-item
+   * `{\listtext ...}` bullets are intentionally left untouched because each is
+   * kept as a placeholder `<img>` that consumes its blip downstream.
+   *
+   * @param {string} rtf Full RTF clipboard payload.
+   * @returns {string} RTF with list-table picture-bullet definitions removed.
+   */
+  stripListPictureDefinitions(rtf) {
+    // eslint-disable-next-line spellcheck/spell-checker
+    return this.removeBalancedGroups(rtf, '{\\*\\listpicture');
+  }
+  /**
+   * Removes every balanced-brace RTF group that starts with the given marker.
+   *
+   * @param {string} rtf RTF payload to scan.
+   * @param {string} marker Opening delimiter of the group to remove (including its `{`).
+   * @returns {string} RTF with the matching groups removed.
+   */
+  removeBalancedGroups(rtf, marker) {
+    let index = rtf.indexOf(marker);
+    while (index !== -1) {
+      const end = this.findGroupEnd(rtf, index);
+      rtf = rtf.slice(0, index) + rtf.slice(end);
+      index = rtf.indexOf(marker, index);
+    }
+    return rtf;
+  }
+  /**
+   * Finds the index just past the brace that closes the group opened at `start`.
+   *
+   * A backslash escapes the next character (such as `\{` or `\}`) so escaped
+   * braces are not counted. When the group is unbalanced the RTF length is
+   * returned so the trailing remainder is dropped.
+   *
+   * @param {string} rtf RTF payload to scan.
+   * @param {number} start Index of the group's opening `{`.
+   * @returns {number} Index immediately after the matching closing `}`.
+   */
+  findGroupEnd(rtf, start) {
+    const length = rtf.length;
+    let depth = 0;
+    let position = start;
+    while (position < length) {
+      const char = rtf[position];
+      if (char === '\\') {
+        position += 2;
+        continue;
+      }
+      if (char === '{') {
+        depth++;
+      }
+      else if (char === '}') {
+        depth--;
+        if (depth === 0) {
+          return position + 1;
+        }
+      }
+      position++;
+    }
+    return length;
+  }
+  /**
+   * Extracts the raw image bytes that follow a Word RTF blip marker.
+   *
+   * Starting just after the blip control word, RTF control words (such as
+   * `\bliptag`) and nested groups (such as `{\*\blipuid ...}`) are skipped so
+   * their hex is not mistaken for image data. Hex digits are decoded into bytes
+   * until the enclosing `{\pict}` group is closed.
+   *
+   * @param {string} rtf Full RTF clipboard payload.
+   * @param {number} startIndex Index immediately after the blip marker.
+   * @returns {number[]} Decoded image byte values.
+   */
+  extractImageBytes(rtf, startIndex) {
+    const length = rtf.length;
+    const bytes = [];
+    let depth = 0;
+    let highNibble = -1;
+    let position = startIndex;
+    while (position < length) {
+      const char = rtf[position];
+      if (char === '{') {
+        depth++;
+        position++;
+        continue;
+      }
+      if (char === '}') {
+        if (depth === 0) {
+          break;
+        }
+        depth--;
+        position++;
+        continue;
+      }
+      if (depth > 0) {
+        position++;
+        continue;
+      }
+      if (char === '\\') {
+        position++;
+        while (position < length && /[a-zA-Z]/.test(rtf[position])) {
+          position++;
+        }
+        if (position < length && rtf[position] === '-') {
+          position++;
+        }
+        while (position < length && /[0-9]/.test(rtf[position])) {
+          position++;
+        }
+        continue;
+      }
+      const nibble = this.hexNibble(char);
+      if (nibble >= 0) {
+        if (highNibble < 0) {
+          highNibble = nibble;
+        }
+        else {
+          bytes.push((highNibble << 4) | nibble);
+          highNibble = -1;
+        }
+      }
+      position++;
+    }
+    return bytes;
+  }
+  /**
+   * Converts a single hex character to its numeric value.
+   *
+   * @param {string} char Candidate hex character.
+   * @returns {number} Value in `[0, 15]`, or `-1` when not a hex digit.
+   */
+  hexNibble(char) {
+    if (char >= '0' && char <= '9') {
+      return char.charCodeAt(0) - 48;
+    }
+    if (char >= 'a' && char <= 'f') {
+      return char.charCodeAt(0) - 87;
+    }
+    if (char >= 'A' && char <= 'F') {
+      return char.charCodeAt(0) - 55;
+    }
+    return -1;
+  }
+  /**
+   * Returns whether an `<img>` element is nested inside list content.
+   *
+   * The Word paste sanitizer strips non-allowlisted attributes but keeps the
+   * `ul`/`ol`/`li` structure, so list membership is detected by DOM ancestry
+   * here rather than by a marker attribute set upstream.
+   *
+   * @param {HTMLImageElement} imageElement Image element to test.
+   * @returns {boolean} Whether the image is part of list content.
+   */
+  isListImage(imageElement) {
+    return Boolean(imageElement.closest('li,ul,ol'));
+  }
+}
+PasteImageParser.PREVIEW_IMG_KEY = 'data-rte-id';