@shelamkoff/rector 1.0.0

package/dist/core/clipboard/CrossBlockEditor.js

@@ -0,0 +1,198 @@
+import { EditorEvent } from '../editorEvents.js'
+
+/** @param {import('../types').IBlock} block */
+function editableElement(block) {
+  const root = block.contentElement
+  if (root.matches('[contenteditable="true"]')) return root
+  return /** @type {HTMLElement | null} */ (root.querySelector('[contenteditable="true"]'))
+}
+
+/**
+ * Operations on cross-block selections (text spanning multiple blocks).
+ *
+ * Cross-block selection is held in `ICrossBlockSelection` (a custom range
+ * since the native browser API can't span editing hosts). This class
+ * encapsulates the multi-step delete sequence:
+ *
+ *  1. Delete tail of last block (from rangeEnd → end of CE).
+ *  2. Remove all middle blocks.
+ *  3. Delete head of first block (from start of CE → rangeStart).
+ *  4. Merge first + last (first block keeps the merged content).
+ *  5. Restore caret at the merge boundary.
+ *
+ * Wrapped in an UNDO_BATCH so the whole operation is one undo step.
+ */
+export class CrossBlockEditor {
+  /** @type {HTMLElement} */
+  #rootEl
+
+  /** @type {import('../types').IBlockManager} */
+  #blocks
+
+  /** @type {import('../types').ISelectionManager} */
+  #selection
+
+  /** @type {import('../types').ICrossBlockSelection} */
+  #crossBlockSelection
+
+  /** @type {import('../types').IEventBus} */
+  #events
+
+  /** @type {string} */
+  #defaultBlockType
+
+  /**
+   * @param {HTMLElement} rootEl
+   * @param {import('../types').IBlockManager} blocks
+   * @param {import('../types').ISelectionManager} selection
+   * @param {import('../types').ICrossBlockSelection} crossBlockSelection
+   * @param {import('../types').IEventBus} events
+   * @param {string} defaultBlockType
+   */
+  constructor(rootEl, blocks, selection, crossBlockSelection, events, defaultBlockType) {
+    this.#rootEl = rootEl
+    this.#blocks = blocks
+    this.#selection = selection
+    this.#crossBlockSelection = crossBlockSelection
+    this.#events = events
+    this.#defaultBlockType = defaultBlockType
+  }
+
+  /**
+   * Place the native caret at the end of a cross-block range.
+   * Required so UndoManager captures the correct caret position when
+   * the next snapshot is taken.
+   *
+   * @param {Range} range
+   */
+  setCaretToRangeEnd(range) {
+    const endNode = range.endContainer
+    const endOffset = range.endOffset
+
+    const endBlock = this.#blocks.getBlockByChildNode(endNode)
+    if (!endBlock) return
+
+    const idx = this.#blocks.getBlockIndex(endBlock.id)
+    if (idx >= 0) this.#blocks.setCurrentIndex(idx)
+
+    endBlock.focus()
+
+    try {
+      const sel = window.getSelection()
+      const r = document.createRange()
+      r.setStart(endNode, endOffset)
+      r.collapse(true)
+      sel?.removeAllRanges()
+      sel?.addRange(r)
+    } catch {
+      // Range may be detached after a focus shift; ignore.
+    }
+  }
+
+  /**
+   * Delete the content covered by a cross-block range and merge the
+   * surviving head + tail into the first block.
+   *
+   * @param {Range} crossRange
+   * @param {(...blocks: import('../types').IBlock[]) => void} notifyChanged
+   */
+  deleteContent(crossRange, notifyChanged) {
+    const blocks = this.#blocks
+
+    const firstBlock = blocks.getBlockByChildNode(crossRange.startContainer)
+    const lastBlock = blocks.getBlockByChildNode(crossRange.endContainer)
+    if (!firstBlock || !lastBlock || firstBlock === lastBlock) return
+
+    const firstIndex = blocks.getBlockIndex(firstBlock.id)
+    const lastIndex = blocks.getBlockIndex(lastBlock.id)
+    if (firstIndex < 0 || lastIndex <= firstIndex) return
+
+    const rangeStart = { node: crossRange.startContainer, offset: crossRange.startOffset }
+    const rangeEnd = { node: crossRange.endContainer, offset: crossRange.endOffset }
+
+    const firstCe = editableElement(firstBlock)
+    const lastCe = editableElement(lastBlock)
+
+    // The cross-block algorithm requires two editable endpoints. Validate
+    // before opening a history batch so malformed/detached ranges cannot
+    // leave UndoManager permanently batching.
+    if (!firstCe || !lastCe) return
+
+    this.#events.emit(EditorEvent.UNDO_BATCH_START)
+    try {
+      // 1. Delete tail of last block.
+      if (lastCe) {
+        try {
+          const delRange = document.createRange()
+          delRange.selectNodeContents(lastCe)
+          delRange.setEnd(rangeEnd.node, rangeEnd.offset)
+          delRange.deleteContents()
+          lastCe.normalize()
+        } catch {
+          // Range may have been invalidated mid-operation; ignore.
+        }
+      }
+
+      // 2. Remove middle blocks (skip first and last).
+      for (let index = lastIndex - 1; index > firstIndex; index--) {
+        blocks.remove(index)
+      }
+
+      // 3. Delete head of first block.
+      if (firstCe) {
+        try {
+          const delRange = document.createRange()
+          delRange.selectNodeContents(firstCe)
+          delRange.setStart(rangeStart.node, rangeStart.offset)
+          delRange.deleteContents()
+          firstCe.normalize()
+        } catch {
+          // ignore
+        }
+      }
+
+      // Caret target = end of remaining text in firstCe (the merge boundary).
+      const caretOffset = (firstCe?.textContent || '').length
+
+      // 4. Merge first + last.
+      if (lastCe !== firstCe) {
+        // Preserve boundary whitespace exactly. Trimming here joins words
+        // when a range ends immediately before a leading space in the tail.
+        const remaining = lastCe.innerHTML
+        if (remaining) {
+          const tpl = document.createElement('template')
+          tpl.innerHTML = remaining
+          firstCe.append(...tpl.content.childNodes)
+        }
+        const index = blocks.getBlockIndex(lastBlock.id)
+        if (index >= 0) blocks.remove(index)
+      }
+
+      blocks.clearSelection()
+      this.#crossBlockSelection.deactivate(this.#rootEl)
+
+      if (blocks.getBlockCount() === 0) blocks.insert(this.#defaultBlockType)
+
+      // 5. Restore caret at the merge boundary.
+      const focusIdx = blocks.getBlockIndex(firstBlock.id)
+      if (focusIdx >= 0) {
+        blocks.setCurrentIndex(focusIdx)
+        const block = blocks.getBlockByIndex(focusIdx)
+        if (block) {
+          block.focus()
+          if (caretOffset > 0) {
+            this.#selection.setCaretToOffset(block.id, caretOffset)
+          } else {
+            this.#selection.setCaretToBlock(block.id, 'start')
+          }
+        }
+      }
+
+      // Mark the surviving block dirty and notify while UndoManager is still
+      // batching, so the final snapshot observes the DOM mutation.
+      notifyChanged(firstBlock)
+    } finally {
+      this.#events.emit(EditorEvent.UNDO_BATCH_END)
+    }
+  }
+}

package/dist/core/clipboard/PasteRouter.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Routing table built from each plugin's `pasteConfig`.
+ *
+ * Three independent maps:
+ *  - tag → plugin (for HTML element matching)
+ *  - file MIME pattern → plugin (for `e.clipboardData.files`)
+ *  - text regex → plugin (for plain-text URL/pattern matching)
+ *
+ * Built once at construction time, then queried by Clipboard during paste.
+ */
+export class PasteRouter {
+    /** @param {Iterable<import('../types.js').BlockPlugin>} plugins */
+    constructor(plugins: Iterable<import("../types.js").BlockPlugin>);
+    /** @param {string} tag @returns {import('../types.js').BlockPlugin | undefined} */
+    findByTag(tag: string): import("../types.js").BlockPlugin | undefined;
+    /**
+     * @param {string} mime
+     * @returns {import('../types.js').BlockPlugin | undefined}
+     */
+    findByFile(mime: string): import("../types.js").BlockPlugin | undefined;
+    /**
+     * @param {string} text
+     * @returns {import('../types.js').BlockPlugin | undefined}
+     */
+    findByPattern(text: string): import("../types.js").BlockPlugin | undefined;
+    #private;
+}

package/dist/core/clipboard/PasteRouter.js

@@ -0,0 +1,86 @@
+/**
+ * Routing table built from each plugin's `pasteConfig`.
+ *
+ * Three independent maps:
+ *  - tag → plugin (for HTML element matching)
+ *  - file MIME pattern → plugin (for `e.clipboardData.files`)
+ *  - text regex → plugin (for plain-text URL/pattern matching)
+ *
+ * Built once at construction time, then queried by Clipboard during paste.
+ */
+export class PasteRouter {
+  /** @type {Map<string, import('../types').BlockPlugin>} */
+  #tagRoutes = new Map()
+
+  /** @type {Array<{ regex: RegExp, plugin: import('../types').BlockPlugin }>} */
+  #fileRoutes = []
+
+  /** @type {Array<{ regex: RegExp, plugin: import('../types').BlockPlugin }>} */
+  #patternRoutes = []
+
+  /** @param {Iterable<import('../types').BlockPlugin>} plugins */
+  constructor(plugins) {
+    for (const plugin of plugins) {
+      const config = plugin.pasteConfig
+      if (!config) continue
+
+      if (config.tags) {
+        for (const tag of config.tags) {
+          this.#tagRoutes.set(tag.toLowerCase(), plugin)
+        }
+      }
+
+      if (config.files) {
+        for (const mime of config.files) {
+          // Convert "image/*" → /^image\/.*$/i
+          const regex = new RegExp(
+            '^' + mime.replace(/[.+]/g, '\\$&').replace(/\*/g, '.*') + '$',
+            'i',
+          )
+          this.#fileRoutes.push({ regex, plugin })
+        }
+      }
+
+      if (config.patterns) {
+        for (const pattern of config.patterns) {
+          this.#patternRoutes.push({ regex: pattern, plugin })
+        }
+      }
+    }
+  }
+
+  /** @param {string} tag @returns {import('../types').BlockPlugin | undefined} */
+  findByTag(tag) {
+    return this.#tagRoutes.get(tag.toLowerCase())
+  }
+
+  /**
+   * @param {string} mime
+   * @returns {import('../types').BlockPlugin | undefined}
+   */
+  findByFile(mime) {
+    return this.#fileRoutes.find((r) => r.regex.test(mime))?.plugin
+  }
+
+  /**
+   * @param {string} text
+   * @returns {import('../types').BlockPlugin | undefined}
+   */
+  findByPattern(text) {
+    return this.#patternRoutes.find((route) => this.#matches(route.regex, text))?.plugin
+  }
+
+  /**
+   * Plugin-owned expressions may be global or sticky. RegExp.test() mutates
+   * lastIndex for both flags, so every routing decision must start from the
+   * same state and leave the expression reusable by the next paste.
+   * @param {RegExp} regex
+   * @param {string} value
+   */
+  #matches(regex, value) {
+    regex.lastIndex = 0
+    const matched = regex.test(value)
+    regex.lastIndex = 0
+    return matched
+  }
+}

package/dist/core/clipboard/pasteInsert.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @typedef {Object} InsertContext
+ * @property {import('../types.js').IBlockManager} blocks
+ * @property {import('../types.js').ISelectionManager} selection
+ * @property {import('../BlockOperations.js').BlockOperations} blockOps
+ * @property {string} defaultBlockType
+ * @property {import('./PasteRouter.js').PasteRouter} router
+ * @property {(...blocks: import('../types.js').IBlock[]) => void} notifyChanged
+ */
+/**
+ * Insert plain text into the editor at the current caret.
+ * Multi-line text becomes one block per non-empty line.
+ *
+ * @param {string} text
+ * @param {InsertContext} ctx
+ */
+export function pastePlainText(text: string, ctx: InsertContext): void;
+/**
+ * Insert HTML into the editor at the current caret.
+ * Splits multi-element HTML into multiple blocks via `extractBlockElements`,
+ * routes known tags to plugins via `pasteConfig.tags`, and falls back to
+ * the default block type for unknown tags.
+ *
+ * @param {string} html
+ * @param {InsertContext} ctx
+ */
+export function pasteHtml(html: string, ctx: InsertContext): void;
+export type InsertContext = {
+    blocks: import("../types.js").IBlockManager;
+    selection: import("../types.js").ISelectionManager;
+    blockOps: import("../BlockOperations.js").BlockOperations;
+    defaultBlockType: string;
+    router: import("./PasteRouter.js").PasteRouter;
+    notifyChanged: (...blocks: import("../types.js").IBlock[]) => void;
+};

package/dist/core/clipboard/pasteInsert.js

@@ -0,0 +1,215 @@
+import { sanitizeHtml } from '../sanitize.js'
+import { extractBlockElements } from './pasteUtils.js'
+
+/**
+ * @typedef {Object} InsertContext
+ * @property {import('../types').IBlockManager} blocks
+ * @property {import('../types').ISelectionManager} selection
+ * @property {import('../BlockOperations').BlockOperations} blockOps
+ * @property {string} defaultBlockType
+ * @property {import('./PasteRouter.js').PasteRouter} router
+ * @property {(...blocks: import('../types').IBlock[]) => void} notifyChanged
+ */
+
+/**
+ * Insert plain text into the editor at the current caret.
+ * Multi-line text becomes one block per non-empty line.
+ *
+ * @param {string} text
+ * @param {InsertContext} ctx
+ */
+export function pastePlainText(text, ctx) {
+  const lines = text.split(/\n/)
+  const nonEmpty = lines.filter((line) => line.length > 0)
+  if (nonEmpty.length === 0) return
+  // Keep the original target before a multi-block paste moves current/focus
+  // to the last inserted block. This existing block is mutated directly and
+  // must be invalidated explicitly for the pre/post-paste history snapshots.
+  const targetBlock = ctx.blocks.getCurrentBlock()
+
+  if (nonEmpty.length === 1) {
+    insertTextOrReplace(/** @type {string} */ (nonEmpty[0]), ctx.blocks)
+    if (targetBlock) ctx.notifyChanged(targetBlock)
+    else ctx.notifyChanged()
+    return
+  }
+
+  insertTextOrReplace(/** @type {string} */ (nonEmpty[0]), ctx.blocks)
+
+  const currentIndex = ctx.blocks.getCurrentIndex()
+  let insertIndex = currentIndex + 1
+
+  for (let i = 1; i < nonEmpty.length; i++) {
+    const escaped = /** @type {string} */ (nonEmpty[i])
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+    ctx.blocks.insert(ctx.defaultBlockType, { text: escaped }, insertIndex)
+    insertIndex++
+  }
+
+  // Focus the last inserted block once (avoid intermediate focus shifts).
+  const lastBlock = ctx.blocks.getBlockByIndex(insertIndex - 1)
+  if (lastBlock) {
+    ctx.blocks.setCurrentIndex(insertIndex - 1)
+    ctx.selection.setCaretToBlock(lastBlock.id, 'end')
+    lastBlock.focus()
+  }
+
+  if (targetBlock) ctx.notifyChanged(targetBlock)
+  else ctx.notifyChanged()
+}
+
+/**
+ * Insert HTML into the editor at the current caret.
+ * Splits multi-element HTML into multiple blocks via `extractBlockElements`,
+ * routes known tags to plugins via `pasteConfig.tags`, and falls back to
+ * the default block type for unknown tags.
+ *
+ * @param {string} html
+ * @param {InsertContext} ctx
+ */
+export function pasteHtml(html, ctx) {
+  // Parse clipboard markup in inert template content. Individual extracted
+  // blocks are sanitized before insertion or handed to an explicit plugin
+  // paste handler; no untrusted subtree is connected to the live document.
+  const template = document.createElement('template')
+  template.innerHTML = html
+
+  const extracted = extractBlockElements(
+    template.content,
+    (tag) => !!ctx.router.findByTag(tag),
+  )
+    // Routed non-text elements (for example IMG/HR) may have no textContent
+    // and still carry meaningful paste data in their attributes.
+    .filter((b) => (b.element.textContent || '').trim() || !!ctx.router.findByTag(b.tag))
+
+  if (extracted.length === 0) return
+
+  const first = /** @type {import('./pasteUtils.js').ExtractedBlock} */ (extracted[0])
+  const targetBlock = ctx.blocks.getCurrentBlock()
+
+  // Single paragraph → inline insert into the current block.
+  if (extracted.length === 1 && first.tag === 'p') {
+    const sanitized = sanitizeHtml(first.element.innerHTML)
+    if (sanitized) insertHtmlAtCaret(sanitized)
+    if (targetBlock) ctx.notifyChanged(targetBlock)
+    else ctx.notifyChanged()
+    return
+  }
+
+  const currentIndex = ctx.blocks.getCurrentIndex()
+  const currentBlock = ctx.blocks.getBlockByIndex(currentIndex)
+  const currentIsEmpty = currentBlock?.isEmpty()
+
+  const firstIsTextLike = first.tag === 'p' || first.tag === 'div'
+
+  if (firstIsTextLike) {
+    const sanitized = sanitizeHtml(first.element.innerHTML)
+    if (sanitized) {
+      if (currentIsEmpty && currentBlock) {
+        currentBlock.contentElement.innerHTML = sanitized
+      } else {
+        insertHtmlAtCaret(sanitized)
+      }
+    }
+  } else {
+    insertBlockFromExtracted(first, currentIndex + 1, ctx)
+  }
+
+  let insertIndex = currentIndex + 1
+  if (!firstIsTextLike) insertIndex++
+
+  for (let i = 1; i < extracted.length; i++) {
+    const item = /** @type {import('./pasteUtils.js').ExtractedBlock} */ (extracted[i])
+    insertBlockFromExtracted(item, insertIndex, ctx)
+    insertIndex++
+  }
+
+  if (extracted.length > 1 || first.tag !== 'p') {
+    const lastIdx = insertIndex - 1
+    const lastBlock = ctx.blocks.getBlockByIndex(lastIdx)
+    if (lastBlock) {
+      ctx.blocks.setCurrentIndex(lastIdx)
+      ctx.selection.setCaretToBlock(lastBlock.id, 'end')
+      lastBlock.focus()
+    }
+  }
+
+  if (firstIsTextLike && targetBlock) ctx.notifyChanged(targetBlock)
+  else ctx.notifyChanged()
+}
+
+/**
+ * @param {import('./pasteUtils.js').ExtractedBlock} extracted
+ * @param {number} index
+ * @param {InsertContext} ctx
+ */
+function insertBlockFromExtracted(extracted, index, ctx) {
+  const plugin = ctx.router.findByTag(extracted.tag)
+
+  if (plugin?.onPaste) {
+    const data = plugin.onPaste({
+      type: 'tag',
+      element: extracted.element,
+      tag: extracted.tag,
+    })
+    if (data) {
+      ctx.blocks.insert(plugin.type, data, index)
+      return
+    }
+  }
+
+  const sanitized = sanitizeHtml(extracted.element.innerHTML)
+  ctx.blocks.insert(ctx.defaultBlockType, { text: sanitized }, index)
+}
+
+/**
+ * Insert text at the native caret. Falls back to overwriting the current
+ * block's content if no native selection exists.
+ *
+ * @param {string} text
+ * @param {import('../types').IBlockReader} blocks
+ */
+function insertTextOrReplace(text, blocks) {
+  const sel = window.getSelection()
+  if (sel && sel.rangeCount > 0) {
+    insertTextAtCaret(text)
+    return
+  }
+  const block = blocks.getCurrentBlock()
+  if (block) block.contentElement.textContent = text
+}
+
+/** @param {string} text */
+function insertTextAtCaret(text) {
+  const sel = window.getSelection()
+  if (!sel || sel.rangeCount === 0) return
+  const range = sel.getRangeAt(0)
+  range.deleteContents()
+  const textNode = document.createTextNode(text)
+  range.insertNode(textNode)
+  range.setStartAfter(textNode)
+  range.collapse(true)
+  sel.removeAllRanges()
+  sel.addRange(range)
+}
+
+/** @param {string} html */
+function insertHtmlAtCaret(html) {
+  const sel = window.getSelection()
+  if (!sel || sel.rangeCount === 0) return
+  const range = sel.getRangeAt(0)
+  range.deleteContents()
+  const template = document.createElement('template')
+  template.innerHTML = html
+  const frag = template.content
+  const lastNode = frag.lastChild
+  range.insertNode(frag)
+  if (lastNode) {
+    range.setStartAfter(lastNode)
+    range.collapse(true)
+    sel.removeAllRanges()
+    sel.addRange(range)
+  }
+}

package/dist/core/clipboard/pasteUtils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @typedef {Object} ExtractedBlock
+ * @property {string} tag Lowercase tag name (for example, `p`, `pre`, or `h2`).
+ * @property {HTMLElement} element Extracted DOM element.
+ */
+/**
+ * Extract block-level elements from parsed HTML.
+ * Returns an array of {tag, element} objects for each block-level element found.
+ * Inline-only content is returned as a synthetic 'p' wrapper.
+ *
+ * @param {ParentNode} container Inert parsed HTML container.
+ * @param {(tag: string) => boolean} [isRoutedTag] Tests plugin-owned container tags.
+ * @returns {ExtractedBlock[]}
+ */
+export function extractBlockElements(container: ParentNode, isRoutedTag?: (tag: string) => boolean): ExtractedBlock[];
+export type ExtractedBlock = {
+    /**
+     * Lowercase tag name (for example, `p`, `pre`, or `h2`).
+     */
+    tag: string;
+    /**
+     * Extracted DOM element.
+     */
+    element: HTMLElement;
+};

package/dist/core/clipboard/pasteUtils.js

@@ -0,0 +1,98 @@
+/** Block-level tags that represent separate paragraphs */
+const BLOCK_TAGS = new Set([
+  'p', 'div', 'li', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+  'blockquote', 'pre', 'tr', 'td', 'th', 'figure',
+])
+
+/**
+ * Create a paragraph that remains owned by inert template content. Cloning
+ * untrusted media into a regular detached element can still start loading and
+ * fire event attributes before the paste sanitizer gets a chance to run.
+ * @returns {HTMLParagraphElement}
+ */
+function createInertParagraph() {
+  const template = document.createElement('template')
+  template.innerHTML = '<p></p>'
+  return /** @type {HTMLParagraphElement} */ (template.content.firstElementChild)
+}
+
+/**
+ * @typedef {Object} ExtractedBlock
+ * @property {string} tag Lowercase tag name (for example, `p`, `pre`, or `h2`).
+ * @property {HTMLElement} element Extracted DOM element.
+ */
+
+/**
+ * Extract block-level elements from parsed HTML.
+ * Returns an array of {tag, element} objects for each block-level element found.
+ * Inline-only content is returned as a synthetic 'p' wrapper.
+ *
+ * @param {ParentNode} container Inert parsed HTML container.
+ * @param {(tag: string) => boolean} [isRoutedTag] Tests plugin-owned container tags.
+ * @returns {ExtractedBlock[]}
+ */
+export function extractBlockElements(container, isRoutedTag = () => false) {
+  /** @type {ExtractedBlock[]} */
+  const results = []
+  const isBlockTag = (tag) => BLOCK_TAGS.has(tag) || isRoutedTag(tag)
+
+  const hasBlockChild = Array.from(container.children).some(
+    c => isBlockTag(c.tagName.toLowerCase())
+  )
+
+  if (!hasBlockChild) {
+    // Wrap flat HTML without block structure as a single paragraph.
+    const p = createInertParagraph()
+    for (const child of container.childNodes) p.appendChild(child.cloneNode(true))
+    if (p.innerHTML.trim()) {
+      results.push({ tag: 'p', element: p })
+    }
+    return results
+  }
+
+  /**
+   * @param {import('../types').DOMNode} node
+   */
+  const walk = (node) => {
+    for (const child of node.childNodes) {
+      if (child.nodeType === Node.TEXT_NODE) {
+        const text = child.textContent?.trim()
+        if (text) {
+          const p = createInertParagraph()
+          p.textContent = text
+          results.push({ tag: 'p', element: p })
+        }
+        continue
+      }
+
+      if (child.nodeType !== Node.ELEMENT_NODE) continue
+
+      const el = /** @type {HTMLElement} */ (child)
+      const tag = el.tagName.toLowerCase()
+
+      if (tag === 'br') continue
+
+      if (isBlockTag(tag)) {
+        results.push({ tag, element: el })
+      } else {
+        // Inline or unknown — check for nested block children
+        const nested = Array.from(el.children).some(
+          c => isBlockTag(c.tagName.toLowerCase())
+        )
+
+        if (nested) {
+          walk(el)
+        } else {
+          const p = createInertParagraph()
+          for (const child of el.childNodes) p.appendChild(child.cloneNode(true))
+          if (p.innerHTML.trim()) {
+            results.push({ tag: 'p', element: p })
+          }
+        }
+      }
+    }
+  }
+
+  walk(container)
+  return results
+}