@shelamkoff/rector 1.0.0

package/dist/inline-tools/link.js

@@ -0,0 +1,251 @@
+import { el } from '../core/dom.js'
+import { sanitizeUrl } from '../shared/sanitize/sanitizeUrl.js'
+import {
+  ICON_LINK, ICON_CHECK, ICON_UNLINK,
+  removeEmptyInlineTags,
+  saveSelectionOffsets,
+  restoreSelectionOffsets,
+  getContentEditable,
+  getWalkRoot,
+  collectTextTargets,
+  normalizeAfterEdit,
+  createBackButton,
+} from './utils.js'
+
+/**
+ * Return every link touched by a range. The walk root is deliberately the
+ * contenteditable (or the common editor root for a cross-block selection),
+ * rather than the range's common ancestor: the latter can be the link itself,
+ * and querySelectorAll() never includes the element it is called on.
+ *
+ * Keeping detection, active-state rendering, and unlinking on this single
+ * query prevents the three code paths from disagreeing about the selection.
+ *
+ * @param {Range} range
+ * @returns {HTMLAnchorElement[]}
+ */
+function getIntersectingLinks(range) {
+  const walkRoot = getWalkRoot(range)
+  if (!walkRoot) return []
+
+  /** @type {HTMLAnchorElement[]} */
+  const candidates = []
+  if (walkRoot instanceof HTMLAnchorElement) candidates.push(walkRoot)
+  candidates.push(...walkRoot.querySelectorAll('a'))
+
+  return candidates.filter((candidate) => {
+    try {
+      return range.intersectsNode(candidate)
+    } catch {
+      return false
+    }
+  })
+}
+
+/**
+ * Create the link inline tool with a drill-down URL input panel.
+ * @param {string} linkPlaceholder — i18n placeholder for the input
+ * @param {string} linkLabel — i18n label for the tool
+ * @param {{ apply?: string, unlink?: string }} [actionLabels]
+ * @param {import('../types').ICrossBlockSelection | null} [cbs]
+ * @returns {import('../types').InlineTool}
+ */
+export function createLinkTool(linkPlaceholder, linkLabel, actionLabels = {}, cbs = null) {
+  return {
+    type: 'link',
+    title: linkLabel,
+    icon: ICON_LINK,
+    tag: 'a',
+    shortcut: 'Mod+K',
+    getTitle(active) {
+      return active ? (actionLabels.unlink || 'Unlink') : linkLabel
+    },
+
+    getIcon(active) {
+      return active ? ICON_UNLINK : ICON_LINK
+    },
+
+    isActive(selection) {
+      const range = cbs?.range || selection?.range
+      if (!range) {
+        const sel = window.getSelection()
+        if (sel?.anchorNode) return !!sel.anchorNode.parentElement?.closest('a')
+        return false
+      }
+      return getIntersectingLinks(range).length > 0
+    },
+
+    toggle(selection) {
+      // Toggle: if links exist in selection — remove them all
+      const actualRange = cbs?.range || selection?.range
+      if (!actualRange) return
+      const saved = saveSelectionOffsets(actualRange)
+
+      const walkRoot = getWalkRoot(actualRange)
+      if (!walkRoot) return
+
+      for (const link of getIntersectingLinks(actualRange)) {
+        const parent = link.parentNode
+        while (link.firstChild) parent?.insertBefore(link.firstChild, link)
+        link.remove()
+      }
+
+      normalizeAfterEdit(getContentEditable(actualRange), walkRoot)
+
+      restoreSelectionOffsets(cbs, saved)
+    },
+
+    /**
+     * Render the drill-down panel with URL input, apply, unlink buttons.
+     * Returns null when active (links in selection) — signals toggle behavior instead.
+     * @param {import('../types').InlineToolActionContext} ctx
+     * @returns {HTMLElement | null}
+     */
+    renderActions(ctx) {
+      // When links exist, return null to trigger toggle() (remove links)
+      const currentSel = window.getSelection()
+      if (currentSel?.anchorNode) {
+        const range = cbs?.range || (currentSel.rangeCount ? currentSel.getRangeAt(0) : null)
+        if (range && getIntersectingLinks(range).length > 0) return null
+      }
+
+      const panel = el('div', 'oe-inline-toolbar__panel oe-inline-toolbar__panel--link')
+
+      const backBtn = createBackButton(ctx)
+
+      // URL input
+      const input = /** @type {HTMLInputElement} */ (el('input', 'oe-inline-toolbar__link-input', {
+        type: 'url',
+        placeholder: linkPlaceholder,
+      }))
+      input.addEventListener('keydown', (e) => {
+        e.stopPropagation()
+        if (e.key === 'Enter') {
+          e.preventDefault()
+          applyLink()
+        }
+        if (e.key === 'Escape') {
+          e.preventDefault()
+          ctx.close()
+        }
+      })
+      // Prevent input events from bubbling to wireInputTracking
+      // (typing a URL is not a document content change).
+      input.addEventListener('input', (e) => e.stopPropagation())
+
+      // Apply button
+      const applyLabel = actionLabels.apply || 'Apply'
+      const applyBtn = el('button', 'oe-inline-tool oe-inline-tool--apply', { type: 'button' })
+      applyBtn.innerHTML = ICON_CHECK
+      applyBtn.addEventListener('mouseenter', () => ctx.showTooltip(applyBtn, applyLabel))
+      applyBtn.addEventListener('mouseleave', () => ctx.hideTooltip())
+      applyBtn.addEventListener('mousedown', (e) => {
+        e.preventDefault()
+        e.stopPropagation()
+      })
+      applyBtn.addEventListener('click', (e) => {
+        e.preventDefault()
+        e.stopPropagation()
+        applyLink()
+      })
+
+      // Unlink button
+      const unlinkLabel = actionLabels.unlink || 'Unlink'
+      const unlinkBtn = el('button', 'oe-inline-tool oe-inline-tool--unlink', { type: 'button' })
+      unlinkBtn.innerHTML = ICON_UNLINK
+      unlinkBtn.addEventListener('mouseenter', () => ctx.showTooltip(unlinkBtn, unlinkLabel))
+      unlinkBtn.addEventListener('mouseleave', () => ctx.hideTooltip())
+      unlinkBtn.addEventListener('mousedown', (e) => {
+        e.preventDefault()
+        e.stopPropagation()
+      })
+      unlinkBtn.addEventListener('click', (e) => {
+        e.preventDefault()
+        e.stopPropagation()
+        removeLink()
+      })
+
+      // Check if already inside a link
+      const sel = window.getSelection()
+      const existingAnchor = sel?.anchorNode?.parentElement?.closest('a')
+      if (existingAnchor) {
+        input.value = existingAnchor.getAttribute('href') || ''
+        unlinkBtn.style.display = ''
+      } else {
+        unlinkBtn.style.display = 'none'
+      }
+
+      function applyLink() {
+        const url = input.value.trim()
+        if (!url) return
+
+        ctx.restoreSelection()
+
+        // Use cross-block range if available
+        const sel = window.getSelection()
+        const actualRange = cbs?.range || (sel && sel.rangeCount ? sel.getRangeAt(0) : null)
+        if (!actualRange) return
+
+        const saved = saveSelectionOffsets(actualRange)
+
+        ctx.mutate(() => {
+          // Wrap each text node in the range with an <a> tag
+          const walkRoot = getWalkRoot(actualRange)
+          if (walkRoot) {
+            const targets = collectTextTargets(walkRoot, actualRange)
+            for (let i = targets.length - 1; i >= 0; i--) {
+              const t = targets[i]
+              if (!t) continue
+              const { node, startOffset, endOffset } = t
+              let targetNode = node
+              if (endOffset < node.length) node.splitText(endOffset)
+              if (startOffset > 0) targetNode = /** @type {Text} */ (node.splitText(startOffset))
+
+              // Skip if already inside a link
+              if (targetNode.parentElement?.closest('a')) continue
+
+              const anchor = document.createElement('a')
+              anchor.href = sanitizeUrl(url)
+              anchor.rel = 'noopener noreferrer'
+              anchor.target = '_blank'
+              targetNode.parentNode?.insertBefore(anchor, targetNode)
+              anchor.appendChild(targetNode)
+            }
+            normalizeAfterEdit(getContentEditable(actualRange), walkRoot)
+          }
+
+          restoreSelectionOffsets(cbs, saved)
+        })
+        ctx.close()
+      }
+
+      function removeLink() {
+        ctx.restoreSelection()
+        const s = window.getSelection()
+        const anchor = s?.anchorNode?.parentElement?.closest('a')
+        ctx.mutate(() => {
+          if (anchor) {
+            const parent = anchor.parentNode
+            const fragment = document.createDocumentFragment()
+            while (anchor.firstChild) {
+              fragment.appendChild(anchor.firstChild)
+            }
+            anchor.replaceWith(fragment)
+            removeEmptyInlineTags(parent)
+          }
+        })
+        ctx.close()
+      }
+
+      panel.appendChild(backBtn)
+      panel.appendChild(input)
+      panel.appendChild(applyBtn)
+      panel.appendChild(unlinkBtn)
+
+      // Focus input after panel is mounted
+      requestAnimationFrame(() => input.focus())
+
+      return panel
+    },
+  }
+}

package/dist/inline-tools/marker.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Create the built-in text-highlight control (`<mark>`, `Mod+Shift+H`).
+ *
+ * @param {string} label
+ * @param {import('../types.js').ICrossBlockSelection | null} [cbs]
+ * @returns {import('../types.js').InlineTool}
+ */
+export function createMarkerTool(label: string, cbs?: import("../types.js").ICrossBlockSelection | null): import("../types.js").InlineTool;

package/dist/inline-tools/marker.js

@@ -0,0 +1,12 @@
+import { createSimpleInlineTool, ICON_HIGHLIGHT } from './utils.js'
+
+/**
+ * Create the built-in text-highlight control (`<mark>`, `Mod+Shift+H`).
+ *
+ * @param {string} label
+ * @param {import('../types').ICrossBlockSelection | null} [cbs]
+ * @returns {import('../types').InlineTool}
+ */
+export function createMarkerTool(label, cbs) {
+  return createSimpleInlineTool('marker', label, ICON_HIGHLIGHT, 'mark', 'Mod+Shift+H', cbs ?? undefined)
+}

package/dist/inline-tools/scriptTool.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Create combined superscript/subscript tool with a dropdown panel.
+ * @param {{ sup: string, sub: string, none: string }} labels
+ * @param {import('../types.js').ICrossBlockSelection | null} [cbs]
+ * @returns {import('../types.js').InlineTool}
+ */
+export function createScriptTool(labels: {
+    sup: string;
+    sub: string;
+    none: string;
+}, cbs?: import("../types.js").ICrossBlockSelection | null): import("../types.js").InlineTool;

package/dist/inline-tools/scriptTool.js

@@ -0,0 +1,149 @@
+import {
+  toggleTag,
+  removeEmptyInlineTags,
+  saveSelectionOffsets,
+  restoreSelectionOffsets,
+  createBackButton,
+  getWalkRoot,
+} from './utils.js'
+
+const ICON_SUP = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 7l8 10m-8 0l8 -10"/><path d="M21 11h-4l3.5 -4a1.73 1.73 0 0 0 -3.5 -1"/></svg>'
+const ICON_SUB = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 7l8 10m-8 0l8 -10"/><path d="M21 20h-4l3.5 -4a1.73 1.73 0 0 0 -3.5 -1"/></svg>'
+const ICON_NONE = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 7l8 10m-8 0l8 -10"/></svg>'
+
+/**
+ * Detect which script mode the selection is in.
+ * @returns {'sup' | 'sub' | 'none'}
+ */
+function getCurrentScript() {
+  const sel = window.getSelection()
+  if (!sel?.anchorNode) return 'none'
+  const node = sel.anchorNode.nodeType === Node.ELEMENT_NODE
+    ? /** @type {HTMLElement} */ (sel.anchorNode)
+    : sel.anchorNode.parentElement
+  if (node?.closest('sup')) return 'sup'
+  if (node?.closest('sub')) return 'sub'
+  return 'none'
+}
+
+/**
+ * Remove all <sup> and <sub> tags that intersect the range by unwrapping them.
+ * Walks up to the contenteditable to ensure we find wrapping tags.
+ * @param {Range} range
+ */
+function removeAllScriptTags(range) {
+  // Use the contenteditable (or common editor root for cross-block ranges),
+  // not commonAncestorContainer. The common ancestor can itself be <sup> or
+  // <sub>, and querySelectorAll() does not include the receiver element.
+  const root = getWalkRoot(range)
+  if (!root) return
+
+  const tags = []
+  if (root.matches('sup, sub')) tags.push(root)
+  tags.push(...root.querySelectorAll('sup, sub'))
+  for (const tag of tags) {
+    if (!range.intersectsNode(tag)) continue
+    if (tag.closest('[data-inline-plugin]')) continue
+    const parent = tag.parentNode
+    if (!parent) continue
+    while (tag.firstChild) parent.insertBefore(tag.firstChild, tag)
+    tag.remove()
+  }
+
+  // Clean up empty inline tags and normalize
+  removeEmptyInlineTags(root)
+}
+
+/**
+ * Create combined superscript/subscript tool with a dropdown panel.
+ * @param {{ sup: string, sub: string, none: string }} labels
+ * @param {import('../types').ICrossBlockSelection | null} [cbs]
+ * @returns {import('../types').InlineTool}
+ */
+export function createScriptTool(labels, cbs = null) {
+  const modes = [
+    { tag: 'sup', icon: ICON_SUP, title: labels.sup, key: 'sup' },
+    { tag: 'sub', icon: ICON_SUB, title: labels.sub, key: 'sub' },
+    { tag: '',    icon: ICON_NONE, title: labels.none, key: 'none' },
+  ]
+
+  return {
+    type: 'script',
+    title: labels.sup,
+    icon: ICON_SUP,
+
+    getIcon() {
+      const c = getCurrentScript()
+      return c === 'sub' ? ICON_SUB : ICON_SUP
+    },
+
+    getTitle() {
+      const c = getCurrentScript()
+      if (c === 'sup') return labels.sup
+      if (c === 'sub') return labels.sub
+      return labels.sup
+    },
+
+    isActive() {
+      return getCurrentScript() !== 'none'
+    },
+
+    toggle() {
+      // no-op: opens renderActions panel
+    },
+
+    renderActions(ctx) {
+      const panel = document.createElement('div')
+      panel.className = 'oe-inline-toolbar__panel oe-inline-toolbar__script-panel'
+
+      panel.appendChild(createBackButton(ctx))
+
+      const current = getCurrentScript()
+
+      for (const mode of modes) {
+        const btn = document.createElement('button')
+        btn.type = 'button'
+        btn.className = 'oe-inline-tool'
+        btn.innerHTML = mode.icon
+        if (current === mode.key && mode.key !== 'none') btn.classList.add('oe-inline-tool--active')
+
+        btn.addEventListener('mouseenter', () => ctx.showTooltip(btn, mode.title))
+        btn.addEventListener('mouseleave', () => ctx.hideTooltip())
+        btn.addEventListener('mousedown', (e) => { e.preventDefault(); e.stopPropagation() })
+        btn.addEventListener('click', (e) => {
+          e.preventDefault()
+          e.stopPropagation()
+          ctx.restoreSelection()
+
+          const sel = window.getSelection()
+          if (!sel || !sel.rangeCount) { ctx.close(); return }
+          // Use cross-block range if available (native range is clipped to one contenteditable)
+          const range = cbs?.range || sel.getRangeAt(0)
+
+          const saved = saveSelectionOffsets(range)
+
+          ctx.mutate(() => {
+            // Step 1: Always remove ALL existing sup/sub tags in range
+            removeAllScriptTags(range)
+
+            // Restore selection after DOM cleanup (normalize invalidates range)
+            restoreSelectionOffsets(cbs, saved)
+
+            // Step 2: If target is different from current (not toggling off), wrap with new tag
+            if (mode.tag && mode.key !== current) {
+              const newRange = (saved.crossOffsets ? cbs?.range : null) || (sel.rangeCount ? sel.getRangeAt(0) : null)
+              if (newRange) {
+                toggleTag(mode.tag, newRange)
+              }
+            }
+          })
+
+          ctx.close()
+        })
+        panel.appendChild(btn)
+      }
+
+      return panel
+    },
+  }
+}

package/dist/inline-tools/strikethrough.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Create the built-in strikethrough control (`<s>`, `Mod+Shift+S`).
+ *
+ * @param {string} label
+ * @param {import('../types.js').ICrossBlockSelection | null} [cbs]
+ * @returns {import('../types.js').InlineTool}
+ */
+export function createStrikethroughTool(label: string, cbs?: import("../types.js").ICrossBlockSelection | null): import("../types.js").InlineTool;

package/dist/inline-tools/strikethrough.js

@@ -0,0 +1,12 @@
+import { createSimpleInlineTool, ICON_STRIKETHROUGH } from './utils.js'
+
+/**
+ * Create the built-in strikethrough control (`<s>`, `Mod+Shift+S`).
+ *
+ * @param {string} label
+ * @param {import('../types').ICrossBlockSelection | null} [cbs]
+ * @returns {import('../types').InlineTool}
+ */
+export function createStrikethroughTool(label, cbs) {
+  return createSimpleInlineTool('strikethrough', label, ICON_STRIKETHROUGH, 's', 'Mod+Shift+S', cbs ?? undefined)
+}

package/dist/inline-tools/utils.d.ts

@@ -0,0 +1,220 @@
+/**
+ * Remove empty inline wrapper tags and normalize text nodes.
+ * Called after any DOM mutation that unwraps/removes inline formatting.
+ * @param {Node | null} parent
+ * @returns {void}
+ */
+export function removeEmptyInlineTags(parent: Node | null): void;
+/**
+ * Wrap or unwrap a selection with an inline tag.
+ * @param {string} tagName
+ * @param {Range} range
+ * @param {(element: HTMLElement) => boolean} [matches]
+ * @returns {void}
+ */
+export function toggleTag(tagName: string, range: Range, matches?: (element: HTMLElement) => boolean): void;
+/**
+ * Find the closest .oe-editor root from a DOM node.
+ * Avoids global querySelector — works with multiple editor instances.
+ * @param {Node | null | undefined} [node]
+ * @returns {HTMLElement | null}
+ */
+export function getEditorRoot(node?: Node | null | undefined): HTMLElement | null;
+/**
+ * Clear the stored cross-block range (call after DOM mutations that
+ * invalidate the range's node references).
+ * @param {import('../types.js').ICrossBlockSelection | null} [cbs]
+ * @param {Node} [contextNode] - any node inside the editor for scoping
+ * @returns {void}
+ */
+export function clearCrossBlockRange(cbs?: import("../types.js").ICrossBlockSelection | null, contextNode?: Node): void;
+/**
+ * Find the text node and offset at a given character position.
+ * @param {Node} container
+ * @param {number} charOffset
+ * @param {'start' | 'end'} [bias='start'] - when the offset lands exactly at a
+ *   node boundary, 'start' prefers the beginning of the next node (for range
+ *   start points), 'end' prefers the end of the current node (for range end
+ *   points). This avoids creating ranges that inadvertently cross into adjacent
+ *   inline wrappers.
+ * @returns {{ node: Node, offset: number } | null}
+ */
+export function findNodeAtOffset(container: Node, charOffset: number, bias?: "start" | "end"): {
+    node: Node;
+    offset: number;
+} | null;
+/**
+ * Save cross-block range as block IDs + character offsets (survives DOM mutations).
+ * @param {Range} range
+ * @returns {{ editorRoot: HTMLElement, startBlockId: string, endBlockId: string, startFieldIndex: number, endFieldIndex: number, startOffset: number, endOffset: number } | null}
+ */
+export function saveCrossBlockOffsets(range: Range): {
+    editorRoot: HTMLElement;
+    startBlockId: string;
+    endBlockId: string;
+    startFieldIndex: number;
+    endFieldIndex: number;
+    startOffset: number;
+    endOffset: number;
+} | null;
+/**
+ * Restore cross-block range from saved offsets. Updates CrossBlockSelection and CSS Highlight.
+ * @param {import('../types.js').ICrossBlockSelection | null} cbs
+ * @param {{ editorRoot: HTMLElement, startBlockId: string, endBlockId: string, startFieldIndex?: number, endFieldIndex?: number, startOffset: number, endOffset: number }} offsets
+ * @returns {Range | null}
+ */
+export function restoreCrossBlockRange(cbs: import("../types.js").ICrossBlockSelection | null, offsets: {
+    editorRoot: HTMLElement;
+    startBlockId: string;
+    endBlockId: string;
+    startFieldIndex?: number;
+    endFieldIndex?: number;
+    startOffset: number;
+    endOffset: number;
+}): Range | null;
+/**
+ * Check if a selection spans multiple .oe-block elements.
+ * @param {import('../types.js').ICrossBlockSelection | null} [cbs]
+ * @returns {HTMLElement[] | null} Array of plugin-owned block roots, or null if single-block
+ */
+export function getSelectedBlockElements(cbs?: import("../types.js").ICrossBlockSelection | null): HTMLElement[] | null;
+/**
+ * Dispatch a synthetic input event on the nearest contenteditable to trigger
+ * undo/redo snapshot via EditorFacade.onInput → editor:changed.
+ * @param {Node} [contextNode] - any node inside the editor for scoping
+ * @returns {void}
+ */
+export function notifyEditorChanged(contextNode?: Node): void;
+/**
+ * Create a simple tag-based inline tool.
+ * @param {string} type
+ * @param {string} title
+ * @param {string} icon
+ * @param {string} tag
+ * @param {string} [shortcut]
+ * @param {import('../types.js').ICrossBlockSelection} [cbs]
+ * @returns {import('../types.js').InlineTool}
+ */
+export function createSimpleInlineTool(type: string, title: string, icon: string, tag: string, shortcut?: string, cbs?: import("../types.js").ICrossBlockSelection): import("../types.js").InlineTool;
+/**
+ * Find the contentEditable block element from the current selection.
+ * @returns {HTMLElement | null}
+ */
+export function getBlockElement(): HTMLElement | null;
+/**
+ * Find the plugin-owned root of the block containing the current selection.
+ * Unlike {@link getBlockElement}, this returns the block content root rather
+ * than one nested editable field, so block-level settings survive plugins
+ * with several text fields.
+ * @returns {HTMLElement | null}
+ */
+export function getBlockContentElement(): HTMLElement | null;
+/**
+ * Find the contentEditable ancestor of a range's start.
+ * Returns null for cross-block ranges (start and end in different contenteditables).
+ * @param {Range} range
+ * @returns {HTMLElement | null}
+ */
+export function getContentEditable(range: Range): HTMLElement | null;
+/**
+ * Resolve the DOM root to walk for range operations.
+ * Uses contenteditable for single-block ranges, commonAncestorContainer for cross-block.
+ * @param {Range} range
+ * @returns {HTMLElement | null}
+ */
+export function getWalkRoot(range: Range): HTMLElement | null;
+/**
+ * Collect text nodes within a range, clipped to range boundaries.
+ * @param {HTMLElement} walkRoot
+ * @param {Range} range
+ * @returns {{ node: Text, startOffset: number, endOffset: number }[]}
+ */
+export function collectTextTargets(walkRoot: HTMLElement, range: Range): {
+    node: Text;
+    startOffset: number;
+    endOffset: number;
+}[];
+/**
+ * Normalize contenteditables after DOM manipulation.
+ * @param {HTMLElement | null} singleCe - single contenteditable (null for cross-block)
+ * @param {HTMLElement} walkRoot
+ * @returns {void}
+ */
+export function normalizeAfterEdit(singleCe: HTMLElement | null, walkRoot: HTMLElement): void;
+/**
+ * @typedef {Object} SavedOffsets
+ * @property {{ editorRoot: HTMLElement, startBlockId: string, endBlockId: string, startFieldIndex: number, endFieldIndex: number, startOffset: number, endOffset: number } | null} crossOffsets - Serialized selection spanning multiple editable block fields.
+ * @property {{ ce: Node, start: number, end: number } | null} singleOffsets - Text offsets and owning editable node for a selection contained in one field.
+ */
+/**
+ * Save selection offsets (cross-block or single-block) before DOM mutation.
+ * @param {Range} range
+ * @returns {SavedOffsets}
+ */
+export function saveSelectionOffsets(range: Range): SavedOffsets;
+/**
+ * Restore selection from saved offsets after DOM mutation.
+ * @param {import('../types.js').ICrossBlockSelection | null} cbs
+ * @param {SavedOffsets} saved
+ * @returns {void}
+ */
+export function restoreSelectionOffsets(cbs: import("../types.js").ICrossBlockSelection | null, saved: SavedOffsets): void;
+/**
+ * Create a standard back button for inline toolbar drill-down panels.
+ * @param {{ close(): void }} ctx
+ * @returns {HTMLElement}
+ */
+export function createBackButton(ctx: {
+    close(): void;
+}): HTMLElement;
+/** SVG markup for the bold formatting control. */
+export const ICON_BOLD: string;
+/** SVG markup for the italic formatting control. */
+export const ICON_ITALIC: string;
+/** SVG markup for the link formatting control. */
+export const ICON_LINK: string;
+/** SVG markup for the inline-code formatting control. */
+export const ICON_CODE: string;
+/** SVG markup for the text-highlight formatting control. */
+export const ICON_HIGHLIGHT: string;
+/** SVG markup for the strikethrough formatting control. */
+export const ICON_STRIKETHROUGH: string;
+/** SVG markup for the left-alignment control. */
+export const ICON_ALIGN_LEFT: string;
+/** SVG markup for the center-alignment control. */
+export const ICON_ALIGN_CENTER: string;
+/** SVG markup for the right-alignment control. */
+export const ICON_ALIGN_RIGHT: string;
+/** SVG markup for the justified-alignment control. */
+export const ICON_ALIGN_JUSTIFY: string;
+/** SVG markup for the remove-link control. */
+export const ICON_UNLINK: string;
+/** SVG markup for confirmation controls. */
+export const ICON_CHECK: string;
+/** SVG markup for the clear-formatting control. */
+export const ICON_CLEAR: string;
+export type SavedOffsets = {
+    /**
+     * - Serialized selection spanning multiple editable block fields.
+     */
+    crossOffsets: {
+        editorRoot: HTMLElement;
+        startBlockId: string;
+        endBlockId: string;
+        startFieldIndex: number;
+        endFieldIndex: number;
+        startOffset: number;
+        endOffset: number;
+    } | null;
+    /**
+     * - Text offsets and owning editable node for a selection contained in one field.
+     */
+    singleOffsets: {
+        ce: Node;
+        start: number;
+        end: number;
+    } | null;
+};
+import { ICON_BACK } from '../core/icons.js';
+import { getTextOffset } from '../core/textOffset.js';
+export { ICON_BACK, getTextOffset };