@heartlandone/vega 2.88.0 → 2.90.0

package/dist/esm/{token-extension-30011dc4.js → token-extension-6cb7dcb2.js}

@@ -1,31 +1,30 @@
 import { g as generateUUID } from './misc-9fdbcfbb.js';
-import { a as arrayToClassString, g as getDeviceType, D as DeviceType, f as findParent, r as rgbToHex } from './ui-64815a12.js';
+import { a as arrayToClassString, g as getDeviceType, D as DeviceType, f as findParent, r as rgbToHex } from './ui-d73f756a.js';
 import { L as LogUtility, I as InjectVegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
 import { I as InjectVegaTelemetrySlimmer, c as createPublicAPIRuntimeMetricsSlimmer } from './create-public-api-runtime-metrics-slimmer-da6615bf.js';
 import { I as InternalVegaZIndexManager } from './internal-vega-z-index-manager-7d2b54c3.js';
 import { c as createDynamicSlimmer } from './dynamic-slimmer-90b8af32.js';
 import { P as PageResizeObserverSlimmer } from './page-resize-observer-slimmer-e24d36c5.js';
-import { i as internalVegaEventManager } from './internal-vega-event-manager-dc4c3a37.js';
-import { V as VegaInternalTranslation } from './internal-translation-controller-0b9589d0.js';
-import { R as RTEDTOActionStrategyManager, E as ElementToDTOClassStrategyManager, h as htmlElementToAnnotationGenerator, U as UpdateCursorPositionAction, V as VegaRTEContent, B as BlockToRTEBlockStrategyAbstract, a as ElementToDTOStrategy, I as InsertNewParagraphAction, b as RTEImageBlock, c as InsertChildrenBeforeStrategy, P as PasteContentStrategy, A as AnnotationGeneratorStrategyAbstract, d as RTEListItemBlock } from './content-state-9bf85e00.js';
-import { s as stateEntityRenderingRegistry, A as ActionHandleStrategyRegistry, a as ActionHandlerInterceptorRegistry, R as RTEFilterStylesStrategyRegistry, b as RTEDTOClassManager, M as ModifyContentAction, c as RTETextNode, d as RTEBlock, e as RTETextBlock, f as RTEAnnotationStyle, g as ActionHandleStrategy, I as InsertChildrenAfterAction, h as AppendChildrenAction, i as RTENode, j as InsertChildrenBeforeAction, k as InternalAnnotationTypeEnum, l as ModifyContentActionType, B as BlockAnnotation, m as AnnotationAction, n as RemoveChildrenAction, C as CommonAnnotationTypeEnum, o as CustomAttributeAnnotation, p as RTEFilterStylesStrategy, U as UpdateTextAction, N as NodeAnnotationTypeEnum, q as RTECodeBlock, r as CustomStyleAnnotation } from './code-block-6261a99d.js';
-import { i as isNonNullable } from './type-guard-b18807dc.js';
-import { R as RTEDTORendererManager } from './dto-renderer-manager-abc7eb5f.js';
-import { V as VegaRTEBaseRenderer } from './base-renderer-101f6d04.js';
+import { i as internalVegaEventManager } from './internal-vega-event-manager-a9758b6e.js';
+import { V as VegaInternalTranslation } from './internal-translation-controller-653bd7e3.js';
+import { U as UpdateCursorPositionAction, V as VegaRTEContent, B as BlockToRTEBlockStrategyAbstract, E as ElementToDTOStrategy, h as htmlElementToAnnotationGenerator, I as InsertNewParagraphAction, R as RTEImageBlock, a as InsertChildrenBeforeStrategy, P as PasteContentStrategy, A as AnnotationGeneratorStrategyAbstract, b as RTEListItemBlock } from './content-state-d59b4560.js';
+import { R as RTEExtensionContextManager, a as VegaRTEExtensionRenderer, b as VegaRTEExtension } from './link-extension-be164793.js';
+import { M as ModifyContentAction, A as ActionHandleStrategyRegistry, R as RTETextNode, a as RTEBlock, b as RTETextBlock, c as RTEAnnotationStyle, d as ActionHandleStrategy, I as InsertChildrenAfterAction, e as AppendChildrenAction, f as RTENode, s as stateEntityRenderingRegistry, g as InsertChildrenBeforeAction, h as InternalAnnotationTypeEnum, i as ModifyContentActionType, B as BlockAnnotation, j as AnnotationAction, k as RemoveChildrenAction, C as CommonAnnotationTypeEnum, l as CustomAttributeAnnotation, m as RTEDTOClassManager, n as RTEFilterStylesStrategy, o as RTEDecoratorNode, S as SplitBlockWithNodeAction, U as UpdateTextAction, N as NodeAnnotationTypeEnum, p as RTECodeBlock, q as CustomStyleAnnotation, r as RTEFilterStylesStrategyRegistry } from './code-block-9a17d89b.js';
+import { i as isNonNullable } from './type-guard-fd1f4760.js';
 import { V as VegaInternalIconManager } from './internal-icon-manager-276f968f.js';
 import { v as vegaNonceManager } from './vega-nonce-manager-497e5eb5.js';
-import { D as DomNodeSubjectObserverFactory, d as domNodeSubjectFactory } from './dom-node-subject-observer-factory-3897e95b.js';
-import { V as VegaDropdownClick, a as VegaClick, b as VegaPopoverHide, c as VegaPopoverShow } from './vega-event-id-20494454.js';
-import { R as RTETableExtensionAnnotationTypeEnum, a as RTE_TABLE_HEAD_DEFAULT_BACKGROUND_COLOR, S as SettingEventHandler, T as TableSettingType, b as RTETableAnnotation, c as RTETableCellAnnotation, d as RTETableHeadCellBlock, e as RowOperationEventHandler, C as ColumnOperationEventHandler, M as MergeCellsOperationEventHandler, f as SplitCellOperationEventHandler, g as RTETableColorManager, h as RTETableBlock, i as generateTableBody, j as RTETableCellBlock, k as RTETableHeadBlock, l as RTETableBodyBlock, m as getParentBlockByType, n as RTETableHeadCellAnnotation, o as TableColumnStrategy, p as getAllTableRows, q as buildTableGrid, s as setSpanAttributes, r as findCellBlockById, t as getDefaultCellBlockTemplate, I as InsertTableColumnDirection, u as buildCellStartColumnMap, v as getTableColumnCount, w as getFirstNode, x as getCellSpan, y as createNewCell, z as MergeCellsOperationType, A as RTETableRowBlock, B as getActualColumnPosition, D as InsertTableRowDirection, E as RTE_TABLE_DEFAULT_COLORS, F as INSERT_TABLE_ROW_INTO_DIFFERENT_SECTION, G as INSERT_TABLE_ROW_INTO_SAME_SECTION, H as DELETE_TABLE_ROW, J as TOGGLE_HEADER_ROW, K as INSERT_TABLE_COLUMN, L as DELETE_TABLE_COLUMN, N as TOGGLE_HEADER_TABLE_COLUMN, O as ToggleHeaderTableColumnStrategy, P as SPLIT_TABLE_CELL, Q as REPLACE_TABLE_CELL, U as SPLIT_CELL_HORIZONTALLY, W as SPLIT_CELL_VERTICALLY, X as SELECT_TABLE_COLUMN, Y as MERGE_CELLS } from './split-cell-operation-1d114aa3.js';
+import { D as DomNodeSubjectObserverFactory, d as domNodeSubjectFactory } from './dom-node-subject-observer-factory-ddff8662.js';
+import { V as VegaDropdownClick, a as VegaClick, b as VegaPopoverHide, c as VegaPopoverShow } from './vega-event-id-92848bf5.js';
+import { R as RTETableExtensionAnnotationTypeEnum, a as RTE_TABLE_HEAD_DEFAULT_BACKGROUND_COLOR, S as SettingEventHandler, T as TableSettingType, b as RTETableAnnotation, c as RTETableCellAnnotation, d as RTETableHeadCellBlock, e as RowOperationEventHandler, C as ColumnOperationEventHandler, M as MergeCellsOperationEventHandler, f as SplitCellOperationEventHandler, g as RTETableColorManager, h as RTETableBlock, i as generateTableBody, j as RTETableCellBlock, k as RTETableHeadBlock, l as RTETableBodyBlock, m as getParentBlockByType, n as RTETableHeadCellAnnotation, o as TableColumnStrategy, p as getAllTableRows, q as buildTableGrid, s as setSpanAttributes, r as findCellBlockById, t as getDefaultCellBlockTemplate, I as InsertTableColumnDirection, u as buildCellStartColumnMap, v as getTableColumnCount, w as getFirstNode, x as getCellSpan, y as createNewCell, z as MergeCellsOperationType, A as RTETableRowBlock, B as getActualColumnPosition, D as InsertTableRowDirection, E as RTE_TABLE_DEFAULT_COLORS, F as INSERT_TABLE_ROW_INTO_DIFFERENT_SECTION, G as INSERT_TABLE_ROW_INTO_SAME_SECTION, H as DELETE_TABLE_ROW, J as TOGGLE_HEADER_ROW, K as INSERT_TABLE_COLUMN, L as DELETE_TABLE_COLUMN, N as TOGGLE_HEADER_TABLE_COLUMN, O as ToggleHeaderTableColumnStrategy, P as SPLIT_TABLE_CELL, Q as REPLACE_TABLE_CELL, U as SPLIT_CELL_HORIZONTALLY, W as SPLIT_CELL_VERTICALLY, X as SELECT_TABLE_COLUMN, Y as MERGE_CELLS } from './split-cell-operation-8251d2a1.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
 import { V as VegaInternalRTEExtensionTableCellsSelectionAnchor, a as VegaInternalPopoverUpdateTarget, b as VegaInternalRTEExtensionTableCellSelectionChange } from './vega-internal-event-id-913e8be6.js';
 import { r as remoteInvocationRegistry } from './remote-invocation-registry-d69245c2.js';
-import { V as VegaInternalThemeManager } from './dark-mode-style-controller-fcda24ec.js';
+import { V as VegaInternalThemeManager } from './dark-mode-style-controller-ca5afd2d.js';
 import { t as tryGetDocument } from './try-get-document-bef0f526.js';
 import { p as parseToPixelString } from './pixel-f32c07ce.js';
 import { c as cleanObject } from './object-0c277f57.js';
 import { d as debounce } from './timer-9321173b.js';
-import { R as ReplaceSelectedTextAction } from './replace-selected-text-action-a45bee4b.js';
+import { R as ReplaceSelectedTextAction } from './replace-selected-text-action-1abc5200.js';
 
 const VegaLoaderRuntimeMetricsPayloadDefinition = [
   {
@@ -1048,393 +1047,6 @@ __decorate([
 ], TranslationController.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
 const VegaTranslation = new TranslationController();
 
-/**
- * Manager for storing and retrieving the extension context associated with each rich text editor host element.
- *
- * @todo Currently, there are three types of contexts in RTE: toolbar render context, extension context, and DTO render context. The second and third types are bound to the extension context via host props. We are considering optimizing these three types of contexts to make the program more flexible and easier to maintain.
- */
-class RTEExtensionContextManager {
-  constructor() {
-    this.extensionContextMap = new WeakMap();
-  }
-  /**
-   * Store the extension context for the given rich text editor host element.
-   *
-   * @param {RTEExtensionContext} context - The extension context to store.
-   */
-  updateExtensionContext(context) {
-    if (context && context.host) {
-      let newContext = context;
-      const existingContext = this.extensionContextMap.get(context.host);
-      // If there is already an existing context for the host, merge the new context with the existing one to avoid overwriting any properties that are not included in the new context.
-      if (existingContext) {
-        newContext = Object.assign(Object.assign({}, existingContext), context);
-      }
-      this.extensionContextMap.set(context.host, newContext);
-    }
-  }
-  /**
-   * Get the extension context for the given rich text editor host element.
-   *
-   * @typedef HTMLVegaRichTextEditorElement - The type definition for the rich text editor host element.
-   * @param {Nullable<HTMLVegaRichTextEditorElement>} el - The host rich text editor element.
-   * @returns {Nullable<RTEExtensionContext>} - The extension context associated with the host.
-   */
-  getExtensionContext(el) {
-    return el ? this.extensionContextMap.get(el) : null;
-  }
-}
-const RTEExtensionContextManager$1 = new RTEExtensionContextManager();
-
-/**
- * Base renderer for Vega Rich Text Editor.
- */
-class VegaRTEExtensionRenderer extends VegaRTEBaseRenderer {
-  /**
-   * Returns the styles to be injected into the RTE scope.
-   * Override this method to provide custom styles for the custom blocks or nodes.
-   *
-   * @returns {string} - The styles as a string.
-   */
-  injectRTEScopeStyles() {
-    return '';
-  }
-  /**
-   * Renders the given data as a DOM element.
-   *
-   * @param {RTEBlock | RTENode} renderData - The data to render, which can be a block or a node.
-   * @param {RTERenderContext} rteContext - The rte editor context.
-   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
-   * @returns {VegaRTERenderResult} - The rendered DOM element.
-   */
-  render(renderData, rteContext, createElement) {
-    var _a;
-    const element = this.doRender(createElement, renderData, rteContext);
-    this.fallbackRegisterRef(element, renderData);
-    this.appendChildren(((_a = element.childrenContainerGetter) === null || _a === void 0 ? void 0 : _a.call(element)) || element, renderData, rteContext, createElement);
-    return element;
-  }
-  /**
-   * Register the reference of the element in the rendering registry.
-   *
-   * @param {RTEBlock | RTENode} renderData - The data to register with the element.
-   * @returns {VegaRTEUseRef} - The function to register the element.
-   */
-  useRef(renderData) {
-    renderData[VegaRTEExtensionRenderer.REGISTER_REF_FLAG] = true;
-    return function (element) {
-      if (element) {
-        stateEntityRenderingRegistry.register(element, renderData);
-      }
-    };
-  }
-  /**
-   * Get a registered renderer by its key.
-   *
-   * @param {string} key - The key of the renderer.
-   * @returns {Nullable<BaseRenderer>} - The registered renderer or null if not found.
-   */
-  getDTORenderer(key) {
-    return RTEDTORendererManager.getRTERenderer(key);
-  }
-  /**
-   * Get the extension context for the given rich text editor host element.
-   *
-   * @typedef HTMLVegaRichTextEditorElement - The type definition for the rich text editor host element.
-   * @param {HTMLVegaRichTextEditorElement} el - The host rich text editor element.
-   * @returns {Nullable<RTEExtensionContext>} - The extension context associated with the host.
-   */
-  getExtensionContext(el) {
-    return RTEExtensionContextManager$1.getExtensionContext(el);
-  }
-  /**
-   * Auto render the block children if the block element is not exist
-   *
-   * @param {VegaRTERenderResult} parentElement - The parent element to append children to.
-   * @param {RTEBlock | RTENode} renderData - The data to render children for.
-   * @param {RTERenderContext} rteContext - The render context.
-   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
-   */
-  appendChildren(parentElement, renderData, rteContext, createElement) {
-    if (Array.isArray(renderData['children']) &&
-      renderData['children'].length &&
-      !parentElement['$children$']) {
-      parentElement['$children$'] = renderData['children']
-        .map((child) => {
-        return this.renderChildren(child, rteContext, createElement);
-      })
-        .filter(isNonNullable);
-    }
-  }
-  /**
-   * Render the children node.
-   *
-   * @param {RTENode | RTEBlock} renderData - The node to render children for.
-   * @param {RTERenderContext} rteContext - The render context.
-   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
-   * @returns {Nullable<VegaRTERenderResult>} - The rendered DOM element.
-   */
-  renderChildren(renderData, rteContext, createElement) {
-    const renderer = this.getDTORenderer(renderData.type);
-    if (renderer) {
-      return renderer.render(renderData, rteContext, createElement);
-    }
-  }
-  /**
-   * Fallback register reference for the element.
-   *
-   * @param {VegaRTERenderResult} element - The rendered DOM element.
-   * @param {RTEBlock | RTENode} renderData - The data to register with the element.
-   */
-  fallbackRegisterRef(element, renderData) {
-    if (!renderData[VegaRTEExtensionRenderer.REGISTER_REF_FLAG] &&
-      element['$attrs$'] &&
-      !element['$attrs$']['ref']) {
-      // eslint-disable-next-line jsdoc/require-jsdoc
-      element['$attrs$']['ref'] = this.useRef(renderData);
-    }
-  }
-}
-VegaRTEExtensionRenderer.REGISTER_REF_FLAG = '__registeredRef__';
-
-const patchedBlockClasses = new WeakSet();
-const annotationHandlersByClass = new WeakMap();
-/**
- * Abstract class for Vega Rich Text Editor extensions.
- */
-class VegaRTEExtension {
-  constructor() {
-    /**
-     * The context of the RTE extension, which may include references to the host editor and other relevant information.
-     */
-    this.extensionContext = null;
-    this.hasCustomStylesRenderers = new Set();
-  }
-  /**
-   * Registers an action handle strategy for a specific node or block class.
-   *
-   * @param {string} nodeOrBlockClassName - The name of the node or block class.
-   * @param {string} actionType - The type of the action.
-   * @param {ActionHandleStrategy<ModifyContentAction | AnnotationAction, RTENode | RTEBlock | VegaRTEContent>} strategy - The strategy to register.
-   */
-  static registerActionHandleStrategy(nodeOrBlockClassName, actionType, strategy) {
-    ActionHandleStrategyRegistry.register(actionType, nodeOrBlockClassName, strategy);
-  }
-  /**
-   * Registers an action handler interceptor for a specific node or block class.
-   *
-   * @param {string} nodeOrBlockClassName - The name of the node or block class.
-   * @param {string} actionType - The type of the action.
-   * @param {ActionHandlerInterceptor<ModifyContentAction, RTENode | RTEBlock | VegaRTEContent>} strategy - The interceptor to register.
-   */
-  static registerActionHandlerInterceptor(nodeOrBlockClassName, actionType, strategy) {
-    ActionHandlerInterceptorRegistry.register(actionType, nodeOrBlockClassName, strategy);
-  }
-  /**
-   * Registers a filter styles strategy for a specific block or node class.
-   *
-   * @param {string} blockOrNodeClassName - The name of the block or node class.
-   * @param {RTEFilterStylesStrategy} strategy - The filter styles strategy to register.
-   */
-  static registerFilterStylesStrategy(blockOrNodeClassName, strategy) {
-    RTEFilterStylesStrategyRegistry.register(blockOrNodeClassName, strategy);
-  }
-  /**
-   * Attach a custom JSON annotation handler to a block DTO class's static `from` flow.
-   *
-   * This is a reusable extension point: any extension can register a handler for an
-   * annotation key and transform the value into block annotations during JSON parsing.
-   *
-   * Safe to call multiple times per class/key/handler — duplicate registrations are no-ops.
-   *
-   * @param {BlockClassWithFrom} BlockClass - Block DTO class to patch.
-   * @param {string} annotationKey - JSON annotation key to read from `block.annotations`.
-   * @param {AnnotationFromJsonHandler} handler - Handler that applies annotation logic to the instance.
-   */
-  static attachAnnotationFromJson(BlockClass, annotationKey, handler) {
-    var _a, _b;
-    const handlerMap = (_a = annotationHandlersByClass.get(BlockClass)) !== null && _a !== void 0 ? _a : new Map();
-    const handlers = (_b = handlerMap.get(annotationKey)) !== null && _b !== void 0 ? _b : new Set();
-    handlers.add(handler);
-    handlerMap.set(annotationKey, handlers);
-    annotationHandlersByClass.set(BlockClass, handlerMap);
-    if (patchedBlockClasses.has(BlockClass)) {
-      return;
-    }
-    patchedBlockClasses.add(BlockClass);
-    const originalFrom = BlockClass.from.bind(BlockClass);
-    /**
-     * Wrapped static `from` that preserves original behavior and then applies
-     * all registered annotation-from-json handlers for this BlockClass.
-     *
-     * @param {VegaRTEBlockBase} block - Raw JSON block payload.
-     * @param {VegaRTETransformOptions} [options] - Optional transform options.
-     * @returns {RTEBlock} The transformed block instance.
-     */
-    BlockClass.from = function patchedFrom(block, options) {
-      const instance = originalFrom(block, options);
-      const annotations = block.annotations;
-      const currentHandlerMap = annotationHandlersByClass.get(BlockClass);
-      if (annotations && currentHandlerMap) {
-        currentHandlerMap.forEach((registeredHandlers, key) => {
-          const value = annotations[key];
-          registeredHandlers.forEach((registeredHandler) => {
-            registeredHandler(instance, value, block, options);
-          });
-        });
-      }
-      return instance;
-    };
-  }
-  /**
-   * Lifecycle hook called by the rich text editor before the first render
-   * (during `componentWillLoad`).  Override this method to perform per-host
-   * pre-render setup — for example, registering a host-specific toolbar button
-   * renderer via {@link registerToolbarButtonRenderer} so that each editor on
-   * the page gets its own isolated renderer instance.
-   *
-   * The default implementation is a no-op; subclasses may override selectively.
-   *
-   * @typedef HTMLVegaRichTextEditorElement - The type of the host rich text editor element.
-   * @param {HTMLVegaRichTextEditorElement} host - The host rich text editor element that is about to load.
-   */
-  prepareBeforeLoad(host) {
-  }
-  /**
-   * Initializes the RTE extension with the provided context.
-   *
-   * @param {RTEExtensionContext} context - The context of the RTE extension.
-   */
-  initialExtensionAfterLoad(context) {
-    this.extensionContext = context;
-    RTEExtensionContextManager$1.updateExtensionContext(context);
-  }
-  /**
-   * Callback method invoked when the extension is destroyed.
-   * Override this method to perform any necessary cleanup.
-   */
-  destroyExtension() {
-  }
-  /**
-   * Collect custom styles for the extension renderers.
-   * If custom nodes have special styles, override this method to provide the styles.
-   *
-   * @returns {string} - The custom styles as a string.
-   */
-  collectExtensionRendererStyles() {
-    let styles = '';
-    if (this.hasCustomStylesRenderers.size > 0) {
-      this.hasCustomStylesRenderers.forEach((renderer) => {
-        styles += `${renderer.injectRTEScopeStyles()}\n`;
-      });
-    }
-    return styles;
-  }
-  /**
-   * Register a node type with the extension.
-   *
-   * @param {string} type - The type of the node or block. The type should be a string that uniquely identifies the node or block.
-   * @param {ClassType<RTEBlock | RTENode>} DTOClass - The DTO class to register.
-   */
-  registerNode(type, DTOClass) {
-    RTEDTOClassManager.registerRTEDTOClass(type, DTOClass);
-  }
-  /**
-   * Register a renderer for a node type with the extension.
-   *
-   * @param {string} type - The type of the node or block. The type should be a string that uniquely identifies the node or block.
-   * @param {BaseRenderer} renderer - The renderer to register.
-   */
-  registerRenderer(type, renderer) {
-    RTEDTORendererManager.registerRTEDTORenderer(type, renderer);
-    if (renderer instanceof VegaRTEExtensionRenderer && renderer.injectRTEScopeStyles()) {
-      this.hasCustomStylesRenderers.add(renderer);
-    }
-  }
-  /**
-   * Register a toolbar button renderer for the extension.
-   * When a `host` element is provided the renderer is registered in the per-host map
-   * (via {@link RTEDTORendererManager#registerRTEToolbarButtonRendererForHost}), giving
-   * that host an isolated renderer instance that takes precedence over the global singleton.
-   * Omit `host` to fall back to the global registration (backwards-compatible default).
-   *
-   * @param {string} type - The type of the toolbar button.
-   * @param {VegaRTEToolbarButtonRenderer} renderer - The renderer to register.
-   * @param {HTMLVegaRichTextEditorElement} [host] - Optional host element for per-host isolation.
-   */
-  registerToolbarButtonRenderer(type, renderer, host) {
-    if (host) {
-      RTEDTORendererManager.registerRTEToolbarButtonRendererForHost(host, type, renderer);
-    }
-    else {
-      RTEDTORendererManager.registerRTEToolbarButtonRenderer(type, renderer);
-    }
-  }
-  /**
-   * This is a helper method that utilizes RTEUtils to register common strategies.
-   * Call the method with the class name of the block to make it support basic strategies like:
-   * - Delete children
-   * - Append the children
-   * - Delete the block children content
-   *
-   * @param {string} blockClassName - The class name of the block to register strategies for.
-   */
-  registerBlockBasicStrategies(blockClassName) {
-    RTEDTOActionStrategyManager.registerBlockBasicStrategies(blockClassName);
-  }
-  /**
-   * Unregister a strategy for a specific action type and block class if not need.
-   *
-   * @param {string} actionType - The special action type or the action class name.
-   * @param {string} blockClassName - The class name of the block to unregister the strategy for.
-   */
-  unRegisterStrategy(actionType, blockClassName) {
-    ActionHandleStrategyRegistry.unregister(actionType, blockClassName);
-  }
-  /**
-   * Unregister a strategy for a specific action type and block class if not need.
-   *
-   * @param {string} actionType - The special action type or the action class name.
-   * @param {string} blockClassName - The class name of the block to unregister the strategy for.
-   * @param {ActionHandlerInterceptor<ModifyContentAction, RTENode | RTEBlock | VegaRTEContent>} strategy - The interceptor to unregister.
-   */
-  unRegisterInterceptor(actionType, blockClassName, strategy) {
-    ActionHandlerInterceptorRegistry.unregister(actionType, blockClassName, strategy);
-  }
-  /**
-   * Register an element to block DTO class strategy.
-   *
-   * @param {ElementToDTOStrategy} strategy - The strategy to register.
-   */
-  registerElementToBlockDTOClassStrategy(strategy) {
-    ElementToDTOClassStrategyManager.registerElementToBlockStrategy(strategy);
-  }
-  /**
-   * Register an element to node DTO class strategy.
-   *
-   * @param {ElementToDTOStrategy} strategy - The strategy to register.
-   */
-  registerElementToNodeDTOClassStrategy(strategy) {
-    ElementToDTOClassStrategyManager.registerElementToNodeStrategy(strategy);
-  }
-  /**
-   * Get the registered element to node DTO class strategies.
-   *
-   * @returns {ElementToDTOStrategy[]} - The registered element to node DTO class strategies.
-   */
-  getElementToNodeDTOClassStrategies() {
-    return ElementToDTOClassStrategyManager.getElementToNodeStrategies();
-  }
-  /**
-   * Register a custom annotation handler for HTML to DTO conversion.
-   *
-   * @param {AnnotationGeneratorStrategyAbstract} handler - The annotation handler to register.
-   */
-  registerAnnotationHandler(handler) {
-    htmlElementToAnnotationGenerator.registerHandler(handler);
-  }
-}
-
 /**
  * Base class for rendering extension toolbar button in the rich text editor.
  * The renderer provides common functionalities for rendering toolbar buttons, including:
@@ -1469,7 +1081,7 @@ class VegaRTEToolbarButtonRenderer {
    * @returns {Nullable<RTEExtensionContext>} - The extension context associated with the host.
    */
   getExtensionContext(el) {
-    return RTEExtensionContextManager$1.getExtensionContext(el);
+    return RTEExtensionContextManager.getExtensionContext(el);
   }
   /**
    * Renders a dropdown component with the specified properties and children.
@@ -1496,9 +1108,10 @@ class VegaRTEToolbarButtonRenderer {
    *
    * @param {VegaRTECreateElementFunction} h - Create element function.
    * @param {(RTEDropdownListItem | RTEDropdownListGroup)[]} itemList - The list of dropdown items.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
    * @returns {VegaRTERenderResult} - The render result for the dropdown list.
    */
-  renderDropdownListTemplate(h, itemList) {
+  renderDropdownListTemplate(h, itemList, editorContext) {
     return h('div', {
       slot: 'items',
       onMouseDown: this.preventDefault,
@@ -1513,8 +1126,8 @@ class VegaRTEToolbarButtonRenderer {
       h('style', { nonce: vegaNonceManager.nonce }, '.rte-dropdown-list vega-dropdown-group vega-dropdown-group { padding-left: 4px }'),
       ...itemList.map((item) => {
         return 'children' in item
-          ? this.renderDropdownGroup(h, item)
-          : this.renderDropdownItem(h, item);
+          ? this.renderDropdownGroup(h, item, editorContext)
+          : this.renderDropdownItem(h, item, editorContext);
       }),
     ]);
   }
@@ -1523,32 +1136,34 @@ class VegaRTEToolbarButtonRenderer {
    *
    * @param {VegaRTECreateElementFunction} h - Create element function.
    * @param {RTEDropdownListItem} item - The dropdown item.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
    * @returns {VegaRTERenderResult} - The render result for the dropdown item.
    */
-  renderDropdownItem(h, item) {
+  renderDropdownItem(h, item, editorContext) {
     return h('vega-dropdown-item', {
       key: item.key,
       itemKey: item.key,
-      label: item.label,
+      label: editorContext.translation.t(item.label),
       prefixIcon: item.icon,
     });
   }
   /**
-   * Renders a dropdown item for the toolbar button.
+   * Renders a dropdown group for the toolbar button.
    *
    * @param {VegaRTECreateElementFunction} h - Create element function.
    * @param {RTEDropdownListGroup} item - The dropdown group.
-   * @returns {VegaRTERenderResult} - The render result for the dropdown item.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @returns {VegaRTERenderResult} - The render result for the dropdown group.
    */
-  renderDropdownGroup(h, item) {
+  renderDropdownGroup(h, item, editorContext) {
     return h('vega-dropdown-group', {
       key: item.key,
-      label: item.label,
+      label: editorContext.translation.t(item.label),
       divide: false,
     }, item.children.map((child) => {
       return 'children' in child
-        ? this.renderDropdownGroup(h, child)
-        : this.renderDropdownItem(h, child);
+        ? this.renderDropdownGroup(h, child, editorContext)
+        : this.renderDropdownItem(h, child, editorContext);
     }));
   }
   /**
@@ -1607,7 +1222,7 @@ class VegaRTEToolbarButtonRenderer {
       return h('vega-font', {
         variant: 'font-field-label-sm',
         color: isDisabled ? 'text-disabled' : 'text-primary',
-      }, label);
+      }, editorContext.translation.t(label));
     }
     return null;
   }
@@ -1789,7 +1404,7 @@ class RTETokenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
         showArrowIcon: true,
         tooltip: { text: 'Insert token' },
       }),
-      this.renderDropdownListTemplate(createElement, this.tokenList),
+      this.renderDropdownListTemplate(createElement, this.tokenList, editorContext),
     ]);
   }
   /**
@@ -1971,13 +1586,8 @@ class RTETokenNodeRenderer extends VegaRTEExtensionRenderer {
 
 /**
  * Toolbar button renderer for language selection in Vega Rich Text Editor.
- *
- * Each {@link HTMLVegaRichTextEditorElement} that uses a language extension receives its
- * **own** instance of this renderer, registered in the per-host map inside
- * {@link RTEDTORendererManager} via {@link VegaRTEExtension#prepareBeforeLoad}.  Because
- * every editor has a dedicated renderer, all state (label DOM ref, selected language, and
- * the language-change callback) is held in plain instance fields — no WeakMaps or shared
- * singletons are required.
+ * Each editor host gets its own instance, registered via
+ * {@link VegaRTEExtension#prepareBeforeLoad}, so renderer state is held in plain fields.
  */
 class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
   constructor(languageList, languageChangeCallback, selectedLanguage = '') {
@@ -1986,10 +1596,9 @@ class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     this.languageChangeCallback = null;
     this.selectedLanguage = '';
     this.labelRef = null;
+    this.translation = null;
     /**
-     * Handles the language selection event.
-     * Because each editor has its own renderer instance, the language-change callback
-     * is stored directly on this instance — no indirect context lookup is needed.
+     * Handles the language selection event from the dropdown.
      *
      * @param {string} itemKey - The key of the selected language item.
      */
@@ -2004,15 +1613,18 @@ class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     this.selectedLanguage = selectedLanguage;
   }
   /**
-   * Updates the selected language and refreshes the button label text in-place,
-   * without requiring a full re-render of the toolbar.
+   * Updates the selected language and refreshes the button label text in-place
+   * without a full toolbar re-render. The label is routed through the translation
+   * helper so localization is preserved on imperative updates.
    *
    * @param {string} language The language key to set as selected.
    */
   setSelectedLanguage(language) {
+    var _a;
     this.selectedLanguage = language;
-    if (this.labelRef) {
-      this.labelRef.textContent = this.getLanguageLabelByKey(language);
+    if (((_a = this.labelRef) === null || _a === void 0 ? void 0 : _a.firstChild) && this.translation) {
+      const label = this.getLanguageLabelByKey(language);
+      this.labelRef.firstChild.nodeValue = this.translation.t(label);
     }
   }
   /**
@@ -2027,7 +1639,8 @@ class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
    * @inheritDoc
    */
   render(createElement, editorContext) {
-    return this.renderDropdown(createElement, editorContext, { source: this.languageList }, [
+    const translatedSource = this.languageList.map((item) => this.translateDropdownEntry(item, editorContext));
+    return this.renderDropdown(createElement, editorContext, { source: translatedSource }, [
       this.renderButton(createElement, editorContext, {
         label: this.getLanguageLabelByKey(this.selectedLanguage),
         showArrowIcon: true,
@@ -2042,6 +1655,7 @@ class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
    * @inheritDoc
    */
   renderButtonLabel(h, editorContext, label) {
+    this.translation = editorContext.translation;
     const isDisabled = this.isDisabled(editorContext);
     return h('vega-font', {
       variant: 'font-field-label-sm',
@@ -2050,7 +1664,7 @@ class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
       ref: (el) => {
         this.labelRef = el;
       },
-    }, label);
+    }, editorContext.translation.t(label));
   }
   /* istanbul ignore next */
   /**
@@ -2071,6 +1685,21 @@ class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
     const language = this.getListItemByKey(this.languageList, key);
     return (_a = language === null || language === void 0 ? void 0 : language.label) !== null && _a !== void 0 ? _a : 'Select Language';
   }
+  /**
+   * Recursively translates labels in a dropdown entry so that nested
+   * {@link RTEDropdownListGroup} children are also localized.
+   *
+   * @param {RTEDropdownListItem | RTEDropdownListGroup} entry The entry to translate.
+   * @param {VegaRTEToolbarRenderContext} editorContext The render context.
+   * @returns {RTEDropdownListItem | RTEDropdownListGroup} The translated entry.
+   */
+  translateDropdownEntry(entry, editorContext) {
+    const translatedLabel = editorContext.translation.t(entry.label);
+    if ('children' in entry) {
+      return Object.assign(Object.assign({}, entry), { label: translatedLabel, children: entry.children.map((child) => this.translateDropdownEntry(child, editorContext)) });
+    }
+    return Object.assign(Object.assign({}, entry), { label: translatedLabel });
+  }
 }
 
 /**
@@ -2574,7 +2203,7 @@ class FunctionToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
         showArrowIcon: true,
         tooltip: { text: 'Insert function' },
       }),
-      this.renderDropdownListTemplate(h, FunctionToolbarButtonRenderer.FUNCTION_LIST),
+      this.renderDropdownListTemplate(h, FunctionToolbarButtonRenderer.FUNCTION_LIST, editorContext),
     ]);
   }
   /**
@@ -3027,7 +2656,7 @@ class VegaRTEFunctionExtension extends VegaRTEExtension {
   VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.name, ModifyContentActionType.PASTE_CONTENT, new PreventPasteContentInterceptor());
 })();
 
-const tableBlockStylesCss = ".v-rte--extension-table-container{display:table}table.v-rte--extension-table{border-collapse:collapse}table.v-rte--extension-table th,table.v-rte--extension-table td{border:1px solid #ddd;padding:12px;text-align:left;vertical-align:middle;min-width:55px;box-sizing:border-box;position:relative}table.v-rte--extension-table th{background-color:#f2f2f2}.rte-table-setting-popover,.rte-table-dynamic-popover{display:block}table.v-rte--extension-table .v-rte-table-cell-focused::after,table.v-rte--extension-table .v-rte-table-cell-selected::after{content:'';position:absolute;top:0;left:0;right:0;bottom:0;pointer-events:none;background-color:rgba(158, 207, 250, 0.3)}table.v-rte--extension-table:has(.v-rte-table-cell-selected){caret-color:transparent}table.v-rte--extension-table:has(.v-rte-table-cell-selected) ::selection{background-color:transparent}table.v-rte--extension-table:has(.v-rte-table-cell-selected) ::-moz-selection{background-color:transparent}.v-rte--extension-table-caption{padding:8px;border:1px solid #ddd;border-bottom:none;background-color:rgba(var(--v-bg-table-header, 24, 24, 48));position:relative;display:table-caption;caption-side:top;min-height:22px;text-align:center;word-break:break-word;overflow-wrap:break-word}.v-rte--extension-table-caption.showPlaceholder::before{position:absolute;left:0;right:0;content:attr(data-placeholder);font-family:'Inter', sans-serif;font-size:16px;font-weight:400;line-height:24px;letter-spacing:0;color:rgba(var(--v-text-input-placeholder, 176, 180, 181, 1));text-align:center;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}";
+const tableBlockStylesCss = ".v-rte--extension-table-container{display:table}table.v-rte--extension-table{border-collapse:collapse}table.v-rte--extension-table th,table.v-rte--extension-table td{border:1px solid #ddd;padding:12px;text-align:left;vertical-align:middle;min-width:55px;box-sizing:border-box;position:relative}table.v-rte--extension-table th{background-color:#f2f2f2}.rte-table-setting-popover,.rte-table-dynamic-popover{display:block}table.v-rte--extension-table .v-rte-table-cell-focused::after,table.v-rte--extension-table .v-rte-table-cell-selected::after{content:'';position:absolute;top:0;left:0;right:0;bottom:0;pointer-events:none;background-color:rgba(158, 207, 250, 0.3)}table.v-rte--extension-table:has(.v-rte-table-cell-selected){caret-color:transparent}table.v-rte--extension-table:has(.v-rte-table-cell-selected) ::selection{background-color:transparent}table.v-rte--extension-table:has(.v-rte-table-cell-selected) ::-moz-selection{background-color:transparent}.v-rte--extension-table-caption{padding:8px;border:1px solid #ddd;border-bottom:none;background-color:rgba(var(--v-bg-table-header, 240, 243, 247, 1));position:relative;display:table-caption;caption-side:top;min-height:22px;text-align:center;word-break:break-word;overflow-wrap:break-word}.v-rte--extension-table-caption.showPlaceholder::before{position:absolute;left:0;right:0;content:attr(data-placeholder);font-family:'Inter', sans-serif;font-size:16px;font-weight:400;line-height:24px;letter-spacing:0;color:rgba(var(--v-text-input-placeholder, 176, 180, 181, 1));text-align:center;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}";
 
 const DELETE_TABLE_BLOCK = 'DELETE_TABLE_BLOCK';
 /**
@@ -3657,7 +3286,7 @@ class TablePopoverBaseRenderer {
    */
   getTableExtensionContext() {
     return this.renderContext
-      ? RTEExtensionContextManager$1.getExtensionContext(this.renderContext.host)
+      ? RTEExtensionContextManager.getExtensionContext(this.renderContext.host)
       : null;
   }
 }
@@ -7751,6 +7380,518 @@ class VegaRTETableExtension extends VegaRTEExtension {
   VegaRTEExtension.registerFilterStylesStrategy(RTETableHeadCellBlock.dtoName, new TableCellFilterStylesStrategy('th'));
 })();
 
+/**
+ * Horizontal line node — a decorator node representing `<hr>` in the editor.
+ */
+class RTEHorizontalLineNode extends RTEDecoratorNode {
+  constructor(id, parentBlock, annotationMap) {
+    super(id, annotationMap);
+    this.type = 'horizontal-line';
+    this.parent = parentBlock;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      type: 'horizontal-line',
+    };
+  }
+  /**
+   * @inheritDoc
+   */
+  clone(parent) {
+    return new RTEHorizontalLineNode(this.id, parent, super.cloneAnnotations());
+  }
+  /**
+   * @inheritDoc
+   */
+  toHtml() {
+    return '<hr>';
+  }
+}
+
+/**
+ * Predicate class provides static methods to check specific conditions on HTML elements or dto instances.
+ */
+class Predicate {
+  /**
+   * Checks if the given class name corresponds to a horizontal line block.
+   *
+   * @param {string} className The class name to check.
+   * @returns {boolean} True if the class name corresponds to a horizontal line block, false otherwise.
+   */
+  static isHorizontalLineBlock(className) {
+    return className === 'RTEHorizontalLineBlock';
+  }
+}
+
+/**
+ * Default visual styles for the `<hr>` element in the RTE.
+ * These styles match the CSS applied in `horizontal-line-block-styles.css`.
+ *
+ * @see {@link file://extensions/horizontal-line/renderers/horizontal-line-block-styles.css} — must stay in sync.
+ */
+const HR_DEFAULT_STYLES = {
+  display: 'inline-block',
+  width: '100%',
+  height: '4px',
+  backgroundColor: 'rgb(222, 222, 222)',
+  borderWidth: '0px',
+};
+/**
+ * Filter styles strategy for horizontal line blocks.
+ * Strips default HR visual styles during output and refills them during input,
+ * ensuring source edit round-trips do not lose information.
+ */
+class HorizontalLineFilterStylesStrategy extends RTEFilterStylesStrategy {
+  constructor() {
+    super(...arguments);
+    this.stylesToBeFiltered = HR_DEFAULT_STYLES;
+    this.elementTagName = 'hr';
+  }
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance) {
+    return Predicate.isHorizontalLineBlock(blockOrNodeInstance.dtoName);
+  }
+  /**
+   * @inheritDoc
+   */
+  canRefill(_blockOrNodeClassName, element) {
+    return element.tagName.toLowerCase() === this.elementTagName;
+  }
+  /**
+   * @inheritDoc
+   */
+  toCssText() {
+    return this.buildCssTextForStyles(this.elementTagName, this.classNameToBeAdded);
+  }
+}
+
+var RTEHorizontalLineExtensionAnnotationTypeEnum;
+(function (RTEHorizontalLineExtensionAnnotationTypeEnum) {
+  RTEHorizontalLineExtensionAnnotationTypeEnum["HORIZONTAL_LINE"] = "HORIZONTAL_LINE";
+})(RTEHorizontalLineExtensionAnnotationTypeEnum || (RTEHorizontalLineExtensionAnnotationTypeEnum = {}));
+/**
+ * Horizontal line annotation.
+ * Mirrors {@link TextStyleAnnotation}: emits the HR default visual styles in
+ * standalone mode (source edit) and the corresponding class in normal mode.
+ * Only added to the block when `autoMatchFormat` is enabled.
+ */
+class HorizontalLineAnnotation extends BlockAnnotation {
+  constructor() {
+    super(...arguments);
+    this.type = RTEHorizontalLineExtensionAnnotationTypeEnum.HORIZONTAL_LINE;
+  }
+  /**
+   * Generate the map item for the annotation.
+   *
+   * @returns {[RTEHorizontalLineExtensionAnnotationTypeEnum.HORIZONTAL_LINE, HorizontalLineAnnotation]} Map item.
+   */
+  static from() {
+    return [RTEHorizontalLineExtensionAnnotationTypeEnum.HORIZONTAL_LINE, new HorizontalLineAnnotation()];
+  }
+  /**
+   * Get the default styles for the horizontal line element.
+   *
+   * @returns {AnnotationStyle} The default styles.
+   */
+  static getDefaultStyles() {
+    return HR_DEFAULT_STYLES;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    // HR identity is captured by the block type; nothing to serialize.
+    return null;
+  }
+  /**
+   * @inheritDoc
+   */
+  clone() {
+    return new HorizontalLineAnnotation();
+  }
+  /**
+   * @inheritDoc
+   */
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return 'v-rte-horizontal-line-hr';
+  }
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    return HorizontalLineAnnotation.getDefaultStyles();
+  }
+}
+
+/**
+ * Horizontal line block — a block containing a single `<hr>` decorator node.
+ */
+class RTEHorizontalLineBlock extends RTEBlock {
+  constructor(id, options) {
+    super(id);
+    this.dtoName = RTEHorizontalLineBlock.dtoName;
+    this.type = 'horizontal-line';
+    this.children = [];
+    const { autoMatchFormat = true } = options !== null && options !== void 0 ? options : {};
+    if (autoMatchFormat) {
+      this.annotationMap = new Map([HorizontalLineAnnotation.from()]);
+    }
+  }
+  /**
+   * Creates an RTEHorizontalLineBlock from a JSON representation.
+   *
+   * @param {VegaRTECustomBlock} block - The block JSON to convert.
+   * @param {VegaRTETransformOptions} [options] - Transformation options.
+   * @returns {RTEHorizontalLineBlock} The created block instance.
+   */
+  static from(block, options = { autoMatchFormat: true }) {
+    var _a, _b;
+    const hrBlock = new RTEHorizontalLineBlock(block.id, options);
+    const nodeId = ((_b = (_a = block.children) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.id) || generateUUID();
+    const node = new RTEHorizontalLineNode(nodeId, hrBlock);
+    hrBlock.children = [node];
+    if (block.annotations) {
+      RTEBlock.convertAnnotationsToMap(hrBlock.annotationMap, block.annotations);
+    }
+    return hrBlock;
+  }
+  /**
+   * Creates a new RTEHorizontalLineBlock with a child node.
+   *
+   * @param {VegaRTEBlockAnnotations} [annotations] - Optional annotations (e.g. customStyle overrides).
+   * @param {VegaRTETransformOptions} [options] - Transformation options.
+   * @returns {RTEHorizontalLineBlock} A new block instance.
+   */
+  static create(annotations, options = { autoMatchFormat: true }) {
+    const hrBlock = new RTEHorizontalLineBlock(generateUUID(), options);
+    const node = new RTEHorizontalLineNode(generateUUID(), hrBlock);
+    hrBlock.children = [node];
+    if (annotations) {
+      RTEBlock.convertAnnotationsToMap(hrBlock.annotationMap, annotations);
+    }
+    return hrBlock;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    return Object.assign(Object.assign({}, super.toJSON()), { type: 'horizontal-line', children: this.children.map((node) => node.toJSON()) });
+  }
+  /**
+   * @inheritDoc
+   */
+  toHtml(options) {
+    const attrStr = super.generateAttributeString(options);
+    return `<hr${attrStr}>`;
+  }
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty() {
+    return this.children.length > 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  getLastNode() {
+    return this.children[this.children.length - 1];
+  }
+  /**
+   * @inheritDoc
+   */
+  clone(parent) {
+    const clonedBlock = new RTEHorizontalLineBlock(this.id);
+    clonedBlock.children = this.children.map((node) => node.clone(clonedBlock));
+    clonedBlock.annotationMap = super.cloneAnnotations();
+    clonedBlock.parent = parent;
+    return clonedBlock;
+  }
+}
+RTEHorizontalLineBlock.dtoName = 'RTEHorizontalLineBlock';
+
+const horizontalLineBlockStylesCss = ".v-rte-horizontal-line{padding:8px 0;overflow:hidden}.v-rte-horizontal-line .v-rte-horizontal-line-hr{display:inline-block;width:100%;height:4px;border-width:0px;background-color:rgb(222, 222, 222)}";
+
+/**
+ * Renderer for horizontal line blocks in the rich text editor.
+ */
+class RTEHorizontalLineBlockRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(createElement, block, rteContext) {
+    const node = block.children[0];
+    const customStyles = block.getStyles(rteContext);
+    const annotationClasses = block.getClasses(rteContext);
+    const hrClass = [RTEDecoratorNode.DECORATOR_NODE_CLASS, annotationClasses]
+      .filter(Boolean)
+      .join(' ');
+    return createElement('div', {
+      key: block.id,
+      class: `v-rte-horizontal-line ${RTEDecoratorNode.DECORATOR_CONTAINER_CLASS}`,
+      ref: this.useRef(block),
+    }, [
+      createElement('hr', {
+        key: (node === null || node === void 0 ? void 0 : node.id) || block.id + '-hr',
+        class: hrClass,
+        style: Object.keys(customStyles).length > 0 ? customStyles : undefined,
+        ref: node ? this.useRef(node) : undefined,
+      }),
+    ]);
+  }
+  /**
+   * @inheritDoc
+   */
+  injectRTEScopeStyles() {
+    return horizontalLineBlockStylesCss;
+  }
+}
+
+const HorizontalLine = {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 512"><!--! Font Awesome Pro 6.3.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><path fill="currentColor"  d="M0 224H32 608h32v64H608 32 0V224z"/></svg>`,
+};
+
+const INSERT_HORIZONTAL_LINE_BLOCK = 'INSERT_HORIZONTAL_LINE_BLOCK';
+/**
+ * Action to insert a horizontal line block into the rich text editor.
+ * Carries cursor position info to support split-paragraph insertion (same pattern as InsertImageToBlockAction).
+ */
+class InsertHorizontalLineBlockAction extends ModifyContentAction {
+  constructor(splitPointNode, startOffsetOfNode = 0) {
+    super();
+    this.type = INSERT_HORIZONTAL_LINE_BLOCK;
+    this.splitPointNode = splitPointNode;
+    this.startOffsetOfNode = startOffsetOfNode;
+  }
+}
+
+/**
+ * Toolbar button renderer for horizontal line insertion.
+ */
+class RTEHorizontalLineToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  /**
+   * Renders the horizontal line toolbar button.
+   *
+   * @param {VegaRTECreateElementFunction} createElement - The function to create elements.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context.
+   * @returns {VegaRTERenderResult} The rendered toolbar button.
+   */
+  render(createElement, editorContext) {
+    return this.renderButton(createElement, editorContext, {
+      icon: 'horizontal-line',
+      tooltip: { text: VegaInternalTranslation.t('Horizontal line') },
+    });
+  }
+  /**
+   * @inheritDoc
+   */
+  isDisabled(editorContext) {
+    const context = this.getExtensionContext(editorContext.host);
+    if (context) {
+      const { host, getSelectedNodes } = context;
+      const [startNode] = getSelectedNodes();
+      return startNode
+        ? host.disabled ||
+          !ActionHandleStrategyRegistry.canHandle(INSERT_HORIZONTAL_LINE_BLOCK, startNode.parent)
+        : host.disabled;
+    }
+    return false;
+  }
+  /**
+   * @inheritDoc
+   */
+  handleButtonClick(editorContext) {
+    if (this.isDisabled(editorContext)) {
+      return;
+    }
+    const context = this.getExtensionContext(editorContext.host);
+    if (context) {
+      const { host, getSelectedNodes, flushValue } = context;
+      const selectedNodes = getSelectedNodes();
+      const focusNode = selectedNodes[0];
+      const startOffset = editorContext.rteRange.startOffset;
+      const action = new InsertHorizontalLineBlockAction(focusNode, startOffset);
+      if (!focusNode) {
+        host.value.apply(action);
+      }
+      else if (focusNode.parent) {
+        focusNode.parent.apply(action);
+      }
+      if (action.nextFocusNode) {
+        host.value.apply(new UpdateCursorPositionAction(action.nextFocusNode, 0));
+      }
+      flushValue(host.value);
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  handleDropdownClick() {
+    // No dropdown for horizontal line
+  }
+}
+(() => {
+  VegaInternalIconManager.register({
+    'horizontal-line': HorizontalLine,
+  });
+})();
+
+/**
+ * Strategy to convert `<hr>` HTML elements into RTEHorizontalLineBlock instances.
+ */
+class HrToHorizontalLineBlockStrategy extends ElementToDTOStrategy {
+  /**
+   * Determines if this strategy can handle the current element.
+   *
+   * @param {HTMLElement[]} elementsArray - Array of elements to process.
+   * @param {number} currentIndex - The current index in the array.
+   * @returns {number} The number of elements this strategy can handle (1 for `<hr>`, 0 otherwise).
+   */
+  canHandle(elementsArray, currentIndex) {
+    return elementsArray[currentIndex].tagName === 'HR' ? 1 : 0;
+  }
+  /**
+   * Converts the `<hr>` element to an RTEHorizontalLineBlock.
+   * Uses `htmlElementToAnnotationGenerator` to extract annotations (handles refill + filter).
+   *
+   * @param {HTMLElement[]} elementsArray - Array of elements.
+   * @param {VegaRTETransformOptions} [options] - Transformation options.
+   * @returns {Nullable<RTEContentBlock>} The created horizontal line block.
+   */
+  handle(elementsArray, options) {
+    const element = elementsArray[0];
+    const annotations = htmlElementToAnnotationGenerator.generate(RTEHorizontalLineBlock, element, options);
+    return RTEHorizontalLineBlock.create(annotations, options);
+  }
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks() {
+    // `<hr>` is a void element — no children to append.
+  }
+  /**
+   * `<hr>` is a void element — no children to process.
+   *
+   * @returns {boolean} Always false.
+   */
+  shouldProceedToElementChildren() {
+    return false;
+  }
+}
+
+/**
+ * Strategy to handle the insertion of a horizontal line block into the rich text editor.
+ * Follows the same pattern as BlockInsertImageIntoTextStrategy (before/after/split).
+ */
+class InsertHorizontalLineBlockStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const hrBlock = RTEHorizontalLineBlock.create();
+    if (action.splitPointNode instanceof RTETextNode) {
+      const splitNode = action.splitPointNode;
+      const startOffsetOfNode = action.startOffsetOfNode;
+      if (this.isCaretPositionAtBlockEnd(target, splitNode, startOffsetOfNode)) {
+        this.insertAfterWithFocus(action, target, hrBlock);
+      }
+      else if (this.isCaretPositionAtBlockStart(target, splitNode, startOffsetOfNode)) {
+        target.parent.apply(new InsertChildrenBeforeAction(target, hrBlock));
+        action.nextFocusNode = target.getFirstNode();
+      }
+      else {
+        const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
+        target.apply(splitBlockAction);
+        const nextBlock = this.getNextSiblingBlock(target);
+        target.parent.apply(new InsertChildrenAfterAction(target, hrBlock));
+        action.nextFocusNode = nextBlock.getFirstNode();
+      }
+    }
+    else if (action.splitPointNode) {
+      // Decorator node selected (image, HR, etc.) — insert after current block
+      this.insertAfterWithFocus(action, target, hrBlock);
+    }
+    else {
+      const emptyParagraph = super.createNewParagraph('');
+      target.apply(new AppendChildrenAction([hrBlock, emptyParagraph]));
+      action.nextFocusNode = emptyParagraph.children[0];
+    }
+  }
+  /**
+   * Insert HR after target. If next sibling is focusable (has a text node), move cursor there;
+   * otherwise create an empty paragraph after HR.
+   *
+   * @param {InsertHorizontalLineBlockAction} action - The insert action whose `nextFocusNode` is updated.
+   * @param {RTEBlock} target - The block after which the HR is inserted.
+   * @param {RTEHorizontalLineBlock} hrBlock - The HR block to insert.
+   */
+  insertAfterWithFocus(action, target, hrBlock) {
+    const nextBlock = this.getNextSiblingBlock(target);
+    const nextFirstNode = nextBlock === null || nextBlock === void 0 ? void 0 : nextBlock.getFirstNode();
+    if (nextFirstNode instanceof RTETextNode) {
+      target.parent.apply(new InsertChildrenAfterAction(target, hrBlock));
+      action.nextFocusNode = nextFirstNode;
+    }
+    else {
+      const emptyParagraph = super.createNewParagraph('');
+      target.parent.apply(new InsertChildrenAfterAction(target, hrBlock, emptyParagraph));
+      action.nextFocusNode = emptyParagraph.children[0];
+    }
+  }
+  /**
+   * Get the next sibling block of the given block.
+   *
+   * @param {RTEBlock} block - The current block.
+   * @returns {RTEBlock | undefined} The next sibling block, or undefined if none.
+   */
+  getNextSiblingBlock(block) {
+    const parent = block.parent;
+    const siblings = parent.children;
+    const index = siblings.indexOf(block);
+    return siblings[index + 1];
+  }
+}
+
+/**
+ * Extension that adds horizontal line (`<hr>`) support to the Vega Rich Text Editor.
+ */
+class VegaRTEHorizontalLineExtension extends VegaRTEExtension {
+  constructor() {
+    super();
+    this.blockRenderer = new RTEHorizontalLineBlockRenderer();
+    this.toolbarButtonRenderer = new RTEHorizontalLineToolbarButtonRenderer();
+    // Register basic block strategies (delete, append, paste, etc.)
+    this.registerBlockBasicStrategies(RTEHorizontalLineBlock.name);
+    // Register the block DTO class
+    this.registerNode('horizontal-line', RTEHorizontalLineBlock);
+    // Register the renderer
+    this.registerRenderer('horizontal-line', this.blockRenderer);
+    // Register the toolbar button
+    this.registerToolbarButtonRenderer('horizontalLine', this.toolbarButtonRenderer);
+    // Register HTML → DTO conversion strategy
+    this.registerElementToBlockDTOClassStrategy(new HrToHorizontalLineBlockStrategy());
+    // Register filter styles strategy for source edit round-trip
+    VegaRTEExtension.registerFilterStylesStrategy(RTEHorizontalLineBlock.dtoName, new HorizontalLineFilterStylesStrategy());
+  }
+}
+(() => {
+  const insertStrategy = new InsertHorizontalLineBlockStrategy();
+  // Register insert strategy for all block types that can be a target
+  VegaRTEExtension.registerActionHandleStrategy(VegaRTEContent.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTETextBlock.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTEImageBlock.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(RTEHorizontalLineBlock.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
+})();
+
 const ARROW_CHARACTERS = [
   { character: '←', title: 'leftwards simple arrow' },
   { character: '→', title: 'rightwards simple arrow' },
@@ -8409,7 +8550,7 @@ class RTELineHeightToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
         showArrowIcon: true,
         tooltip: { text: VegaInternalTranslation.t('Line Height') },
       }),
-      this.renderDropdownListTemplate(createElement, dropdownItems),
+      this.renderDropdownListTemplate(createElement, dropdownItems, editorContext),
     ]);
   }
   /**
@@ -8804,4 +8945,4 @@ class VegaRTETokenExtension extends VegaRTEExtension {
   VegaRTEExtension.registerActionHandleStrategy(RTEListItemBlock.name, 'INSERT_TOKEN_NODE', insertTokenNodeStrategy);
 })();
 
-export { ActionHandlerInterceptor as A, InsertNodeToNearestRootAction as I, RTETokenToolbarButtonRenderer as R, VegaLoader as V, VegaNotify as a, VegaEventManager$1 as b, VegaZIndexManager$1 as c, VegaSkeletonLoader as d, VegaTranslation as e, VegaRTETokenExtension as f, VegaRTELanguageExtension as g, VegaRTEDefaultLineHeightOptions as h, VegaRTEFunctionExtension as i, VegaRTETableExtension as j, VegaRTESpecialCharactersExtension as k, VegaRTESpecialCharactersEssentials as l, VegaRTESpecialCharactersLatin as m, VegaRTESpecialCharactersMathematical as n, VegaRTESpecialCharactersArrows as o, VegaRTESpecialCharactersCurrency as p, VegaRTESpecialCharactersText as q, VegaRTELineHeightExtension as r, VegaRTEExtension as s, VegaRTEExtensionRenderer as t, VegaRTEToolbarButtonRenderer as u, RTETokenNode as v, waitForVega as w, RTETokenNodeRenderer as x, RTELanguageToolbarButtonRenderer as y };
+export { ActionHandlerInterceptor as A, InsertNodeToNearestRootAction as I, RTETokenToolbarButtonRenderer as R, VegaLoader as V, VegaNotify as a, VegaEventManager$1 as b, VegaZIndexManager$1 as c, VegaSkeletonLoader as d, VegaTranslation as e, VegaRTETokenExtension as f, VegaRTELanguageExtension as g, VegaRTEDefaultLineHeightOptions as h, VegaRTEFunctionExtension as i, VegaRTETableExtension as j, VegaRTEHorizontalLineExtension as k, VegaRTESpecialCharactersExtension as l, VegaRTESpecialCharactersEssentials as m, VegaRTESpecialCharactersLatin as n, VegaRTESpecialCharactersMathematical as o, VegaRTESpecialCharactersArrows as p, VegaRTESpecialCharactersCurrency as q, VegaRTESpecialCharactersText as r, VegaRTELineHeightExtension as s, VegaRTEToolbarButtonRenderer as t, RTETokenNode as u, RTETokenNodeRenderer as v, waitForVega as w, RTELanguageToolbarButtonRenderer as x };