@heartlandone/vega 2.100.0 → 2.102.0

package/dist/cjs/image-extension-1cf84f27.js

@@ -0,0 +1,1209 @@
+'use strict';
+
+const codeBlock = require('./code-block-06e6591f.js');
+const linkExtension = require('./link-extension-2a6133b7.js');
+const misc = require('./misc-3d30df91.js');
+const contentState = require('./content-state-8c862e5e.js');
+const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-c82df135.js');
+const vegaEventId = require('./vega-event-id-b5abf7c9.js');
+const internalTranslationController = require('./internal-translation-controller-eae8a8de.js');
+const accessibility = require('./accessibility-6ca2a237.js');
+const timer = require('./timer-5f33058b.js');
+const tryGetDocument = require('./try-get-document-c0ebd39a.js');
+const internalIconManager = require('./internal-icon-manager-b9702049.js');
+const typeGuard = require('./type-guard-29e01bd4.js');
+const vegaNonceManager = require('./vega-nonce-manager-df69d3ed.js');
+
+/**
+ * Base class for rendering extension toolbar button in the rich text editor.
+ * The renderer provides common functionalities for rendering toolbar buttons, including:
+ * - Rendering a button with an icon, label, and optional arrow icon.
+ * - Rendering a dropdown with a list of items.
+ * - Rendering dropdown items.
+ * - Rendering template for dropdown list.
+ * - Determining if the button should be disabled based on the editor context.
+ * - Handling button and dropdown click events.
+ * Override the methods to customize the rendering and behavior of the button.
+ */
+class VegaRTEToolbarButtonRenderer {
+  constructor() {
+    this.dropdownEl = null;
+    this.itemsContainerEl = null;
+    this.buttonEl = null;
+  }
+  /**
+   * Checks if the button should be hidden.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext The render context for the editor.
+   * @returns {boolean} True if the button is hidden, false otherwise.
+   */
+  isHidden(editorContext) {
+    return editorContext.sourceEditMode;
+  }
+  /**
+   * 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 linkExtension.extensionContextManager.getExtensionContext(el);
+  }
+  /**
+   * Renders a dropdown component with the specified properties and children.
+   *
+   * @param {VegaRTECreateElementFunction} h - Create element function.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @param {RTEToolbarDropdownProps} dropdownProps - The properties for the dropdown.
+   * @param {VegaRTERenderResult[]} children - The children elements for the dropdown.
+   * @returns {VegaRTERenderResult} - The render result for the dropdown.
+   */
+  renderDropdown(h, editorContext, dropdownProps, children) {
+    return h('vega-dropdown', Object.assign({ trigger: 'click', searchable: false, maxWidth: '200', itemDisplayRule: 'ellipsis', isScreenPosition: true, role: 'presentation', 
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      ref: (el) => {
+        this.dropdownEl = el;
+        domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(el, vegaEventId.VegaDropdownClick, (input) => {
+          const payload = input;
+          this.handleDropdownClick(payload.detail, editorContext);
+        });
+      } }, dropdownProps), children);
+  }
+  /**
+   * Renders the dropdown list template.
+   *
+   * @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, editorContext) {
+    return h('div', {
+      slot: 'items',
+      onMouseDown: this.preventDefault,
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      onKeyDown: (e) => this.handleItemsKeyDown(e),
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      ref: (el) => {
+        this.itemsContainerEl = el;
+      },
+      class: 'rte-dropdown-list',
+    }, [
+      h('style', { nonce: vegaNonceManager.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, editorContext)
+          : this.renderDropdownItem(h, item, editorContext);
+      }),
+    ]);
+  }
+  /**
+   * Renders a dropdown item for the toolbar button.
+   *
+   * @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, editorContext) {
+    return h('vega-dropdown-item', {
+      key: item.key,
+      itemKey: item.key,
+      label: editorContext.translation.t(item.label),
+      prefixIcon: item.icon,
+    });
+  }
+  /**
+   * Renders a dropdown group for the toolbar button.
+   *
+   * @param {VegaRTECreateElementFunction} h - Create element function.
+   * @param {RTEDropdownListGroup} item - The dropdown group.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @returns {VegaRTERenderResult} - The render result for the dropdown group.
+   */
+  renderDropdownGroup(h, item, editorContext) {
+    return h('vega-dropdown-group', {
+      key: item.key,
+      label: editorContext.translation.t(item.label),
+      divide: false,
+    }, item.children.map((child) => {
+      return 'children' in child
+        ? this.renderDropdownGroup(h, child, editorContext)
+        : this.renderDropdownItem(h, child, editorContext);
+    }));
+  }
+  /**
+   * Renders a common toolbar button with optional icon, label, and arrow icon.
+   * When a tooltip is provided via `buttonProps.tooltip`, the button is wrapped
+   * in a `vega-tooltip` element, matching the behavior of default toolbar buttons.
+   *
+   * @param {VegaRTECreateElementFunction} h - Create element function.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @param {RTEToolbarButtonProps} buttonProps - The properties for the button.
+   * @returns {VegaRTERenderResult} - The render result for the button.
+   */
+  renderButton(h, editorContext, buttonProps) {
+    const { icon, label, showArrowIcon, tooltip, ariaLabel } = buttonProps;
+    const isDisabled = this.isDisabled(editorContext);
+    const button = h('vega-rich-text-editor-toolbar-button', {
+      'disabled': isDisabled,
+      'icon': icon,
+      'data-aria-label': ariaLabel !== null && ariaLabel !== void 0 ? ariaLabel : label,
+      'hidden': this.isHidden(editorContext),
+      'selected': this.isSelected(editorContext),
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      'ref': (el) => {
+        this.buttonEl = el;
+        domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(el, vegaEventId.VegaClick, () => this.handleButtonClick(editorContext));
+      },
+      'onMouseDown': this.preventDefault,
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      'onKeyDown': (e) => this.handleButtonKeyDown(e),
+    }, [
+      this.renderButtonLabel(h, editorContext, label),
+      showArrowIcon
+        ? h('vega-icon', {
+          'size': 'size-8',
+          'color': isDisabled ? 'text-disabled' : 'text-secondary',
+          'style': { marginLeft: '8px' },
+          'aria-hidden': 'true',
+          'icon': internalIconManager.VegaInternalIconManager.getIconKey('chevron-down'),
+        })
+        : null,
+    ].filter(typeGuard.isNonNullable));
+    if (tooltip === null || tooltip === void 0 ? void 0 : tooltip.text) {
+      return h('vega-tooltip', { text: editorContext.translation.t(tooltip.text), placement: ['bottom', 'top'] }, [button]);
+    }
+    return button;
+  }
+  /**
+   * Renders the button label.
+   *
+   * @param {VegaRTECreateElementFunction} h - Create element function.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @param {Nullable<string>} label - The button label if exist.
+   * @returns {Nullable<VegaRTERenderResult>} - The render result for the button.
+   */
+  renderButtonLabel(h, editorContext, label) {
+    if (label) {
+      const isDisabled = this.isDisabled(editorContext);
+      return h('vega-font', {
+        'variant': 'font-field-label-sm',
+        'color': isDisabled ? 'text-disabled' : 'text-primary',
+        'aria-hidden': 'true',
+      }, editorContext.translation.t(label));
+    }
+    return null;
+  }
+  /**
+   * Determines if the button should be disabled based on the editor context.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @returns {boolean} - True if the button should be disabled, false otherwise.
+   */
+  isDisabled(editorContext) {
+    return editorContext.host.disabled;
+  }
+  /**
+   * Checks if the button should be selected.
+   *
+   * @param {VegaRTEToolbarRenderContext} _editorContext The render context for the editor.
+   * @returns {boolean} True if the button is selected, false otherwise.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  isSelected(_editorContext) {
+    return false;
+  }
+  /**
+   * Prevents the default action of the click event. This is to avoid losing focus from the editor when the button is clicked.
+   *
+   * @param {MouseEvent} e The mouse event to prevent default action for.
+   */
+  preventDefault(e) {
+    e.preventDefault();
+  }
+  /**
+   * Moves focus to the toolbar button. Targets the inner focusable `<button>`
+   * inside the button's shadow root, falling back to the host element.
+   */
+  focusToolbarButton() {
+    var _a, _b, _c, _d;
+    const innerButton = (_c = (_b = (_a = this.buttonEl) === null || _a === void 0 ? void 0 : _a.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('button')) !== null && _c !== void 0 ? _c : null;
+    (_d = (innerButton !== null && innerButton !== void 0 ? innerButton : this.buttonEl)) === null || _d === void 0 ? void 0 : _d.focus();
+  }
+  /**
+   * Recursively searches for a dropdown list item by its key.
+   *
+   * @param {(RTEDropdownListItem | RTEDropdownListGroup)[]} itemList The list of dropdown items or groups to search through.
+   * @param {string} key The key of the item to find.
+   * @returns {Nullable<RTEDropdownListItem>} The dropdown list item if found, otherwise null.
+   */
+  getListItemByKey(itemList, key) {
+    for (const item of itemList) {
+      if ('children' in item) {
+        const foundItem = this.getListItemByKey(item.children, key);
+        if (foundItem) {
+          return foundItem;
+        }
+      }
+      else if (item.key === key) {
+        return item;
+      }
+    }
+    return null;
+  }
+  /**
+   * Handles keyboard events on the toolbar button to support dropdown keyboard accessibility.
+   * - Enter / Space: Toggles the dropdown open/closed.
+   * - ArrowDown / ArrowUp: Opens the dropdown and focuses the first/last item.
+   *
+   * @param {KeyboardEvent} e The keyboard event.
+   */
+  handleButtonKeyDown(e) {
+    if (!this.dropdownEl) {
+      return;
+    }
+    if (e.code === 'Enter' || e.code === 'Space') {
+      e.preventDefault();
+      e.stopPropagation();
+      this.dropdownEl.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+    }
+    else if (e.code === 'ArrowDown' || e.code === 'ArrowUp') {
+      e.preventDefault();
+      e.stopPropagation();
+      void this.dropdownEl.show().then(() => {
+        this.focusDropdownItem(e.code === 'ArrowDown' ? 'first' : 'last');
+      });
+    }
+  }
+  /**
+   * Handles keyboard navigation within the dropdown items container.
+   * - ArrowDown/ArrowUp: Moves focus to the next/previous non-disabled item.
+   * - Escape: Closes the dropdown and returns focus to the toolbar button.
+   *
+   * @param {KeyboardEvent} e The keyboard event.
+   */
+  handleItemsKeyDown(e) {
+    var _a, _b;
+    if (e.code === 'Escape') {
+      e.preventDefault();
+      e.stopPropagation();
+      if (this.dropdownEl) {
+        void this.dropdownEl.hide();
+      }
+      this.focusToolbarButton();
+      return;
+    }
+    if (e.code !== 'ArrowDown' && e.code !== 'ArrowUp') {
+      return;
+    }
+    e.preventDefault();
+    e.stopPropagation();
+    const items = this.getDropdownItems();
+    if (items.length === 0) {
+      return;
+    }
+    const currentIndex = items.findIndex((item) => { var _a, _b; return ((_a = item.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('li')) === ((_b = item.shadowRoot) === null || _b === void 0 ? void 0 : _b.activeElement); });
+    const direction = e.code === 'ArrowDown' ? 1 : -1;
+    const startIndex = currentIndex === -1 ? (e.code === 'ArrowDown' ? 0 : items.length - 1) : currentIndex + direction;
+    for (let offset = 0; offset < items.length; offset++) {
+      const index = (startIndex + offset * direction + items.length) % items.length;
+      if (!items[index].disabled) {
+        (_b = (_a = items[index].shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('li')) === null || _b === void 0 ? void 0 : _b.focus();
+        return;
+      }
+    }
+  }
+  /**
+   * Focuses the first or last non-disabled dropdown item.
+   *
+   * @param {'first' | 'last'} position Whether to focus the first or last item.
+   */
+  focusDropdownItem(position) {
+    var _a, _b;
+    const items = this.getDropdownItems();
+    const orderedItems = position === 'first' ? items : [...items].reverse();
+    for (const item of orderedItems) {
+      if (!item.disabled) {
+        (_b = (_a = item.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('li')) === null || _b === void 0 ? void 0 : _b.focus();
+        return;
+      }
+    }
+  }
+  /**
+   * Gets all dropdown items from the items container.
+   *
+   * @returns {HTMLVegaDropdownItemElement[]} Array of dropdown item elements.
+   */
+  getDropdownItems() {
+    if (!this.itemsContainerEl) {
+      return [];
+    }
+    return Array.from(this.itemsContainerEl.querySelectorAll('vega-dropdown-item'));
+  }
+}
+
+/**
+ * Abstract class for action handler interceptors, which can intercept actions before they are handled.
+ */
+class ActionHandlerInterceptor {
+}
+
+/**
+ * Bookmark node for the Vega Rich Text Editor.
+ *
+ * A bookmark is a named, zero-width marker that can be used as a local link target.
+ * It carries no text content and is never directly editable by the user.
+ */
+class RTEBookmarkNode extends codeBlock.RTETextNode {
+  constructor(id, name, parentBlock, annotations) {
+    super(id, '', parentBlock, annotations);
+    this.dtoName = RTEBookmarkNode.dtoName;
+    this.type = 'bookmark';
+    this.name = name;
+  }
+  /**
+   * @inheritDoc
+   */
+  static from(value, parent) {
+    const node = new RTEBookmarkNode(value.id, value.name, parent);
+    if (value.annotations) {
+      node.annotationMap = this.generateTextAnnotationMap(value.annotations);
+    }
+    return node;
+  }
+  /**
+   * Converts the bookmark node to a JSON representation.
+   *
+   * @returns {VegaRTEBookmarkNode} - The JSON representation of the bookmark node.
+   */
+  toJSON() {
+    const serializedNode = super.toJSON();
+    const annotations = serializedNode.annotations;
+    return Object.assign(Object.assign({ id: this.id }, (annotations ? { annotations } : {})), { type: this.type, text: '', name: this.name });
+  }
+  /**
+   * Bookmarks are markers only, so their content can never be edited directly.
+   *
+   * @returns {boolean} - Always returns false for bookmark nodes.
+   */
+  isContentEditable() {
+    return false;
+  }
+  /**
+   * Clones the bookmark node.
+   *
+   * @param {RTETextBlock} parent - The parent block for the cloned node.
+   * @returns {RTEBookmarkNode} - The cloned bookmark node.
+   */
+  clone(parent) {
+    return new RTEBookmarkNode(this.id, this.name, parent, super.cloneAnnotations());
+  }
+  /**
+   * Checks if a node is empty
+   *
+   * @returns {boolean}  It returns `true` if the node is empty
+   */
+  isEmpty() {
+    return false;
+  }
+  /**
+   * Converts the bookmark node to an HTML representation.
+   *
+   * The output matches the CKEditor 5 bookmark contract so the value stays
+   * compatible with other editors and remains a valid local link target.
+   *
+   * @returns {string} - The HTML representation of the bookmark node.
+   */
+  toHtml() {
+    return `<a id="${codeBlock.escapeHtmlAttribute(this.name)}"></a>`;
+  }
+  /**
+   * Bookmarks do not accept text formatting, but still process selection annotations.
+   *
+   * @param {AnnotationAction} action - The annotation action to apply.
+   */
+  doAnnotationActionApply(action) {
+    // BoldAnnotationAction has no annotationType; deletion identifies BOLD through its annotationType.
+    if (action instanceof codeBlock.BoldAnnotationAction ||
+      (action instanceof codeBlock.DeleteNodeAnnotationAction &&
+        action.annotationType === codeBlock.NodeAnnotationTypeEnum.BOLD)) {
+      return;
+    }
+    super.doAnnotationActionApply(action);
+  }
+}
+RTEBookmarkNode.typeName = 'RTEBookmarkNode';
+RTEBookmarkNode.dtoName = 'RTEBookmarkNode';
+
+/**
+ * Removes a bookmark when Backspace is pressed at the start of its following text node.
+ */
+class DeleteBookmarkBeforeTextInterceptor extends ActionHandlerInterceptor {
+  /**
+   * @inheritDoc
+   */
+  canIntercept(action, target) {
+    const { startContainerNode, startOffset } = action;
+    if (!(startContainerNode instanceof codeBlock.RTETextNode)) {
+      return false;
+    }
+    const nodeIndex = target.children.indexOf(startContainerNode);
+    return (startContainerNode.parent === target &&
+      nodeIndex > 0 &&
+      target.children[nodeIndex - 1] instanceof RTEBookmarkNode &&
+      (startOffset === 0 ||
+        (startContainerNode.text.length === 1 && startOffset === startContainerNode.text.length)));
+  }
+  /**
+   * @inheritDoc
+   */
+  intercept(_execution, action, target) {
+    const startContainerNode = action.startContainerNode;
+    if (startContainerNode.text.length === 1 && action.startOffset === 1) {
+      startContainerNode.apply(new codeBlock.UpdateTextAction(''));
+      action.previousNode = startContainerNode;
+      return;
+    }
+    const nodeIndex = target.children.indexOf(startContainerNode);
+    const bookmarkNode = target.children[nodeIndex - 1];
+    target.apply(new codeBlock.RemoveChildrenAction(bookmarkNode));
+    action.nextNode = startContainerNode;
+  }
+}
+
+/**
+ * Strategy to rename an existing bookmark node.
+ */
+class UpdateBookmarkNameStrategy extends codeBlock.ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, node) {
+    node.name = action.name;
+  }
+}
+
+/**
+ * Insert a new children to the nearest position of the parent container
+ *
+ * @example parent.apply(new InsertNodeToNearestRoot(rteRange, nodeToBeInserted))
+ */
+class InsertNodeToNearestRootAction extends codeBlock.ModifyContentAction {
+  constructor(rteRange, nodeToBeInserted) {
+    super();
+    this.type = codeBlock.ModifyContentActionType.INSERT_NODE_TO_NEAREST_ROOT;
+    this.rteRange = rteRange;
+    this.nodeToBeInserted = nodeToBeInserted;
+  }
+}
+
+/**
+ * Strategy to handle the insertion of a bookmark node into the nearest root block.
+ */
+class InsertBookmarkNodeStrategy extends codeBlock.ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, block) {
+    const { rteRange, name } = action;
+    if (rteRange && rteRange.startNode) {
+      const bookmarkNode = new RTEBookmarkNode(misc.generateUUID(), name, block);
+      block.apply(new InsertNodeToNearestRootAction(rteRange, bookmarkNode));
+      action.actionHandleResult = true;
+    }
+  }
+}
+
+const INSERT_BOOKMARK_NODE = 'INSERT_BOOKMARK_NODE';
+/**
+ * Action to insert a bookmark node at a specified range in the Rich Text Editor.
+ *
+ * @example block.apply(new InsertBookmarkNodeAction(rteRange, 'Rights'));
+ */
+class InsertBookmarkNodeAction extends codeBlock.ModifyContentAction {
+  constructor(rteRange, name) {
+    super();
+    this.type = INSERT_BOOKMARK_NODE;
+    this.rteRange = null;
+    this.actionHandleResult = false;
+    this.rteRange = rteRange;
+    this.name = name;
+  }
+}
+
+const UPDATE_BOOKMARK_NAME = 'UPDATE_BOOKMARK_NAME';
+/**
+ * Action to rename an existing bookmark node.
+ *
+ * @example bookmarkNode.apply(new UpdateBookmarkNameAction('Rights'));
+ */
+class UpdateBookmarkNameAction extends codeBlock.ModifyContentAction {
+  constructor(name) {
+    super();
+    this.type = UPDATE_BOOKMARK_NAME;
+    this.name = name;
+  }
+}
+
+/**
+ * Strategy to convert anchor elements into bookmark nodes.
+ *
+ * Supported inputs:
+ * - `<a id="Rights"></a>` — the CKEditor 5 bookmark contract.
+ * - `<a name="Rights"></a>` — the legacy CKEditor 4 anchor format.
+ *
+ * Only empty named anchors become bookmarks. Anchors with content, or anchors carrying an `href`,
+ * are left untouched so existing link/text handling is preserved.
+ */
+class AnchorToBookmarkNodeStrategy extends contentState.ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray, currentIndex) {
+    const element = elementsArray[currentIndex];
+    return this.isBookmarkAnchor(element) ? 1 : 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray) {
+    const element = elementsArray[0];
+    const name = this.resolveBookmarkName(element);
+    if (!name) {
+      return null;
+    }
+    return {
+      id: misc.generateUUID(),
+      type: 'bookmark',
+      text: '',
+      name,
+    };
+  }
+  /**
+   * @inheritDoc
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  appendChildBlocks() { }
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren() {
+    return false;
+  }
+  /**
+   * Checks whether the element is an anchor that represents a bookmark target.
+   *
+   * @param {HTMLElement} element - The element to check.
+   * @returns {boolean} True when the element is a bookmark anchor.
+   */
+  isBookmarkAnchor(element) {
+    return (!!element &&
+      element.nodeName === 'A' &&
+      !element.hasAttribute('href') &&
+      this.isEmptyAnchor(element) &&
+      !!this.resolveBookmarkName(element));
+  }
+  /**
+   * Reads the bookmark name from the anchor, preferring `id` over the legacy `name` attribute.
+   *
+   * @param {HTMLElement} element - The anchor element.
+   * @returns {string} The bookmark name, or an empty string when absent.
+   */
+  resolveBookmarkName(element) {
+    return (element.getAttribute('id') || element.getAttribute('name') || '').trim();
+  }
+  /**
+   * Checks whether the anchor has no meaningful content.
+   *
+   * @param {HTMLElement} element - The anchor element.
+   * @returns {boolean} True when the anchor is effectively empty.
+   */
+  isEmptyAnchor(element) {
+    return (element.textContent || '').trim().length === 0 && element.children.length === 0;
+  }
+}
+
+const BOOKMARK_ICON_VIEW_BOX = '0 0 384 512';
+const BOOKMARK_ICON_PATH = 'M0 48V487.7C0 501.1 10.9 512 24.3 512c5 0 9.9-1.5 14-4.4L192 400 345.7 507.6c4.1 2.9 9 4.4 14 4.4c13.4 0 24.3-10.9 24.3-24.3V48c0-26.5-21.5-48-48-48H48C21.5 0 0 21.5 0 48z';
+const bookmarkIcon = {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${BOOKMARK_ICON_VIEW_BOX}"><path fill="currentColor" d="${BOOKMARK_ICON_PATH}"/></svg>`,
+};
+
+/**
+ * Recursively collects every bookmark node contained in the given entity.
+ *
+ * Walks generic `children` and list `nestList` collections so bookmarks nested in
+ * lists, tables or any custom block are all discovered.
+ *
+ * @param {unknown} entity - Content, block or node to walk.
+ * @returns {RTEBookmarkNode[]} All bookmark nodes found under the entity.
+ */
+function collectBookmarkNodes(entity) {
+  const result = [];
+  const visited = new Set();
+  /**
+   * Visits a single entity and walks into its children.
+   *
+   * @param {unknown} current - The entity currently being visited.
+   */
+  function visit(current) {
+    if (!current || typeof current !== 'object' || visited.has(current)) {
+      return;
+    }
+    visited.add(current);
+    if (current instanceof RTEBookmarkNode) {
+      result.push(current);
+      return;
+    }
+    const { children, nestList } = current;
+    if (Array.isArray(children)) {
+      children.forEach(visit);
+    }
+    if (Array.isArray(nestList)) {
+      nestList.forEach(visit);
+    }
+  }
+  visit(entity);
+  return result;
+}
+/**
+ * Collects the names of every bookmark contained in the given entity.
+ *
+ * @param {unknown} entity - Content, block or node to walk.
+ * @returns {string[]} All bookmark names found under the entity.
+ */
+function collectBookmarkNames(entity) {
+  return collectBookmarkNodes(entity).map((node) => node.name);
+}
+
+/**
+ * Bookmark node renderer for the rich text editor.
+ *
+ * The bookmark always renders as an anchor so it stays a valid local link target. In editable mode
+ * the anchor also carries the marker icon and is wrapped by the bookmark editor popover.
+ */
+class RTEBookmarkNodeRenderer extends linkExtension.VegaRTEExtensionRenderer {
+  constructor() {
+    super(...arguments);
+    this.rangeHighlightHandlers = new WeakMap();
+    this.openPopoverNode = null;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    this.handleBalloonShow = (e) => {
+      const anchor = this.getBookmarkAnchor(e);
+      if (anchor) {
+        this.openPopoverNode = this.getBookmarkNodeByAnchor(anchor);
+        anchor.classList.add(RTEBookmarkNodeRenderer.SELECTED_CLASS);
+      }
+    };
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    this.handleBalloonHide = (e) => {
+      const anchor = this.getBookmarkAnchor(e);
+      if (anchor) {
+        if (this.getBookmarkNodeByAnchor(anchor) === this.openPopoverNode) {
+          this.openPopoverNode = null;
+        }
+        anchor.classList.remove(RTEBookmarkNodeRenderer.SELECTED_CLASS);
+      }
+    };
+  }
+  /**
+   * Renders the bookmark node.
+   *
+   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
+   * @param {RTEBookmarkNode} node - The bookmark node to render.
+   * @param {RTERenderContext} editorContent - The editor content context.
+   * @returns {VegaRTERenderResult} - The rendered DOM element.
+   */
+  doRender(createElement, node, editorContent) {
+    if (!editorContent || editorContent.editable === false) {
+      return this.renderReadonlyBookmark(createElement, node);
+    }
+    return this.renderEditableBookmark(createElement, node, editorContent);
+  }
+  /**
+   * @inheritDoc
+   */
+  injectRTEScopeStyles() {
+    return [
+      `a.rte-bookmark{display: inline-block; vertical-align: middle; line-height: 0; cursor: pointer; padding: 0; margin: 0; border-radius: 2px}`,
+      `a.rte-bookmark.rte-bookmark-readonly{cursor: default}`,
+      `a.rte-bookmark > vega-rich-text-bookmark-editor{position: absolute; width: 0; height: 0}`,
+      // The bookmark is icon only, so it follows the inherited text size instead of a fixed icon size.
+      `a.rte-bookmark .rte-bookmark__icon{display: inline-block; position: relative; top: -0.125em; vertical-align: middle; line-height: 0; height: 1em; width: 1em}`,
+      `a.rte-bookmark svg{display: block; height: 100%; width: 100%}`,
+      // Text colors have no design token variable, so the on action foreground is a literal.
+      `a.rte-bookmark.${RTEBookmarkNodeRenderer.SELECTED_CLASS}{color: rgba(var(--v-bg-action, 19,98,226,1))}`,
+    ].join('\n');
+  }
+  /**
+   * Removes the per-host selection listener so a destroyed host is not retained by the document.
+   *
+   * @param {HTMLVegaRichTextEditorElement} host - The editor host being torn down.
+   */
+  teardownRangeHighlight(host) {
+    var _a, _b;
+    const syncHandler = (_a = this.rangeHighlightHandlers.get(host)) !== null && _a !== void 0 ? _a : null;
+    if (!syncHandler) {
+      return;
+    }
+    (_b = tryGetDocument.tryGetDocument()) === null || _b === void 0 ? void 0 : _b.removeEventListener('selectionchange', syncHandler);
+    this.rangeHighlightHandlers.delete(host);
+  }
+  /**
+   * Renders a visible bookmark target without editor interactions.
+   *
+   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
+   * @param {RTEBookmarkNode} node - The bookmark node to render.
+   * @returns {VegaRTERenderResult} - The rendered bookmark element.
+   */
+  renderReadonlyBookmark(createElement, node) {
+    return createElement('a', {
+      key: node.id,
+      id: node.name,
+      class: 'rte-bookmark rte-bookmark-readonly',
+      title: node.name,
+    }, [this.renderIcon(createElement)]);
+  }
+  /**
+   * Renders the in-editor bookmark anchor wrapped by its editor popover.
+   *
+   *
+   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
+   * @param {RTEBookmarkNode} node - The bookmark node to render.
+   * @param {RTERenderContext} editorContent - The editor content context.
+   * @returns {VegaRTERenderResult} - The rendered bookmark element.
+   */
+  renderEditableBookmark(createElement, node, editorContent) {
+    const registerRef = this.useRef(node);
+    let anchorRef = null;
+    let editorRef = null;
+    this.ensureRangeHighlight(editorContent.host);
+    return createElement('a', {
+      'key': node.id,
+      'id': node.name,
+      'class': 'rte-bookmark',
+      'contenteditable': 'false',
+      'role': 'button',
+      'tabIndex': 0,
+      'aria-label': `${internalTranslationController.VegaInternalTranslation.t('Bookmark')}: ${node.name}`,
+      'title': node.name,
+      'onKeyDown': accessibility.createEnterKeyHandlerToTriggerClick(),
+      // Stops the browser from dropping its own caret before the editor moves it onto the bookmark.
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      'onMouseDown': (e) => e.preventDefault(),
+      // Refreshes the reserved names once the popover opens, mirroring the toolbar insert flow.
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      'onClick': () => {
+        if (editorRef) {
+          editorRef.reservedNames = this.getReservedNames(node, editorContent);
+        }
+        this.placeCaretAfterBookmark(node, editorContent);
+      },
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      'ref': (ref) => {
+        if (ref) {
+          anchorRef = ref;
+          registerRef(ref);
+        }
+        else {
+          void (editorRef === null || editorRef === void 0 ? void 0 : editorRef.hide());
+        }
+      },
+    }, [
+      this.renderIcon(createElement),
+      createElement('vega-rich-text-bookmark-editor', {
+        mode: 'preview',
+        name: node.name,
+        // eslint-disable-next-line jsdoc/require-jsdoc
+        ref: (ref) => {
+          if (ref) {
+            editorRef = ref;
+            // Anchor the popover to the bookmark <a>, mirroring the link editor wiring.
+            if (anchorRef && ref.target !== anchorRef) {
+              ref.target = anchorRef;
+            }
+            this.bindSelectedStateToBalloon(ref);
+            domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, vegaEventId.VegaChange, 
+            // eslint-disable-next-line jsdoc/require-jsdoc
+            (e) => {
+              this.handleChange(e, node, editorContent);
+            });
+          }
+        },
+      }),
+    ]);
+  }
+  /**
+   * Renders the bookmark icon as inline SVG so the browser paints the text selection over it.
+   *
+   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
+   * @returns {VegaRTERenderResult} - The rendered icon.
+   */
+  renderIcon(createElement) {
+    return createElement('span', { class: 'rte-bookmark__icon' }, [
+      createElement('svg', { 'viewBox': BOOKMARK_ICON_VIEW_BOX, 'aria-hidden': 'true', 'focusable': 'false' }, [createElement('path', { fill: 'currentColor', d: BOOKMARK_ICON_PATH })]),
+    ]);
+  }
+  /**
+   * Places the caret right after the bookmark so typing appends text and Backspace removes the bookmark.
+   *
+   * @param {RTEBookmarkNode} node - The bookmark node.
+   * @param {RTERenderContext} editorContent - The editor content context.
+   */
+  placeCaretAfterBookmark(node, editorContent) {
+    var _a;
+    (_a = editorContent.host) === null || _a === void 0 ? void 0 : _a.value.apply(new contentState.UpdateCursorPositionAction(node, node.getRangeEndOffset(), true));
+  }
+  /**
+   * Shows the selected outline on the bookmark while its editor balloon is open.
+   *
+   * The popover lives in the editor shadow root, so its events only reach the editor element.
+   * Stencil reuses the element across renders, so the listeners are replaced instead of stacked.
+   *
+   * @param {HTMLElement} editor - The bookmark editor element.
+   */
+  bindSelectedStateToBalloon(editor) {
+    editor.removeEventListener('vegaPopoverShow', this.handleBalloonShow);
+    editor.removeEventListener('vegaPopoverHide', this.handleBalloonHide);
+    editor.addEventListener('vegaPopoverShow', this.handleBalloonShow);
+    editor.addEventListener('vegaPopoverHide', this.handleBalloonHide);
+  }
+  /**
+   * Binds a single debounced selection listener per host that keeps the range highlight in sync.
+   *
+   * @typedef HTMLVegaRichTextEditorElement - The rich text editor host element.
+   * @param {HTMLVegaRichTextEditorElement} [host] - The editor host owning the bookmarks.
+   */
+  ensureRangeHighlight(host) {
+    const ownerDocument = tryGetDocument.tryGetDocument();
+    if (!host || !ownerDocument || this.rangeHighlightHandlers.has(host)) {
+      return;
+    }
+    const syncHandler = timer.debounce(() => this.syncRangeHighlight(host), 30, this);
+    this.rangeHighlightHandlers.set(host, syncHandler);
+    ownerDocument.addEventListener('selectionchange', syncHandler);
+  }
+  /**
+   * Highlights every bookmark the current non-collapsed selection crosses.
+   *
+   * @typedef HTMLVegaRichTextEditorElement - The rich text editor host element.
+   * @param {HTMLVegaRichTextEditorElement} host - The editor host owning the bookmarks.
+   */
+  syncRangeHighlight(host) {
+    var _a;
+    const selection = (_a = this.getExtensionContext(host)) === null || _a === void 0 ? void 0 : _a.getSelection();
+    const range = selection && selection.rangeCount > 0 ? selection.getRangeAt(0) : null;
+    collectBookmarkNodes(host.value).forEach((node) => {
+      const dom = codeBlock.stateEntityRenderingRegistry.getDOMByEntity(node);
+      if (dom) {
+        const rangeCrosses = !!range && !range.collapsed && range.intersectsNode(dom);
+        dom.classList.toggle(RTEBookmarkNodeRenderer.SELECTED_CLASS, rangeCrosses || node === this.openPopoverNode);
+      }
+    });
+  }
+  /**
+   * Resolves the bookmark anchor that owns the balloon which raised the event.
+   *
+   * @param {Event} e - The balloon event.
+   * @returns {Nullable<HTMLElement>} - The bookmark anchor element.
+   */
+  getBookmarkAnchor(e) {
+    var _a;
+    return (_a = e.currentTarget) === null || _a === void 0 ? void 0 : _a.closest('a.rte-bookmark');
+  }
+  /**
+   * Resolves the bookmark node backing an anchor element.
+   *
+   * @param {HTMLElement} anchor - The bookmark anchor element.
+   * @returns {Nullable<RTEBookmarkNode>} - The backing bookmark node, or null when the anchor is not a bookmark.
+   */
+  getBookmarkNodeByAnchor(anchor) {
+    const entity = codeBlock.stateEntityRenderingRegistry.getEntityByDOM(anchor);
+    return entity instanceof RTEBookmarkNode ? entity : null;
+  }
+  /**
+   * Collects the bookmark names already used by other bookmarks in the same document.
+   *
+   * @param {RTEBookmarkNode} node - The bookmark node being edited.
+   * @param {RTERenderContext} editorContent - The editor content context.
+   * @returns {string[]} - The reserved bookmark names.
+   */
+  getReservedNames(node, editorContent) {
+    var _a;
+    return collectBookmarkNodes((_a = editorContent.host) === null || _a === void 0 ? void 0 : _a.value)
+      .filter((item) => item !== node)
+      .map((item) => item.name);
+  }
+  /**
+   * Applies rename and removal actions emitted by the bookmark editor.
+   *
+   * @param {CustomEvent<{ action: 'save'; name: string } | { action: 'remove' }>} e - The bookmark editor change event.
+   * @param {RTEBookmarkNode} node - The bookmark node being edited.
+   * @param {RTERenderContext} editorContent - The editor content context.
+   */
+  handleChange(e, node, editorContent) {
+    var _a;
+    const host = editorContent.host;
+    if (!host) {
+      return;
+    }
+    if (e.detail.action === 'save') {
+      node.apply(new UpdateBookmarkNameAction(e.detail.name));
+      (_a = this.getExtensionContext(host)) === null || _a === void 0 ? void 0 : _a.flushValue(host.value);
+      return;
+    }
+    this.removeBookmark(node, host);
+  }
+  /**
+   * Removes the bookmark and leaves the caret where the bookmark used to be.
+   *
+   * @param {RTEBookmarkNode} node - The bookmark node being removed.
+   * @param {HTMLVegaRichTextEditorElement} host - The rich text editor host element.
+   */
+  removeBookmark(node, host) {
+    var _a, _b, _c, _d;
+    const siblings = (_b = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.children) !== null && _b !== void 0 ? _b : [];
+    const index = siblings.indexOf(node);
+    const nextNode = index >= 0 ? siblings[index + 1] : null;
+    const previousNode = index > 0 ? siblings[index - 1] : null;
+    (_c = node.parent) === null || _c === void 0 ? void 0 : _c.apply(new codeBlock.RemoveChildrenAction(node));
+    (_d = this.getExtensionContext(host)) === null || _d === void 0 ? void 0 : _d.flushValue(host.value);
+    if (nextNode) {
+      host.value.apply(new contentState.UpdateCursorPositionAction(nextNode, 0, true));
+    }
+    else if (previousNode) {
+      host.value.apply(new contentState.UpdateCursorPositionAction(previousNode, previousNode.getRangeEndOffset(), true));
+    }
+  }
+}
+RTEBookmarkNodeRenderer.typeName = 'RTEBookmarkNodeRenderer';
+RTEBookmarkNodeRenderer.SELECTED_CLASS = 'rte-bookmark-selected';
+
+/**
+ * Toolbar button renderer for the bookmark extension.
+ *
+ * The button hosts the bookmark editor in insert mode and inserts a bookmark
+ * at the caret position captured when the button was activated.
+ */
+class RTEBookmarkToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  constructor() {
+    super(...arguments);
+    this.editorRef = null;
+    this.buttonWrapperRef = null;
+    this.pendingRange = null;
+  }
+  /**
+   * Renders the bookmark toolbar button wrapped in the bookmark editor.
+   *
+   * @param {VegaRTECreateElementFunction} h - Create element function.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @returns {VegaRTERenderResult} - The toolbar button render result.
+   */
+  render(h, editorContext) {
+    return h('vega-rich-text-bookmark-editor', {
+      mode: 'insert',
+      name: '',
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      ref: (ref) => {
+        if (ref) {
+          this.editorRef = ref;
+          this.syncPopoverTarget();
+          domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, vegaEventId.VegaChange, 
+          // eslint-disable-next-line jsdoc/require-jsdoc
+          (e) => {
+            this.handleEditorChange(e, editorContext);
+          });
+        }
+      },
+    }, [
+      // The base renderer owns the actual toolbar button ref, so this wrapper
+      // provides a stable external anchor for the insert popover.
+      h('div', {
+        // eslint-disable-next-line jsdoc/require-jsdoc
+        ref: (ref) => {
+          if (ref) {
+            this.buttonWrapperRef = ref;
+            // The editor and wrapper refs can be assigned in either order.
+            this.syncPopoverTarget();
+          }
+        },
+      }, [
+        this.renderButton(h, editorContext, {
+          icon: 'rte-bookmark',
+          tooltip: { text: internalTranslationController.VegaInternalTranslation.t('Bookmark') },
+        }),
+      ]),
+    ]);
+  }
+  /**
+   * @inheritDoc
+   */
+  isDisabled(editorContext) {
+    let result = super.isDisabled(editorContext);
+    const context = this.getExtensionContext(editorContext.host);
+    if (context) {
+      const { getSelectedNodes } = context;
+      const [startNode] = getSelectedNodes();
+      if (startNode) {
+        result || (result = !codeBlock.ActionHandleStrategyRegistry.canHandle(INSERT_BOOKMARK_NODE, startNode.parent));
+      }
+    }
+    return result;
+  }
+  /**
+   * Captures the caret position and the reserved bookmark names before the editor opens.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   */
+  handleButtonClick(editorContext) {
+    // The editor keeps mutating its live range, so the caret has to be copied before the editor popover takes focus.
+    this.pendingRange = editorContext.rteRange.clone();
+    if (this.editorRef) {
+      this.editorRef.reservedNames = collectBookmarkNames(editorContext.host.value);
+      void this.editorRef.show();
+    }
+  }
+  /* istanbul ignore next */
+  /**
+   * @inheritDoc
+   */
+  handleDropdownClick() {
+    // No dropdown used
+  }
+  /**
+   * Anchors the insert popover to the button, because a self anchored popover never opens.
+   */
+  syncPopoverTarget() {
+    // Ref callbacks are invoked independently; assigning only after both are ready
+    // keeps the target setup valid regardless of render callback order.
+    if (this.editorRef && this.buttonWrapperRef && this.editorRef.target !== this.buttonWrapperRef) {
+      this.editorRef.target = this.buttonWrapperRef;
+    }
+  }
+  /**
+   * Inserts the bookmark emitted by the bookmark editor at the captured caret position.
+   *
+   * @param {CustomEvent<{ action: 'save'; name: string } | { action: 'remove' }>} e - The bookmark editor change event.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   */
+  handleEditorChange(e, editorContext) {
+    if (e.detail.action !== 'save') {
+      return;
+    }
+    const rteRange = this.pendingRange;
+    const startNode = rteRange === null || rteRange === void 0 ? void 0 : rteRange.startNode;
+    if (!(startNode === null || startNode === void 0 ? void 0 : startNode.parent)) {
+      return;
+    }
+    const action = new InsertBookmarkNodeAction(rteRange, e.detail.name);
+    startNode.parent.apply(action);
+    if (action.actionHandleResult) {
+      const context = this.getExtensionContext(editorContext.host);
+      context === null || context === void 0 ? void 0 : context.flushValue(context.host.value);
+    }
+    this.pendingRange = null;
+  }
+}
+(() => {
+  internalIconManager.VegaInternalIconManager.register({ 'rte-bookmark': bookmarkIcon });
+})();
+
+// Module scoped so repeated extension instances reuse the same strategy reference instead of registering duplicates.
+const anchorToBookmarkNodeStrategy = new AnchorToBookmarkNodeStrategy();
+/**
+ * Extension that adds bookmark (named anchor) support to the Vega Rich Text Editor.
+ *
+ * A bookmark is a zero-width, named marker that serializes to `<a id="name"></a>` so it can
+ * be used as a local link target.
+ */
+class VegaRTEBookmarkExtension extends linkExtension.VegaRTEExtension {
+  constructor() {
+    super();
+    this.bookmarkRenderer = new RTEBookmarkNodeRenderer();
+    this.registerNode('bookmark', RTEBookmarkNode);
+    this.registerRenderer('bookmark', this.bookmarkRenderer);
+    this.registerElementToNodeDTOClassStrategy(anchorToBookmarkNodeStrategy);
+  }
+  /** @inheritDoc */
+  prepareBeforeLoad(host) {
+    this.registerToolbarButtonRenderer(VegaRTEBookmarkExtension.TOOLBAR_BUTTON_KEY, new RTEBookmarkToolbarButtonRenderer(), host);
+  }
+  /** Removes the per-host bookmark selection listener when the editor is destroyed. */
+  destroyExtension() {
+    var _a;
+    const host = (_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.host;
+    if (host) {
+      this.bookmarkRenderer.teardownRangeHighlight(host);
+    }
+  }
+}
+(() => {
+  const insertBookmarkNodeStrategy = new InsertBookmarkNodeStrategy();
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTETextBlock.typeName, INSERT_BOOKMARK_NODE, insertBookmarkNodeStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(codeBlock.RTEListItemBlock.typeName, INSERT_BOOKMARK_NODE, insertBookmarkNodeStrategy);
+  linkExtension.VegaRTEExtension.registerActionHandleStrategy(RTEBookmarkNode.typeName, UPDATE_BOOKMARK_NAME, new UpdateBookmarkNameStrategy());
+  const deleteBookmarkBeforeTextInterceptor = new DeleteBookmarkBeforeTextInterceptor();
+  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(codeBlock.RTETextBlock.typeName, codeBlock.ModifyContentActionType.DELETE_BLOCK_CONTENT, deleteBookmarkBeforeTextInterceptor);
+  linkExtension.VegaRTEExtension.registerActionHandlerInterceptor(codeBlock.RTEListItemBlock.typeName, codeBlock.ModifyContentActionType.DELETE_BLOCK_CONTENT, deleteBookmarkBeforeTextInterceptor);
+})();
+VegaRTEBookmarkExtension.TOOLBAR_BUTTON_KEY = 'bookmark';
+
+/**
+ * Replace the text node selected content to new text
+ *
+ * @example selectedNode.apply(new ReplaceSelectedTextAction(insertText))
+ */
+class ReplaceSelectedTextAction extends codeBlock.ModifyContentAction {
+  constructor(text, currentRange) {
+    super();
+    this.type = codeBlock.ModifyContentActionType.REPLACE_SELECTED_TEXT;
+    this.textToBeInsert = '';
+    this.textToBeInsert = text;
+    this.currentRange = currentRange;
+  }
+}
+
+/**
+ * Rich Text Editor extension that configures built-in image behavior.
+ */
+class VegaRTEImageExtension extends linkExtension.VegaRTEExtension {
+  constructor(config = {}) {
+    super();
+    this.config = config;
+  }
+  /**
+   * Store config per host so both toolbar-image and inline-image editors
+   * can consistently read the extension settings.
+   *
+   * @param {HTMLElement} host - The host rich text editor element.
+   */
+  prepareBeforeLoad(host) {
+    VegaRTEImageExtension.configStore.set(host, this.config);
+  }
+  /**
+   * Remove config for the current host when the extension is destroyed.
+   */
+  destroyExtension() {
+    var _a;
+    if ((_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.host) {
+      VegaRTEImageExtension.configStore.delete(this.extensionContext.host);
+    }
+  }
+}
+/**
+ * Per-host config store. Declare as static readonly to isolate config per editor host.
+ *
+ * @type {RTEExtensionStateStore<VegaRTEImageExtensionConfig>}
+ */
+VegaRTEImageExtension.configStore = VegaRTEImageExtension.createStateStore();
+
+exports.ActionHandlerInterceptor = ActionHandlerInterceptor;
+exports.InsertNodeToNearestRootAction = InsertNodeToNearestRootAction;
+exports.ReplaceSelectedTextAction = ReplaceSelectedTextAction;
+exports.VegaRTEBookmarkExtension = VegaRTEBookmarkExtension;
+exports.VegaRTEImageExtension = VegaRTEImageExtension;
+exports.VegaRTEToolbarButtonRenderer = VegaRTEToolbarButtonRenderer;
+exports.bookmarkIcon = bookmarkIcon;
+exports.collectBookmarkNames = collectBookmarkNames;