@globalpayments/vega 2.88.0 → 2.89.0

package/dist/cjs/{token-extension-8b69f7e1.js → token-extension-dfee303a.js}

@@ -1,33 +1,33 @@
 'use strict';
 
 const misc = require('./misc-3d30df91.js');
-const ui = require('./ui-3727d685.js');
+const ui = require('./ui-c91c37a7.js');
 const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
 const createPublicApiRuntimeMetricsSlimmer = require('./create-public-api-runtime-metrics-slimmer-122350c3.js');
 const internalVegaZIndexManager = require('./internal-vega-z-index-manager-f03ddb37.js');
 const dynamicSlimmer = require('./dynamic-slimmer-f31fdfd7.js');
 const pageResizeObserverSlimmer = require('./page-resize-observer-slimmer-273d62ef.js');
-const internalVegaEventManager = require('./internal-vega-event-manager-c515cf5e.js');
-const internalTranslationController = require('./internal-translation-controller-a1250419.js');
-const contentState = require('./content-state-d4f54659.js');
-const codeBlock = require('./code-block-00fee034.js');
-const typeGuard = require('./type-guard-424efe26.js');
+const internalVegaEventManager = require('./internal-vega-event-manager-6e49d1ca.js');
+const internalTranslationController = require('./internal-translation-controller-5582d789.js');
+const contentState = require('./content-state-76b81780.js');
+const codeBlock = require('./code-block-7c49d175.js');
+const typeGuard = require('./type-guard-474dec0d.js');
 const dtoRendererManager = require('./dto-renderer-manager-7eb5c5ce.js');
 const baseRenderer = require('./base-renderer-0a3b62b7.js');
 const internalIconManager = require('./internal-icon-manager-66c48800.js');
 const vegaNonceManager = require('./vega-nonce-manager-df69d3ed.js');
-const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-ba6a95f3.js');
-const vegaEventId = require('./vega-event-id-39dedd17.js');
-const splitCellOperation = require('./split-cell-operation-91ee6894.js');
+const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-c82df135.js');
+const vegaEventId = require('./vega-event-id-37c1716f.js');
+const splitCellOperation = require('./split-cell-operation-b1fe91b5.js');
 const changeManager = require('./change-manager-a297e4d2.js');
 const vegaInternalEventId = require('./vega-internal-event-id-e138d4d6.js');
 const remoteInvocationRegistry = require('./remote-invocation-registry-fc22fdd0.js');
-const darkModeStyleController = require('./dark-mode-style-controller-ed481250.js');
+const darkModeStyleController = require('./dark-mode-style-controller-32d4054a.js');
 const tryGetDocument = require('./try-get-document-c0ebd39a.js');
 const pixel = require('./pixel-98f2a10c.js');
 const object = require('./object-b53e9416.js');
 const timer = require('./timer-5f33058b.js');
-const replaceSelectedTextAction = require('./replace-selected-text-action-a098523f.js');
+const replaceSelectedTextAction = require('./replace-selected-text-action-ef079fed.js');
 
 const VegaLoaderRuntimeMetricsPayloadDefinition = [
   {
@@ -3029,7 +3029,7 @@ class VegaRTEFunctionExtension extends VegaRTEExtension {
   VegaRTEExtension.registerActionHandlerInterceptor(codeBlock.RTETextBlock.name, codeBlock.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';
 /**
@@ -7753,6 +7753,518 @@ class VegaRTETableExtension extends VegaRTEExtension {
   VegaRTEExtension.registerFilterStylesStrategy(splitCellOperation.RTETableHeadCellBlock.dtoName, new TableCellFilterStylesStrategy('th'));
 })();
 
+/**
+ * Horizontal line node — a decorator node representing `<hr>` in the editor.
+ */
+class RTEHorizontalLineNode extends codeBlock.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 codeBlock.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 codeBlock.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 codeBlock.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) || misc.generateUUID();
+    const node = new RTEHorizontalLineNode(nodeId, hrBlock);
+    hrBlock.children = [node];
+    if (block.annotations) {
+      codeBlock.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(misc.generateUUID(), options);
+    const node = new RTEHorizontalLineNode(misc.generateUUID(), hrBlock);
+    hrBlock.children = [node];
+    if (annotations) {
+      codeBlock.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 = [codeBlock.RTEDecoratorNode.DECORATOR_NODE_CLASS, annotationClasses]
+      .filter(Boolean)
+      .join(' ');
+    return createElement('div', {
+      key: block.id,
+      class: `v-rte-horizontal-line ${codeBlock.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 codeBlock.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: internalTranslationController.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 ||
+          !codeBlock.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 contentState.UpdateCursorPositionAction(action.nextFocusNode, 0));
+      }
+      flushValue(host.value);
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  handleDropdownClick() {
+    // No dropdown for horizontal line
+  }
+}
+(() => {
+  internalIconManager.VegaInternalIconManager.register({
+    'horizontal-line': HorizontalLine,
+  });
+})();
+
+/**
+ * Strategy to convert `<hr>` HTML elements into RTEHorizontalLineBlock instances.
+ */
+class HrToHorizontalLineBlockStrategy extends contentState.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 = contentState.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 codeBlock.ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const hrBlock = RTEHorizontalLineBlock.create();
+    if (action.splitPointNode instanceof codeBlock.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 codeBlock.InsertChildrenBeforeAction(target, hrBlock));
+        action.nextFocusNode = target.getFirstNode();
+      }
+      else {
+        const splitBlockAction = new codeBlock.SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
+        target.apply(splitBlockAction);
+        const nextBlock = this.getNextSiblingBlock(target);
+        target.parent.apply(new codeBlock.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 codeBlock.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 codeBlock.RTETextNode) {
+      target.parent.apply(new codeBlock.InsertChildrenAfterAction(target, hrBlock));
+      action.nextFocusNode = nextFirstNode;
+    }
+    else {
+      const emptyParagraph = super.createNewParagraph('');
+      target.parent.apply(new codeBlock.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(contentState.VegaRTEContent.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTETextBlock.name, INSERT_HORIZONTAL_LINE_BLOCK, insertStrategy);
+  VegaRTEExtension.registerActionHandleStrategy(contentState.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' },
@@ -8819,6 +9331,7 @@ exports.VegaRTEDefaultLineHeightOptions = VegaRTEDefaultLineHeightOptions;
 exports.VegaRTEExtension = VegaRTEExtension;
 exports.VegaRTEExtensionRenderer = VegaRTEExtensionRenderer;
 exports.VegaRTEFunctionExtension = VegaRTEFunctionExtension;
+exports.VegaRTEHorizontalLineExtension = VegaRTEHorizontalLineExtension;
 exports.VegaRTELanguageExtension = VegaRTELanguageExtension;
 exports.VegaRTELineHeightExtension = VegaRTELineHeightExtension;
 exports.VegaRTESpecialCharactersArrows = VegaRTESpecialCharactersArrows;

package/dist/cjs/{translation-slimmer-aee3fb1c.js → translation-slimmer-1a7a2b6d.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
-const internalTranslationController = require('./internal-translation-controller-a1250419.js');
+const internalTranslationController = require('./internal-translation-controller-5582d789.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/cjs/{type-guard-424efe26.js → type-guard-474dec0d.js}

@@ -3,7 +3,7 @@
 const breakpoints = require('./breakpoints-ebde4837.js');
 const ui = require('./ui-32120990.js');
 const typography = require('./typography-4560e7f1.js');
-const internalTranslationController = require('./internal-translation-controller-a1250419.js');
+const internalTranslationController = require('./internal-translation-controller-5582d789.js');
 const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
 
 const GridRowsRegex = new RegExp(/^([1-9]|1[0-2])(-auto)?$/);

package/dist/cjs/{ui-3727d685.js → ui-c91c37a7.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
+require('./global-slimmer-registry-b3bce7e0.js');
 
 /**
  * Device type enumeration for responsive design breakpoints.
@@ -186,34 +186,6 @@ function getHexFromShorthand(hex) {
   });
   return hexFullForm;
 }
-/**
- * It returns true if the text in the element is wrapped.
- *
- * @param {HTMLElement} element - The element to be judged.
- * @returns {boolean} A boolean value.
- */
-function isTextWrapped(element) {
-  const lineHeight = parseFloat(getElementComputedStyle(element, 'line-height'));
-  if (!isNaN(lineHeight)) {
-    return element.clientHeight > lineHeight;
-  }
-  else {
-    globalSlimmerRegistry.LogUtility.warn('The line height of this element is not obtained');
-    return false;
-  }
-}
-/**
- * "Get the computed style of an element."
- * The first parameter is the element whose style we want to get. The second parameter is the name of
- * the style we want to get
- *
- * @param {HTMLElement} element - The element whose style you want to get.
- * @param {string} styleName - The name of the style you want to get.
- * @returns {string} The computed style of the element.
- */
-function getElementComputedStyle(element, styleName) {
-  return window.getComputedStyle(element).getPropertyValue(styleName);
-}
 /**
  * Get the deep active element in shadow component
  *
@@ -354,12 +326,10 @@ exports.extractNumberFromString = extractNumberFromString;
 exports.findParent = findParent;
 exports.getDeepActiveElementInShadow = getDeepActiveElementInShadow;
 exports.getDeviceType = getDeviceType;
-exports.getElementComputedStyle = getElementComputedStyle;
 exports.getFirstFocusableElement = getFirstFocusableElement;
 exports.getHexFromShorthand = getHexFromShorthand;
 exports.hexToRGB = hexToRGB;
 exports.isElementVisible = isElementVisible;
 exports.isHTMLElement = isHTMLElement;
 exports.isParent = isParent;
-exports.isTextWrapped = isTextWrapped;
 exports.rgbToHex = rgbToHex;

package/dist/cjs/{valid-credit-card-number-rule-6bd5834c.js → valid-credit-card-number-rule-00c18527.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const typeGuard = require('./type-guard-424efe26.js');
+const typeGuard = require('./type-guard-474dec0d.js');
 const number = require('./number-4816603d.js');
 const internalFormFieldValidationRule_abstract = require('./internal-form-field-validation-rule.abstract-07cdff46.js');