@globalpayments/vega 2.32.0 → 2.34.0

package/dist/collection/polyfill/shadow-selection/shadow-selection-polyfill.js

@@ -0,0 +1,164 @@
+import { getActiveElement } from '../../utils/component';
+let processing = false;
+/**
+ * Simulate a selection for browsers that don't support shadow selection.
+ * Cypress test case added in https://github.com/heartlandpayments/Vega/pull/1561/files#diff-83bdbaaf47fc156ab878099aa1f21b0e8ab92abe5852521299f1fb6efab001c2R300
+ */
+class ShadowSelection {
+  constructor() {
+    this.rangeCount = 0;
+    this.ranges = [];
+  }
+  /**
+   * Returns a Range object at a specified index.
+   *
+   * @param {number} index - A specified index.
+   * @returns {Range} - A Range object.
+   */
+  getRangeAt(index) {
+    return this.ranges[index];
+  }
+  /**
+   * Adds a Range to ranges array.
+   *
+   * @param {Range} range - The range of selection.
+   */
+  addRange(range) {
+    this.ranges.push(range);
+    this.rangeCount = this.ranges.length;
+    if (!processing) {
+      const windowSelection = window.getSelection();
+      windowSelection.removeAllRanges();
+      windowSelection.setBaseAndExtent(range.startContainer, range.startOffset, range.endContainer, range.endOffset);
+    }
+  }
+  /**
+   * Clears all ranges.
+   */
+  removeAllRanges() {
+    this.ranges = [];
+    this.rangeCount = 0;
+  }
+}
+/**
+ * Due to the ShadowRoot.getSelection is not a standard API, we add this polyfill to achieve this function.
+ *
+ * - On Chromium, calling document.getSelection will not pierce into the Shadow DOM and gives you some unhelpful high-level element.
+ *   But it does expose the non-standard getSelection method on the ShadowRoot.
+ *
+ * - On Firefox, it does not implement ShadowRoot.getSelection,
+ *   but document.getSelection will pierce through shadow dom and give you the exact element.
+ *
+ * - On Safari, Selection.getComposedRanges is supported as of v17. On versions before that,
+ *   ShadowRoot.getSelection is not supported and apparently document.getSelection does not pierce the Shadow DOM, meaning you are just out of luck.
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/API/ShadowRoot#shadowroot.getselection
+ * https://stackoverflow.com/a/70523247
+ */
+export class ShadowSelectionPolyfill {
+  constructor() {
+    this.supportShadowSelection = typeof window.ShadowRoot.prototype['getSelection'] === 'function';
+    this.supportBeforeInput = typeof window.InputEvent.prototype.getTargetRanges === 'function';
+    this.isFirefox = window.navigator.userAgent.toLowerCase().indexOf('firefox') > 0;
+    this.listen();
+  }
+  /**
+   * For Firefox, we directly use document.getSelection()
+   * For other browser which not support shadowroot.getSelection, we use this.selection which is built by us.
+   * For browser which supported shadowroot.getSelection, we use shadowRoot.getselection().
+   *
+   * @param {ShadowRoot} shadow - A shadow.
+   * @returns {Selection} - The shadow selection.
+   */
+  getSelection(shadow) {
+    if (this.supportShadowSelection) {
+      return shadow['getSelection']();
+    }
+    else {
+      return this.isFirefox
+        ? this.getFirefoxSelection()
+        : this.polyfilledShadowSelection;
+    }
+  }
+  /**
+   * Get selection in firefox.
+   *
+   * Example:
+   *
+   * <span>span1</span><span>span2</span><span>span3</span>
+   *
+   * In firefox, while selected `span2`, the range be likely to:
+   * range:
+   *   startContainer: #text 'span1'
+   *   startOffset: 5
+   * 	 endContainer: #text 'span3'
+   *   endOffset: 0
+   * start is end of brefore node and end is start of after node.
+   *
+   * So we should modify the startContainer and endContainer here.
+   *
+   * modified range:
+   *   startContainer: #text 'span2'
+   *   startOffset: 0
+   * 	 endContainer: #text 'span2'
+   *   endOffset: 5
+   *
+   * @returns {Selection} - document selection
+   */
+  getFirefoxSelection() {
+    const selection = document.getSelection();
+    const range = selection.getRangeAt(0);
+    const startNode = range.startContainer;
+    const endNode = range.endContainer;
+    if (startNode !== endNode && startNode.textContent.length === range.startOffset) {
+      const nextSibling = startNode.nodeType === Node.TEXT_NODE
+        ? startNode.parentNode.nextSibling
+        : startNode.nextSibling;
+      range.setStart(nextSibling.firstChild, 0);
+    }
+    if (endNode !== startNode && range.endOffset === 0) {
+      const previousSibling = endNode.nodeType === Node.TEXT_NODE
+        ? endNode.parentNode.previousSibling
+        : endNode.previousSibling;
+      range.setEnd(previousSibling.lastChild, previousSibling.lastChild.textContent.length);
+    }
+    return selection;
+  }
+  /**
+   * Sets up event listeners for `selectionchange` and `beforeinput` events to simulate shadow selection.
+   */
+  listen() {
+    if (this.isFirefox || this.supportShadowSelection || !this.supportBeforeInput)
+      return;
+    this.polyfilledShadowSelection = new ShadowSelection();
+    window.addEventListener('selectionchange', () => {
+      if (!processing) {
+        processing = true;
+        const active = getActiveElement();
+        if (active && active.hasAttribute('contenteditable')) {
+          // This command will not actually work, it only trigger the `beforeinput` event,
+          // the `beforeinput` event will prevented this command work.
+          document.execCommand('indent');
+        }
+        else {
+          this.polyfilledShadowSelection.removeAllRanges();
+        }
+        processing = false;
+      }
+    }, true);
+    window.addEventListener('beforeinput', (event) => {
+      if (processing) {
+        const ranges = event.getTargetRanges();
+        const range = ranges[0];
+        const newRange = new Range();
+        newRange.setStart(range.startContainer, range.startOffset);
+        newRange.setEnd(range.endContainer, range.endOffset);
+        this.polyfilledShadowSelection.removeAllRanges();
+        this.polyfilledShadowSelection.addRange(newRange);
+        event.preventDefault();
+        event.stopImmediatePropagation();
+      }
+    }, true);
+  }
+}
+export default new ShadowSelectionPolyfill();

package/dist/collection/polyfill/shadow-selection/test/shadow-selection-polyfill.test.js

@@ -0,0 +1,233 @@
+describe('ShadowSelectionPolyfill', () => {
+  class MockedRanger {
+    setStart(node, offset) {
+      this.startContainer = node;
+      this.startOffset = offset;
+    }
+    setEnd(node, offset) {
+      this.endContainer = node;
+      this.endOffset = offset;
+    }
+  }
+  class MockedSelection {
+    constructor() {
+      this.ranges = [];
+    }
+    removeAllRanges() {
+      this.ranges = [];
+    }
+    setBaseAndExtent(anchorNode, anchorOffset, focusNode, focusOffset) {
+      const range = new MockedRanger();
+      range.setStart(anchorNode, anchorOffset);
+      range.setEnd(focusNode, focusOffset);
+      this.ranges.push(range);
+    }
+    getRangeAt(index) {
+      return this.ranges[index];
+    }
+  }
+  const richTextContent = document.createElement('div');
+  richTextContent.setAttribute('contenteditable', 'true');
+  const richText = document.createElement('div');
+  const shadow = richText.attachShadow({ mode: 'open' });
+  shadow.appendChild(richTextContent);
+  afterEach(function () {
+    jest.resetModules();
+  });
+  describe('Use shadow selection polyfill', () => {
+    Object.defineProperty(global, 'Range', {
+      writable: true,
+      value: MockedRanger,
+    });
+    beforeEach(() => {
+      Object.assign(window, {
+        navigator: { userAgent: '' },
+        /* eslint-disable-next-line @typescript-eslint/naming-convention*/
+        ShadowRoot: {
+          prototype: {
+            /* eslint-disable-next-line @typescript-eslint/no-empty-function*/
+            getSelection: '',
+          },
+        },
+        /* eslint-disable-next-line @typescript-eslint/naming-convention*/
+        InputEvent: {
+          prototype: {
+            /* eslint-disable-next-line @typescript-eslint/no-empty-function*/
+            getTargetRanges: /* eslint-disable jsdoc/require-jsdoc */ () => { },
+          },
+        },
+      });
+      Object.assign(document, {
+        activeElement: richTextContent,
+        execCommand: () => {
+          const event = new Event('beforeinput');
+          event['getTargetRanges'] = () => {
+            return [
+              {
+                startContainer: richTextContent,
+                endContainer: richTextContent,
+                commonAncestorContainer: richTextContent,
+                startOffset: 0,
+                endOffset: 2,
+              },
+            ];
+          };
+          window.dispatchEvent(event);
+        },
+      });
+    });
+    it('should get shadow selection proper', async () => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const ShadowSelectionPolyfill = require('../shadow-selection-polyfill');
+      Object.assign(document, {
+        activeElement: richTextContent,
+        execCommand: () => {
+          const event = new Event('beforeinput');
+          event['getTargetRanges'] = () => {
+            return [
+              {
+                startContainer: richTextContent,
+                endContainer: richTextContent,
+                commonAncestorContainer: richTextContent,
+                startOffset: 0,
+                endOffset: 2,
+              },
+            ];
+          };
+          window.dispatchEvent(event);
+        },
+      });
+      window.dispatchEvent(new Event('selectionchange'));
+      const selection = ShadowSelectionPolyfill.default.getSelection(shadow);
+      expect(selection.rangeCount).toEqual(1);
+      const range = selection.getRangeAt(0);
+      expect(range.startContainer).toEqual(richTextContent);
+      expect(range.endContainer).toEqual(richTextContent);
+      expect(range.startOffset).toEqual(0);
+      expect(range.endOffset).toEqual(2);
+    });
+    it('should set window selection proper while add range to shadow selection', async () => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const ShadowSelectionPolyfill = require('../shadow-selection-polyfill');
+      const selection = ShadowSelectionPolyfill.default.getSelection(shadow);
+      const mockedWindowSelection = new MockedSelection();
+      const mockedWindowRange = new MockedRanger();
+      const windowStart = document.createElement('div');
+      const windowEnd = document.createElement('div');
+      mockedWindowRange.setStart(windowStart, 5);
+      mockedWindowRange.setEnd(windowEnd, 6);
+      mockedWindowSelection.ranges = [mockedWindowRange];
+      Object.assign(window, {
+        getSelection: () => mockedWindowSelection,
+      });
+      const mockedShadowRange = new MockedRanger();
+      const shadowStart = document.createElement('div');
+      const shadowEnd = document.createElement('div');
+      mockedShadowRange.setStart(shadowStart, 3);
+      mockedShadowRange.setEnd(shadowEnd, 4);
+      selection.addRange(mockedShadowRange);
+      expect(mockedWindowSelection.ranges.length).toEqual(1);
+      expect(mockedWindowSelection.ranges[0].startContainer).toEqual(shadowStart);
+      expect(mockedWindowSelection.ranges[0].startOffset).toEqual(3);
+      expect(mockedWindowSelection.ranges[0].endContainer).toEqual(shadowEnd);
+      expect(mockedWindowSelection.ranges[0].endOffset).toEqual(4);
+    });
+    it('should clear selection while not have active element', async () => {
+      richTextContent.removeAttribute('contenteditable');
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const ShadowSelectionPolyfill = require('../shadow-selection-polyfill');
+      const selection = ShadowSelectionPolyfill.default.getSelection(shadow);
+      selection.removeAllRanges();
+      window.dispatchEvent(new Event('selectionchange'));
+      expect(selection.rangeCount).toEqual(0);
+    });
+  });
+  describe('Use document getSelection in firefox', () => {
+    const span1 = document.createElement('span');
+    span1.textContent = 'span1';
+    const span2 = document.createElement('span');
+    span2.textContent = 'span2';
+    const span3 = document.createElement('span');
+    span3.textContent = 'span3';
+    richTextContent.append(span1, span2, span3);
+    beforeEach(() => {
+      Object.assign(window, {
+        /* eslint-disable-next-line @typescript-eslint/naming-convention*/
+        ShadowRoot: {
+          prototype: {
+            getSelection: '',
+          },
+        },
+        /* eslint-disable-next-line @typescript-eslint/naming-convention*/
+        InputEvent: {
+          prototype: {
+            /* eslint-disable-next-line @typescript-eslint/no-empty-function*/
+            getTargetRanges: /* eslint-disable jsdoc/require-jsdoc */ () => { },
+          },
+        },
+      });
+    });
+    it('get document selection proper', () => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const ShadowSelectionPolyfill = require('../shadow-selection-polyfill');
+      const mockedSelection = new MockedSelection();
+      mockedSelection.setBaseAndExtent(span1, 5, span3, 0);
+      Object.assign(document, { getSelection: () => mockedSelection });
+      ShadowSelectionPolyfill.default['supportShadowSelection'] = false;
+      ShadowSelectionPolyfill.default['isFirefox'] = true;
+      const selection = ShadowSelectionPolyfill.default.getSelection(shadow);
+      expect(selection).toEqual(mockedSelection);
+    });
+    it('get selection proper while have boundary node', () => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const ShadowSelectionPolyfill = require('../shadow-selection-polyfill');
+      const mockedSelection = new MockedSelection();
+      mockedSelection.setBaseAndExtent(span1, 5, span3, 0);
+      Object.assign(document, { getSelection: () => mockedSelection });
+      ShadowSelectionPolyfill.default['supportShadowSelection'] = false;
+      ShadowSelectionPolyfill.default['isFirefox'] = true;
+      const selection = ShadowSelectionPolyfill.default.getSelection(shadow);
+      const range = selection.getRangeAt(0);
+      expect(range.startContainer).toEqual(span2.firstChild);
+      expect(range.endContainer).toEqual(span2.firstChild);
+      expect(range.startOffset).toEqual(0);
+      expect(range.endOffset).toEqual(5);
+      // startContainer and endContainer is text node
+      mockedSelection.removeAllRanges();
+      mockedSelection.setBaseAndExtent(span1.firstChild, 5, span3.firstChild, 0);
+      const selection1 = ShadowSelectionPolyfill.default.getSelection(shadow);
+      const range1 = selection1.getRangeAt(0);
+      expect(range1.startContainer).toEqual(span2.firstChild);
+      expect(range1.endContainer).toEqual(span2.firstChild);
+      expect(range1.startOffset).toEqual(0);
+      expect(range1.endOffset).toEqual(5);
+    });
+  });
+  describe('Use shadow getSelection', () => {
+    beforeEach(() => {
+      Object.assign(window, {
+        navigator: { userAgent: '' },
+        /* eslint-disable-next-line @typescript-eslint/naming-convention*/
+        ShadowRoot: {
+          prototype: {
+            getSelection: () => 'shadow.getSelection is called',
+          },
+        },
+        /* eslint-disable-next-line @typescript-eslint/naming-convention*/
+        InputEvent: {
+          prototype: {
+            /* eslint-disable-next-line @typescript-eslint/no-empty-function*/
+            getTargetRanges: /* eslint-disable jsdoc/require-jsdoc */ () => { },
+          },
+        },
+      });
+    });
+    it('should call shadow getSelection proper', async () => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const ShadowSelectionPolyfill = require('../shadow-selection-polyfill');
+      shadow['getSelection'] = () => 'shadow.getSelection is called';
+      ShadowSelectionPolyfill.default['supportShadowSelection'] = true;
+      expect(ShadowSelectionPolyfill.default.getSelection(shadow)).toEqual('shadow.getSelection is called');
+    });
+  });
+});

package/dist/collection/polyfill/test-polyfill/unit/index.js

@@ -1,2 +1,3 @@
 import './events.ts';
 import './methods.ts';
+import './range.ts';

package/dist/collection/polyfill/test-polyfill/unit/methods.js

@@ -27,3 +27,12 @@ MockElement.prototype['replaceChildren'] = function (...nodes) {
     this.appendChild(node);
   });
 };
+/**
+ * A polyfill for the getSelection method
+ * Get the Selection instance from the shadowroot
+ *
+ * @returns {null} null
+ */
+MockElement.prototype['getSelection'] = function () {
+  return null;
+};

package/dist/collection/polyfill/test-polyfill/unit/range.js

@@ -0,0 +1,15 @@
+/**
+ * Mock the Range API for test setStart setEnd methods
+ */
+export const mockRange = {
+  // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/no-empty-function
+  setStart: () => { },
+  // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/no-empty-function
+  setEnd: () => { },
+};
+Object.assign(globalThis, {
+  // eslint-disable-next-line @typescript-eslint/naming-convention, jsdoc/require-jsdoc
+  Range: function () {
+    return mockRange;
+  },
+});

package/dist/collection/polyfill/test-polyfill/unit/shadow-selection.js

@@ -0,0 +1,17 @@
+/* istanbul ignore next */
+Object.assign(window, {
+  /* eslint-disable-next-line @typescript-eslint/naming-convention*/
+  ShadowRoot: {
+    prototype: {
+      /* eslint-disable-next-line @typescript-eslint/no-empty-function*/
+      getSelection: /* eslint-disable jsdoc/require-jsdoc */ () => { },
+    },
+  },
+  /* eslint-disable-next-line @typescript-eslint/naming-convention*/
+  InputEvent: {
+    prototype: {
+      /* eslint-disable-next-line @typescript-eslint/no-empty-function*/
+      getTargetRanges: /* eslint-disable jsdoc/require-jsdoc */ () => { },
+    },
+  },
+});

package/dist/collection/utils/spec-utils.js

@@ -134,12 +134,13 @@ export const emptyContentBySelector = (body, ...selectors) => {
  * @returns {void} - void.
  */
 export const setComponentPropertyWithMutationObserver = (element, property, value, mutationObserverIndex) => {
+  var _a;
   element[property] = value;
   const index = mutationObserverIndex ? mutationObserverIndex : 0;
   let mockedAttributeMutationObserver = MockedMutationObserver.mock.instances[index];
   if (!mutationObserverIndex && MockedMutationObserver.mock.instances.length > 1) {
     for (let i = MockedMutationObserver.mock.instances.length - 1; i >= 0; i--) {
-      if (MockedMutationObserver.mock.instances[i]['observe'].mock.calls[0][0] === element) {
+      if (((_a = MockedMutationObserver.mock.instances[i]['observe'].mock.calls[0]) === null || _a === void 0 ? void 0 : _a[0]) === element) {
         mockedAttributeMutationObserver = MockedMutationObserver.mock.instances[i];
         break;
       }

package/dist/collection/utils/test/ui.test.js

@@ -1,7 +1,7 @@
 import { DeviceType } from '../../types/ui.type';
 import { LogUtility } from '../log';
 import { setupUserAgent } from '../test-utils';
-import { arrayToClassString, getBrowserVisibleArea, getDeviceType, isParent, containerScrollToItem, isElementVisible, extractNumberFromString, hexToRGB, isTextWrapped, getElementComputedStyle, getHexFromShorthand, findParent, getDeepActiveElementInShadow, } from '../ui';
+import { arrayToClassString, getBrowserVisibleArea, getDeviceType, isParent, containerScrollToItem, isElementVisible, extractNumberFromString, hexToRGB, isTextWrapped, getElementComputedStyle, getHexFromShorthand, findParent, getDeepActiveElementInShadow, rgbToHex, } from '../ui';
 beforeAll(() => {
   document.documentElement.scrollTop = 0;
 });
@@ -150,6 +150,11 @@ test('hexToRGB should work as expected', () => {
   expect(hexToRGB('#FFF')).toEqual({ b: 255, g: 255, r: 255 });
   expect(hexToRGB('GGG')).toEqual(null);
 });
+test('rgbToHex should work as expected', () => {
+  expect(rgbToHex('#FFFFFF')).toEqual(null);
+  expect(rgbToHex('rgb(106, 3, 79)')).toEqual('#6a034f');
+  expect(rgbToHex('rgb(106, 3)')).toEqual(null);
+});
 test('hexFullFormConverter should work as expected', () => {
   expect(getHexFromShorthand('#FFF')).toEqual('#FFFFFF');
   expect(getHexFromShorthand('AAA')).toEqual('#AAAAAA');

package/dist/collection/utils/ui.js

@@ -139,6 +139,24 @@ export function hexToRGB(hex) {
     }
     : null;
 }
+/**
+ * It convert RGB color to Hex color
+ *
+ * @param {string} rgb - The RGB color.
+ * @returns {Nullable<string>} - The hex color
+ */
+export function rgbToHex(rgb) {
+  if (!rgb.includes('rgb'))
+    return null;
+  const rgbColors = rgb.match(/\d+/g);
+  if (!rgbColors || rgbColors.length !== 3)
+    return null;
+  const hexColors = rgbColors.map((color) => {
+    const hex = Number(color).toString(16);
+    return hex.length === 1 ? '0' + hex : hex;
+  });
+  return `#${hexColors.join('')}`;
+}
 /**
  * It converts a hexadecimal color code from shorthand form to full form
  *

package/dist/collection/value-model-adapters/angular-ng-model-accessor-adapter.js

@@ -15,6 +15,7 @@ export const AngularAccessorAdapter = [
       'vega-input-range',
       'vega-input-select',
       'vega-radio-group',
+      'vega-rich-text-editor',
       'vega-selection-chip-group',
       'vega-selection-tile-group',
       'vega-signature-capture',

package/dist/collection/value-model-adapters/vue-component-v-model-adaptor.js

@@ -17,6 +17,7 @@ export const VueComponentVModelAdaptor = [
       'vega-input-range',
       'vega-input-select',
       'vega-radio-group',
+      'vega-rich-text-editor',
       'vega-selection-chip-group',
       'vega-selection-tile-group',
       'vega-signature-capture',

package/dist/esm/_commonjsHelpers-9943807e.js

@@ -0,0 +1,17 @@
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function createCommonjsModule(fn, basedir, module) {
+	return module = {
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire();
+		}
+	}, fn(module, module.exports), module.exports;
+}
+
+function commonjsRequire () {
+	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+}
+
+export { commonjsGlobal as a, createCommonjsModule as c };

package/dist/esm/{app-globals-5084ae11.js → app-globals-9971ccfd.js}

@@ -1,17 +1,19 @@
-import { F as FeatureFlag } from './feature-flag-controller-f72c004e.js';
-import { V as VegaLoader, a as VegaNotify, b as VegaThemeManager, c as VegaEventManager, d as VegaZIndexManager, e as VegaSkeletonLoader } from './vega-skeleton-loader-controller-1911558d.js';
-import { M as MapToComponentMethod, V as VegaSlimmer, s as setVegaLogLevel, G as GlobalSlimmersRegistry } from './global-slimmer-registry-17c4efd4.js';
-import { V as VegaDialog } from './vega-dialog-controller-8b343a17.js';
+import { F as FeatureFlag } from './feature-flag-controller-dfde0cfa.js';
+import { V as VegaLoader, a as VegaNotify, b as VegaEventManager, c as VegaZIndexManager, d as VegaSkeletonLoader } from './block-annotation.abstract-b0554e2b.js';
+import { V as VegaThemeManager } from './node.abstract-93746055.js';
+import { M as MapToComponentMethod, V as VegaSlimmer, f as forceUpdate, s as setVegaLogLevel, G as GlobalSlimmersRegistry } from './global-slimmer-registry-6887a59f.js';
+import { V as VegaDialog } from './vega-dialog-controller-5b23f68c.js';
 import { v as vegaEnvManager } from './vega-env-manager-8f8dc473.js';
-import { V as VegaIconManager } from './icon-manager-1ee2c968.js';
-import { V as VegaInternalTranslation, a as VegaTranslation, s as staticTranslations } from './translation-4eb3cf85.js';
-import { T as TypographyUrls } from './typography-a8fc4764.js';
+import { V as VegaIconManager } from './icon-manager-3cef32e7.js';
+import './ui-5600b48f.js';
+import { V as VegaInternalTranslation, a as VegaTranslation, s as staticTranslations } from './translation-b3fe8e74.js';
+import { T as TypographyUrls } from './typography-396de03f.js';
 import { V as ValidCreditCardNumberRule } from './valid-credit-card-number-rule-2aef3ad5.js';
-import { w as waitForVega } from './index-0830dd1d.js';
-import { U as UPDATE_TRANSLATION } from './static-subject-title-500cf2a3.js';
-import { C as ChangeManager } from './change-manager-6a7eb88c.js';
-import { O as Observer } from './observer-3959f9dd.js';
-import { f as forceUpdate } from './index-187f71d1.js';
+import { w as waitForVega } from './text-node-6f7d736c.js';
+import { V as VegaRTEContent } from './content-state-acf55eb0.js';
+import { U as UPDATE_TRANSLATION } from './static-subject-title-e06a3840.js';
+import { C as ChangeManager } from './change-manager-8f5b72c2.js';
+import { O as Observer } from './dom-node-subject-observer-factory-80358591.js';
 
 var __decorate$1 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -171,6 +173,7 @@ function appGlobalScript () {
   injectWaitForVegaIntoGlobal();
   injectVegaSkeletonLoaderIntoGlobal();
   injectVegaTranslationIntoGlobal();
+  injectVegaRichTextEditorClassIntoGlobal();
 }
 /**
  * Disable feature flags from the client global defined lists.
@@ -272,7 +275,7 @@ function injectValidCreditCardNumberRuleIntoGlobal() {
 function initRuntimeMetricsTelemetryCollection() {
   globalThis.VegaEnvInfo = vegaEnvManager.getVegaEnv();
   // eslint-disable-next-line spellcheck/spell-checker
-  void import('./index-0863eec6.js').then(function (n) { return n.i; }).then((
+  void import('./index-44c794b4.js').then((
   // eslint-disable-next-line spellcheck/spell-checker
   module) => {
     module['default']['init'](FeatureFlag);
@@ -297,6 +300,12 @@ function injectVegaTranslationIntoGlobal() {
   globalThis.VegaTranslation = VegaTranslation;
   globalThis.VegaTranslationResourceEN = staticTranslations;
 }
+/**
+ * Inject VegaRTEContent to global as a public api
+ */
+function injectVegaRichTextEditorClassIntoGlobal() {
+  globalThis.VegaRTEContent = VegaRTEContent;
+}
 
 const globalScripts = appGlobalScript;