@heartlandone/vega 2.75.1 → 2.76.0

package/dist/collection/utils/sanitize/test/html-sanitizer.test.js

@@ -0,0 +1,57 @@
+import { tryGetDocument } from '../../try-get-document';
+import { HtmlSanitizer } from '../core/html-sanitizer';
+import { labelSanitizeStrategy, styleSanitizeStrategy, emptySanitizeStrategy } from '../index';
+describe('HtmlSanitizer', () => {
+  const sanitizer = new HtmlSanitizer();
+  it('should return empty string for empty input', () => {
+    expect(sanitizer.sanitize('', labelSanitizeStrategy)).toBe('');
+    expect(sanitizer.sanitize('   ', labelSanitizeStrategy)).toBe('');
+  });
+  it('should sanitize label content correctly', () => {
+    const input = '<b>Bold</b> <i>Italic</i> <script>alert(1)</script>';
+    const result = sanitizer.sanitize(input, labelSanitizeStrategy);
+    expect(result).toBe('<b>Bold</b> <i>Italic</i> alert(1)');
+  });
+  it('should preserve text if no tags exist', () => {
+    const input = 'Hello world';
+    const result = sanitizer.sanitize(input, labelSanitizeStrategy);
+    expect(result).toBe('Hello world');
+  });
+  it('should unwrap disallowed elements', () => {
+    const input = '<div><span>Text</span></div>';
+    const result = sanitizer.sanitize(input, labelSanitizeStrategy);
+    expect(result).toBe('Text');
+  });
+  it('should remove unsupported node types (comment nodes)', () => {
+    const input = '<!-- comment -->Visible';
+    const result = sanitizer.sanitize(input, labelSanitizeStrategy);
+    expect(result).toBe('Visible');
+  });
+  it('should preserve safe CSS text in style strategy', () => {
+    const css = 'body { color: red; }';
+    const result = sanitizer.sanitize(css, styleSanitizeStrategy);
+    expect(result).toBe(css);
+  });
+  it('should remove dangerous CSS in style strategy', () => {
+    const css = 'body { background: url(javascript:alert(1)) }';
+    const result = sanitizer.sanitize(css, styleSanitizeStrategy);
+    expect(result).toBe('');
+  });
+  it('should always return empty string for empty strategy', () => {
+    const input = '<b>Bold</b> <i>Italic</i>';
+    const result = sanitizer.sanitize(input, emptySanitizeStrategy);
+    expect(result).toBe('');
+  });
+  it('sanitizeHtmlLabel should not return empty string if document is available', () => {
+    expect(typeof document).toBe('object');
+    expect(tryGetDocument()).toBe(document);
+    expect(sanitizer.sanitize('<b>Some</b> text', labelSanitizeStrategy)).toEqual('<b>Some</b> text');
+  });
+  it('sanitizeHtmlLabel should return empty string if document is not available', () => {
+    const originalDocument = globalThis.document;
+    delete globalThis.document;
+    expect(tryGetDocument()).toBeUndefined();
+    expect(sanitizer.sanitize('<b>Some</b> text', labelSanitizeStrategy)).toEqual('');
+    globalThis.document = originalDocument;
+  });
+});

package/dist/collection/utils/sanitize/test/label-strategy.test.js

@@ -0,0 +1,56 @@
+import { HtmlSanitizer } from '../core/html-sanitizer';
+import { LabelSanitizeStrategy } from '../strategies/label-sanitize-strategy';
+describe('LabelSanitizeStrategy', () => {
+  const sanitizer = new HtmlSanitizer();
+  const strategy = new LabelSanitizeStrategy();
+  it('should allow <b>, <i>, <strong>, <em>', () => {
+    const input = '<b>Bold</b><i>Italic</i><strong>Strong</strong><em>Em</em>';
+    const result = sanitizer.sanitize(input, strategy);
+    expect(result).toBe(input);
+  });
+  it('should unwrap disallowed tags but preserve text', () => {
+    const input = '<span>Span</span><div>Div</div>';
+    const result = sanitizer.sanitize(input, strategy);
+    expect(result).toBe('SpanDiv');
+  });
+  it('should strip attributes even on allowed tags', () => {
+    const input = '<b style="color:red">Bold</b>';
+    const result = sanitizer.sanitize(input, strategy);
+    expect(result).toBe('<b>Bold</b>');
+  });
+  it('should preserve plain text nodes', () => {
+    const input = 'Just some text';
+    const result = sanitizer.sanitize(input, strategy);
+    expect(result).toBe('Just some text');
+  });
+  it('should handle mixed allowed and disallowed tags', () => {
+    const input = '<b>Bold</b> <script>alert(1)</script>';
+    const result = sanitizer.sanitize(input, strategy);
+    expect(result).toBe('<b>Bold</b> alert(1)');
+  });
+  test('sanitizeHtmlLabel should return textContent if no HTML elements exist', () => {
+    expect(sanitizer.sanitize('>hello', strategy)).toEqual('>hello');
+    expect(sanitizer.sanitize('Me > You', strategy)).toEqual('Me > You');
+    expect(sanitizer.sanitize('Me <b>></b> You', strategy)).toEqual('Me <b>&gt;</b> You');
+  });
+  test('serializeFragment should return innerHTML when HTML elements exist', () => {
+    const result = sanitizer.sanitize('<b>Bold</b>', strategy);
+    expect(result).toBe('<b>Bold</b>');
+  });
+  test('serializeFragment falls back to empty string when textContent is null', () => {
+    const originalCreateElement = document.createElement;
+    jest.spyOn(document, 'createElement').mockImplementation((tagName) => {
+      const el = originalCreateElement.call(document, tagName);
+      if (tagName === 'div') {
+        Object.defineProperty(el, 'textContent', {
+          get: () => null,
+          configurable: true,
+        });
+      }
+      return el;
+    });
+    const result = sanitizer.sanitize('plain text', strategy);
+    expect(result).toBe('');
+    document.createElement.mockRestore();
+  });
+});

package/dist/collection/utils/sanitize/test/sanitize-strategy.test.js

@@ -0,0 +1,85 @@
+import { SanitizeStrategy } from '../core/sanitize-strategy';
+describe('SanitizeStrategy (base)', () => {
+  /**
+   * Concrete implementation for testing base class behavior.
+   * Allows only <b> tags.
+   */
+  class TestStrategy extends SanitizeStrategy {
+    constructor() {
+      super(...arguments);
+      this.allowedTags = new Set(['B']);
+      this.allowedAttributes = new Map([
+        ['B', new Set(['class', 'id'])],
+      ]);
+    }
+  }
+  class NoTextStrategy extends SanitizeStrategy {
+    constructor() {
+      super(...arguments);
+      this.allowedTags = new Set();
+      this.preserveTextContent = false;
+    }
+  }
+  let strategy;
+  let doc;
+  beforeEach(() => {
+    strategy = new TestStrategy();
+    doc = document;
+  });
+  it('should preserve text nodes', () => {
+    const textNode = doc.createTextNode('Hello');
+    const result = strategy.execute(textNode, doc);
+    expect(result).not.toBeNull();
+    expect(result === null || result === void 0 ? void 0 : result.textContent).toBe('Hello');
+  });
+  it('should allow allowed tags', () => {
+    const element = doc.createElement('b');
+    element.textContent = 'Bold';
+    const result = strategy.execute(element, doc);
+    expect(result).not.toBeNull();
+    expect(result.tagName).toBe('B');
+    expect(result === null || result === void 0 ? void 0 : result.textContent).toBe('Bold');
+  });
+  it('should unwrap disallowed tags but preserve children', () => {
+    const div = doc.createElement('div');
+    const span = doc.createElement('span');
+    span.textContent = 'Inner';
+    div.appendChild(span);
+    const result = strategy.execute(div, doc);
+    expect(result).not.toBeNull();
+    expect(result === null || result === void 0 ? void 0 : result.textContent).toBe('Inner');
+  });
+  it('should return null for unsupported node types (base implementation)', () => {
+    const comment = doc.createComment('test');
+    const result = strategy.execute(comment, doc);
+    expect(result).toBeNull();
+  });
+  it('should preserve only allowed attributes', () => {
+    const element = doc.createElement('b');
+    element.setAttribute('class', 'allowed');
+    element.setAttribute('id', 'also-allowed');
+    element.setAttribute('style', 'color:red'); // disallowed attribute
+    const result = strategy.execute(element, doc);
+    expect(result).not.toBeNull();
+    const cleanElement = result;
+    expect(cleanElement.getAttribute('class')).toBe('allowed');
+    expect(cleanElement.getAttribute('id')).toBe('also-allowed');
+    expect(cleanElement.hasAttribute('style')).toBe(false);
+  });
+  it('should fallback to empty string when textContent is null', () => {
+    const textNode = doc.createTextNode('test');
+    Object.defineProperty(textNode, 'textContent', {
+      value: null,
+      configurable: true,
+    });
+    const result = strategy.execute(textNode, doc);
+    expect(result).not.toBeNull();
+    expect(result === null || result === void 0 ? void 0 : result.textContent).toBe('');
+  });
+  it('should return null when preserveTextContent is false', () => {
+    const noTextStrategy = new NoTextStrategy();
+    const textNode = doc.createTextNode('Hidden');
+    const result = noTextStrategy.execute(textNode, doc);
+    expect(result).toBeNull();
+  });
+});

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

@@ -0,0 +1,22 @@
+import { HtmlSanitizer, SanitizeStrategy, LabelSanitizeStrategy, StyleSanitizeStrategy, EmptySanitizeStrategy, htmlSanitizer, labelSanitizeStrategy, styleSanitizeStrategy, emptySanitizeStrategy, } from '../index';
+describe('utils/sanitize/index.ts exports', () => {
+  it('should export HtmlSanitizer class and instance', () => {
+    expect(typeof HtmlSanitizer).toBe('function');
+    expect(htmlSanitizer).toBeInstanceOf(HtmlSanitizer);
+  });
+  it('should export SanitizeStrategy class', () => {
+    expect(typeof SanitizeStrategy).toBe('function');
+  });
+  it('should export LabelSanitizeStrategy class and instance', () => {
+    expect(typeof LabelSanitizeStrategy).toBe('function');
+    expect(labelSanitizeStrategy).toBeInstanceOf(LabelSanitizeStrategy);
+  });
+  it('should export StyleSanitizeStrategy class and instance', () => {
+    expect(typeof StyleSanitizeStrategy).toBe('function');
+    expect(styleSanitizeStrategy).toBeInstanceOf(StyleSanitizeStrategy);
+  });
+  it('should export EmptySanitizeStrategy class and instance', () => {
+    expect(typeof EmptySanitizeStrategy).toBe('function');
+    expect(emptySanitizeStrategy).toBeInstanceOf(EmptySanitizeStrategy);
+  });
+});

package/dist/collection/utils/sanitize/test/serialize-fragment.test.js

@@ -0,0 +1,25 @@
+import { serializeFragment } from '../utils/serialize-fragment';
+describe('serializeFragment', () => {
+  it('should return textContent when there are no element children', () => {
+    const doc = document;
+    const fragment = doc.createDocumentFragment();
+    fragment.appendChild(doc.createTextNode('Hello World'));
+    const result = serializeFragment(fragment, doc);
+    expect(result).toBe('Hello World');
+  });
+  it('should return innerHTML when element children exist', () => {
+    const doc = document;
+    const fragment = doc.createDocumentFragment();
+    const div = doc.createElement('div');
+    div.textContent = 'Inside';
+    fragment.appendChild(div);
+    const result = serializeFragment(fragment, doc);
+    expect(result).toBe('<div>Inside</div>');
+  });
+  it('should return empty string when textContent is null', () => {
+    const doc = document;
+    const fragment = doc.createDocumentFragment();
+    const result = serializeFragment(fragment, doc);
+    expect(result).toBe('');
+  });
+});

package/dist/collection/utils/sanitize/test/style-strategy.test.js

@@ -0,0 +1,45 @@
+import { HtmlSanitizer } from '../core/html-sanitizer';
+import { StyleSanitizeStrategy } from '../strategies/style-sanitize-strategy';
+describe('StyleSanitizeStrategy', () => {
+  const sanitizer = new HtmlSanitizer();
+  const strategy = new StyleSanitizeStrategy();
+  it('should preserve safe CSS text', () => {
+    const css = 'body { color: red; }';
+    const result = sanitizer.sanitize(css, strategy);
+    expect(result).toBe(css);
+  });
+  it('should remove CSS with expression()', () => {
+    const css = 'body { width: expression(alert(1)); }';
+    const result = sanitizer.sanitize(css, strategy);
+    expect(result).toBe('');
+  });
+  it('should remove CSS with javascript: URL', () => {
+    const css = 'background: url(javascript:alert(1));';
+    const result = sanitizer.sanitize(css, strategy);
+    expect(result).toBe('');
+  });
+  it('should remove HTML tags entirely', () => {
+    const input = '<div>Some HTML</div>';
+    const result = sanitizer.sanitize(input, strategy);
+    expect(result).toBe('Some HTML');
+  });
+  it('should return null for unsupported node types', () => {
+    const doc = document;
+    const comment = doc.createComment('unsafe');
+    const result = strategy.execute(comment, doc);
+    expect(result).toBeNull();
+  });
+  it('should fallback to empty string when textContent is null', () => {
+    const doc = document;
+    const textNode = doc.createTextNode('test');
+    Object.defineProperty(textNode, 'textContent', {
+      value: null,
+      configurable: true,
+    });
+    const result = strategy.execute(textNode, doc);
+    // Since css becomes '', and empty string is safe,
+    // it should return an empty text node
+    expect(result).not.toBeNull();
+    expect(result === null || result === void 0 ? void 0 : result.textContent).toBe('');
+  });
+});

package/dist/collection/utils/sanitize/utils/serialize-fragment.js

@@ -0,0 +1,17 @@
+/**
+ * Serializes a DocumentFragment into HTML string.
+ *
+ * If fragment contains no element nodes,
+ * returns textContent to avoid encoding issues.
+ */
+/**
+ * @param {DocumentFragment} fragment - fragment to serialize.
+ * @param {Document} doc - document reference.
+ * @returns {string} - Serialized string
+ */
+export function serializeFragment(fragment, doc) {
+  var _a;
+  const container = doc.createElement('div');
+  container.appendChild(fragment);
+  return container.children.length === 0 ? (_a = container.textContent) !== null && _a !== void 0 ? _a : '' : container.innerHTML;
+}

package/dist/esm/{app-globals-2ac60ff5.js → app-globals-c0676920.js}

@@ -1,23 +1,19 @@
-import { F as FeatureFlag } from './feature-flag-controller-51659753.js';
-import { V as VegaLoader, a as VegaNotify, b as VegaThemeManager, c as VegaDialog, d as VegaEventManager, e as VegaZIndexManager, f as VegaSkeletonLoader, g as VegaRTETokenExtension, h as VegaRTEFunctionExtension } from './function-extension-e8c0e43e.js';
+import { F as FeatureFlag } from './feature-flag-controller-09ea7e87.js';
+import { V as VegaLoader, a as VegaNotify, b as VegaThemeManager, c as VegaEventManager, d as VegaZIndexManager, w as waitForVega, e as VegaSkeletonLoader, f as VegaTranslation, g as VegaRTETokenExtension, h as VegaRTELanguageExtension, i as VegaRTEFunctionExtension } from './token-extension-e33fd151.js';
 import { M as MapToComponentMethod, V as VegaSlimmer, s as setVegaLogLevel, G as GlobalSlimmersRegistry } from './global-slimmer-registry-17c4efd4.js';
-import { v as vegaEnvManager } from './vega-env-manager-8f8dc473.js';
-import { V as VegaIconManager } from './internal-icon-manager-f0486245.js';
-import './wait-for-vega-handler-c2c07ac3.js';
-import './ui-bb99c0c2.js';
-import { V as VegaInternalTranslation, a as VegaTranslation, s as staticTranslations } from './translation-96e5debd.js';
-import { V as VegaRTEContent } from './dto-renderer-manager-ee1a5864.js';
-import { v as vegaNonceManager, s as setVegaNonce } from './vega-nonce-manager-497e5eb5.js';
-import { V as VegaRTEPresetToolbarItems } from './code-block-8ee34ab6.js';
-import './type-guard-c65a227d.js';
+import { V as VegaDialog } from './vega-dialog-controller-bbb2fc52.js';
 import { T as TypographyUrls } from './typography-396de03f.js';
-import { V as ValidCreditCardNumberRule } from './valid-credit-card-number-rule-666c415d.js';
-import { w as waitForVega } from './index-51a7da7f.js';
-import { V as VegaRTELanguageExtension } from './language-extension-29bf8acd.js';
+import { V as VegaIconManager } from './icon-manager-539d7cf7.js';
+import { V as VegaInternalTranslation, s as staticTranslations } from './internal-translation-controller-911515f9.js';
+import { V as ValidCreditCardNumberRule } from './valid-credit-card-number-rule-22ce81db.js';
+import { v as vegaEnvManager } from './vega-env-manager-8f8dc473.js';
 import { U as UPDATE_TRANSLATION } from './static-subject-title-52f93124.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
 import { O as Observer } from './observer-3959f9dd.js';
 import { f as forceUpdate } from './index-090d31ca.js';
+import { V as VegaRTEContent } from './dto-renderer-manager-6fd22ab7.js';
+import { v as vegaNonceManager, s as setVegaNonce } from './vega-nonce-manager-497e5eb5.js';
+import { V as VegaRTEPresetToolbarItems } from './code-block-b6247a45.js';
 
 var __decorate$2 = (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;
@@ -356,7 +352,7 @@ function injectValidCreditCardNumberRuleIntoGlobal() {
 function initRuntimeMetricsTelemetryCollection() {
   globalThis.VegaEnvInfo = vegaEnvManager.getVegaEnv();
   // eslint-disable-next-line spellcheck/spell-checker
-  void import('./index-e9da316f.js').then((
+  void import('./index-bfc6dfa2.js').then((
   // eslint-disable-next-line spellcheck/spell-checker
   module) => {
     module['default']['init'](FeatureFlag);
@@ -398,7 +394,7 @@ function injectVegaRichTextEditorClassIntoGlobal() {
  * Inject VegaPublicValidationRules to global as a public api
  */
 function injectVegaPublicValidationRules() {
-  void import('./public-rules-724873f5.js').then((module) => {
+  void import('./public-rules-25cc3a39.js').then((module) => {
     Object.entries(module).forEach(([name, value]) => {
       globalThis[name] = value;
     });

package/dist/esm/breakpoints-56e5407b.js

@@ -0,0 +1,53 @@
+import { e as BreakpointKeys } from './ui-28fd4193.js';
+import { B as Breakpoints } from './breakpoints-d9faf11c.js';
+
+/**
+ * Get current breakpoint according current window size
+ *
+ * @returns {BreakpointsTokenType} - current breakpoint
+ */
+const getCurrentBreakpoint = () => {
+  let index = BreakpointKeys.length - 1;
+  const windowWidth = window.innerWidth;
+  for (index; index >= 0; index--) {
+    const breakpointKey = BreakpointKeys[index];
+    if (breakpointKey === 'default')
+      break;
+    if (windowWidth >= Breakpoints[breakpointKey])
+      return breakpointKey;
+  }
+  return 'default';
+};
+/**
+ * Completion breakponts, eg:
+ * {
+ *   default: 'size-12',
+ *   M: 'size-24'
+ * }
+ * it will convert to
+ * {
+ *   default: 'size-12',
+ *   S: 'size-12',
+ *   M: 'size-24',
+ *   L: 'size-24',
+ *   XL: 'size-24',
+ * }
+ *
+ * @typedef T generic type
+ * @param {ResponsiveType<ResponsiveScope>} breakpoints - responsive token
+ * @returns {ResponsiveType<T>} - completed breakpointss
+ */
+const createCompleteResponsiveMap = (breakpoints) => {
+  let responsiveScope;
+  BreakpointKeys.forEach((breakpoint) => {
+    if (Object.prototype.hasOwnProperty.call(breakpoints, breakpoint)) {
+      responsiveScope = breakpoints[breakpoint];
+    }
+    else {
+      breakpoints[breakpoint] = responsiveScope;
+    }
+  });
+  return breakpoints;
+};
+
+export { createCompleteResponsiveMap as c, getCurrentBreakpoint as g };

package/dist/esm/{child-nodes-event-prevent-slimmer-e662bee2.js → child-nodes-event-prevent-slimmer-649b9d30.js}

@@ -1,7 +1,7 @@
 import { c as MapToComponentField, M as MapToComponentMethod, V as VegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
-import { i as internalVegaEventManager, j as jqueryDelegatedStrategyController } from './internal-vega-event-manager-efb6786e.js';
+import { i as internalVegaEventManager, j as jqueryDelegatedStrategyController } from './internal-vega-event-manager-32a3d848.js';
 import { v as vegaEnvManager } from './vega-env-manager-8f8dc473.js';
-import { F as FeatureFlag } from './feature-flag-controller-51659753.js';
+import { F as FeatureFlag } from './feature-flag-controller-09ea7e87.js';
 
 var __decorate = (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;

package/dist/esm/{child-nodes-notify-observer-slimmer-b676cd2b.js → child-nodes-notify-observer-slimmer-541dd6a4.js}

@@ -1,7 +1,7 @@
 import { c as MapToComponentField, M as MapToComponentMethod, V as VegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
 import { O as Observer } from './observer-3959f9dd.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
-import { b as isParent } from './ui-bb99c0c2.js';
+import { b as isParent } from './ui-ee31416b.js';
 
 var __decorate = (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;

package/dist/esm/{code-block-8ee34ab6.js → code-block-b6247a45.js}

@@ -1,13 +1,13 @@
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
-import { d as domNodeSubjectFactory } from './dom-node-subject-observer-factory-064ee2b2.js';
-import { b as VegaInternalRichTextEditorFlushChanges, c as VegaInternalRichTextEditorSelectionRangeChange } from './vega-internal-event-id-4a06d705.js';
+import { d as domNodeSubjectFactory } from './dom-node-subject-observer-factory-82f346e3.js';
+import { a as VegaInternalRichTextEditorFlushChanges, b as VegaInternalRichTextEditorSelectionRangeChange } from './vega-internal-event-id-799d012e.js';
 import { c as camelToDashCase } from './string-a953eafc.js';
 import { L as LogUtility } from './global-slimmer-registry-17c4efd4.js';
-import { i as isNonNullable } from './type-guard-c65a227d.js';
-import { g as generateUUID } from './create-public-api-runtime-metrics-slimmer-bedf3a1e.js';
-import { V as VegaInternalThemeManager } from './dark-mode-style-controller-de88a117.js';
+import { i as isNonNullable } from './type-guard-f50e34d6.js';
+import { g as generateUUID } from './misc-9fdbcfbb.js';
+import { V as VegaInternalThemeManager } from './dark-mode-style-controller-82e5c1c6.js';
 import { c as cleanObject } from './object-66c37948.js';
-import { f as findParent } from './ui-bb99c0c2.js';
+import { f as findParent } from './ui-ee31416b.js';
 
 var InternalAnnotationTypeEnum;
 (function (InternalAnnotationTypeEnum) {
@@ -4361,4 +4361,4 @@ class RTECodeBlock extends RTEBlock {
 })();
 RTECodeBlock.CODE_BLOCK_PLACEHOLDER_CLASS_NAME = 'code-block-placeholder-element';
 
-export { TextColorAnnotationAction as $, ActionHandleStrategyRegistry as A, BlockUpdateTextStyleStrategy as B, CustomAttributeAnnotation as C, NodeTypeEnum as D, CommonAnnotation as E, AnnotationAction as F, ReplaceChildNodesAction as G, HorizontalAlignmentAnnotationAction as H, InsertChildrenAfterAction as I, SplitBlockWithNodeAction as J, BlockDeleteNodeContentStrategy as K, RemoveChildrenStrategy as L, ModifyContentAction as M, NodeAnnotation as N, RTE_TEXT_COLORS as O, RTE_DEFAULT_TEXT_COLOR as P, CodeLanguage as Q, RTEDTOClassManager$1 as R, SyncUpSelectionAction as S, TextStyleAnnotationAction as T, UpdateTextAction as U, VegaRTEPresetToolbarItems as V, LinkAnnotationAction as W, CommonAnnotationTypeEnum as X, UpdateCodeBlockAction as Y, ZERO_WIDTH_SPACE as Z, SelectionChangeAction as _, ActionHandlerInterceptorRegistry as a, RTECodeBlockNode as a0, BoldAnnotationAction as a1, ItalicAnnotationAction as a2, UnderlineAnnotationAction as a3, TextStyleAnnotation as a4, BoldAnnotation as a5, ClearFormattingAnnotationAction as a6, CodeAnnotationAction as a7, StrikethroughAnnotationAction as a8, IndentAnnotationAction as a9, RTETextNode as b, ModifyContentActionType as c, ActionHandleStrategy as d, RTETextBlock as e, RTEBlock as f, RTEAnnotationStyle as g, AppendChildrenAction as h, RTENode as i, InsertChildrenBeforeAction as j, InternalAnnotationTypeEnum as k, BlockUpdateHorizontalAlignmentStrategy as l, BlockInsertLineBreakStrategy as m, BlockInsertLineBreakWithBlocksStrategy as n, BlockSplitWithTextNodeStrategy as o, BlockReplaceNodesStrategy as p, BlockMergeNodesStrategy as q, RemoveChildrenAction as r, stateEntityRenderingRegistry as s, BlockAnnotation as t, BlockAnnotationTypeEnum as u, CustomStyleAnnotation as v, CustomClassAnnotation as w, RTECodeBlock as x, NodeAnnotationTypeEnum as y, RTEDecoratorNode as z };
+export { TextColorAnnotationAction as $, ActionHandleStrategyRegistry as A, BlockUpdateTextStyleStrategy as B, CustomAttributeAnnotation as C, NodeTypeEnum as D, CommonAnnotation as E, AnnotationAction as F, ReplaceChildNodesAction as G, HorizontalAlignmentAnnotationAction as H, InsertChildrenAfterAction as I, SplitBlockWithNodeAction as J, BlockDeleteNodeContentStrategy as K, RemoveChildrenStrategy as L, ModifyContentAction as M, NodeAnnotation as N, RTE_TEXT_COLORS as O, RTE_DEFAULT_TEXT_COLOR as P, CodeLanguage as Q, RTEDTOClassManager$1 as R, SyncUpSelectionAction as S, TextStyleAnnotationAction as T, UpdateTextAction as U, VegaRTEPresetToolbarItems as V, LinkAnnotationAction as W, CommonAnnotationTypeEnum as X, UpdateCodeBlockAction as Y, ZERO_WIDTH_SPACE as Z, SelectionChangeAction as _, ActionHandlerInterceptorRegistry as a, RTECodeBlockNode as a0, BoldAnnotationAction as a1, ItalicAnnotationAction as a2, UnderlineAnnotationAction as a3, TextStyleAnnotation as a4, BoldAnnotation as a5, ClearFormattingAnnotationAction as a6, CodeAnnotationAction as a7, StrikethroughAnnotationAction as a8, IndentAnnotationAction as a9, RTETextNode as b, RTEBlock as c, RTETextBlock as d, RTEAnnotationStyle as e, ActionHandleStrategy as f, AppendChildrenAction as g, RTENode as h, InsertChildrenBeforeAction as i, InternalAnnotationTypeEnum as j, ModifyContentActionType as k, BlockUpdateHorizontalAlignmentStrategy as l, BlockInsertLineBreakStrategy as m, BlockInsertLineBreakWithBlocksStrategy as n, BlockSplitWithTextNodeStrategy as o, BlockReplaceNodesStrategy as p, BlockMergeNodesStrategy as q, RemoveChildrenAction as r, stateEntityRenderingRegistry as s, BlockAnnotation as t, BlockAnnotationTypeEnum as u, CustomStyleAnnotation as v, CustomClassAnnotation as w, RTECodeBlock as x, NodeAnnotationTypeEnum as y, RTEDecoratorNode as z };

package/dist/esm/{component-global-style-slimmer-08046b38.js → component-global-style-slimmer-ac703085.js}

@@ -1,5 +1,6 @@
 import { c as MapToComponentField, M as MapToComponentMethod, V as VegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
 import { v as vegaNonceManager } from './vega-nonce-manager-497e5eb5.js';
+import { h as htmlSanitizer, s as styleSanitizeStrategy } from './index-3b327f29.js';
 
 var __decorate = (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;
@@ -59,7 +60,7 @@ class ComponentGlobalStyleSlimmer extends VegaSlimmer {
       // eslint-disable-next-line no-restricted-globals
       styleElement = document.createElement('style');
       styleElement.id = this.id;
-      styleElement.innerHTML = this.style;
+      styleElement.innerHTML = htmlSanitizer.sanitize(this.style, styleSanitizeStrategy);
       if (vegaNonceManager.nonce) {
         styleElement.setAttribute('nonce', vegaNonceManager.nonce);
       }

package/dist/esm/{component-usage-runtime-metrics-a84cc93e.js → component-usage-runtime-metrics-46020a03.js}

@@ -70,7 +70,7 @@ class VegaComponentUsageRuntimeMetricsSlimmer extends VegaSlimmer {
    */
   sendUsagePayloadToTelemetry() {
     // eslint-disable-next-line spellcheck/spell-checker
-    void import('./index-e9da316f.js').then((
+    void import('./index-bfc6dfa2.js').then((
     // eslint-disable-next-line spellcheck/spell-checker
     module) => {
       try {

package/dist/esm/{component-value-history-controller-slimmer.abstract-a61bf821.js → component-value-history-controller-slimmer.abstract-2bb8533d.js}

@@ -1,15 +1,15 @@
 import { M as MapToComponentMethod, V as VegaSlimmer, L as LogUtility, c as MapToComponentField } from './global-slimmer-registry-17c4efd4.js';
-import { a0 as RTECodeBlockNode, b as RTETextNode, Z as ZERO_WIDTH_SPACE, _ as SelectionChangeAction, k as InternalAnnotationTypeEnum, s as stateEntityRenderingRegistry, f as RTEBlock, i as RTENode, z as RTEDecoratorNode, x as RTECodeBlock } from './code-block-8ee34ab6.js';
+import { a0 as RTECodeBlockNode, b as RTETextNode, Z as ZERO_WIDTH_SPACE, _ as SelectionChangeAction, j as InternalAnnotationTypeEnum, s as stateEntityRenderingRegistry, c as RTEBlock, h as RTENode, z as RTEDecoratorNode, x as RTECodeBlock } from './code-block-b6247a45.js';
 import { d as debounce } from './timer-9321173b.js';
 import { g as getActiveElement } from './component-7d906393.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
-import { d as domNodeSubjectFactory, D as DomNodeSubjectObserverFactory } from './dom-node-subject-observer-factory-064ee2b2.js';
-import { c as VegaInternalRichTextEditorSelectionRangeChange, a as VegaInternalUpdateRTECursorPosition } from './vega-internal-event-id-4a06d705.js';
+import { d as domNodeSubjectFactory, D as DomNodeSubjectObserverFactory } from './dom-node-subject-observer-factory-82f346e3.js';
+import { b as VegaInternalRichTextEditorSelectionRangeChange, V as VegaInternalUpdateRTECursorPosition } from './vega-internal-event-id-799d012e.js';
 import { O as Observer } from './observer-3959f9dd.js';
-import { R as RTERange } from './range-5257c062.js';
+import { R as RTERange } from './range-663f44dc.js';
 import { S as SynchronizeTaskQueue } from './synchronize-task-queue-ac8acc3b.js';
-import { i as isHTMLElement } from './ui-bb99c0c2.js';
-import { K as KeyboardManagerSlimmer } from './keyboard-manager-slimmer-79c78ce8.js';
+import { i as isHTMLElement } from './ui-ee31416b.js';
+import { K as KeyboardManagerSlimmer } from './keyboard-manager-slimmer-9984d922.js';
 
 let processing = false;
 /**

package/dist/esm/{create-public-api-runtime-metrics-slimmer-bedf3a1e.js → create-public-api-runtime-metrics-slimmer-aaadaa08.js}

@@ -1,41 +1,6 @@
 import { C as ConsumerSlimmers, S as SlimmerConsumedBy, a as SlimmerMappedMethod, b as CurrentlyInvokedMethodName, V as VegaSlimmer, L as LogUtility } from './global-slimmer-registry-17c4efd4.js';
 import { c as createDynamicSlimmer } from './dynamic-slimmer-90b8af32.js';
-
-/**
- * returns a string that is a random UUID
- *
- * @returns {string} random UUID string.
- */
-const generateUUID = () => {
-  return (Date.now() + Math.floor(Math.random() * 10000)).toString();
-};
-/**
- * It returns true if the object is empty, and false if it's not.
- *
- * @param {unknown} object - The object to check if it's empty.
- * @returns {boolean} A function that takes an object as an argument and returns a boolean.
- */
-const isObjectEmpty = (object) => {
-  return object ? Object.keys(object).length === 0 : true;
-};
-/* istanbul ignore next */
-// eslint-disable-next-line @typescript-eslint/no-empty-function,@typescript-eslint/ban-types
-const AsyncFunction = (async () => { })['constructor'];
-/**
- * The function `isAsyncFunction` checks if a given value is an asynchronous function.
- *
- * @param {unknown} fn - The `fn` parameter is the function that we want to check if it is an asynchronous function.
- * @returns {boolean} a boolean value. It returns true if the input `fn` is an async function, and false otherwise.
- */
-const isAsyncFunction = (fn) => {
-  if (typeof fn === 'function' &&
-    (fn[Symbol.toStringTag] === 'AsyncFunction' || fn instanceof AsyncFunction === true)) {
-    return true;
-  }
-  else {
-    return false;
-  }
-};
+import { i as isObjectEmpty } from './misc-9fdbcfbb.js';
 
 /**
  * This decorator is used to re-define a field in a public API controller
@@ -136,7 +101,7 @@ class VegaPublicAPIRuntimeMetricsSlimmerBase extends VegaSlimmer {
       const publicAPIMetricsPayload = this.getPublicAPIMetricsPayload(args);
       if (publicAPIMetricsPayload) {
         // eslint-disable-next-line spellcheck/spell-checker
-        void import('./index-e9da316f.js').then((
+        void import('./index-bfc6dfa2.js').then((
         // eslint-disable-next-line spellcheck/spell-checker
         module) => {
           module['default']['emit']('publicAPIMetrics', publicAPIMetricsPayload);
@@ -200,4 +165,4 @@ function createPublicAPIRuntimeMetricsSlimmer(mapFromClass, watchMethodNames, in
   return createDynamicSlimmer(mapFromClass, VegaPublicAPIRuntimeMetricsSlimmerBase, [], methodsMap, [mapFromClass.name, initData]);
 }
 
-export { InjectVegaTelemetrySlimmer as I, isObjectEmpty as a, createPublicAPIRuntimeMetricsSlimmer as c, generateUUID as g, isAsyncFunction as i };
+export { InjectVegaTelemetrySlimmer as I, createPublicAPIRuntimeMetricsSlimmer as c };