Text node position offsets include consumed blockquote continuation prefixes

[adri1wald]

Initial checklist

• I read the support docs
• I read the contributing guide
• I agree to follow the code of conduct
• I searched issues and couldn't find anything (or linked relevant results below)

Affected packages and versions

mdast-util-from-markdown@2.0.2 (via remark-parse@11.0.0)

Steps to reproduce

Parse a blockquote with a continuation line:

import { unified } from 'unified'
import remarkParse from 'remark-parse'
import remarkRehype from 'remark-rehype'

const content =
  "Hello:\n\n" +
  "> *\"Quote line one.\"*\n" +
  "> Continuation line.\n\n" +
  "After."

const processor = unified().use(remarkParse).use(remarkRehype)
const tree = processor.runSync(processor.parse(content))

// Find the text node containing "Continuation line."
function findText(node) {
  if (node.type === 'text' && node.value.includes('Continuation'))
    return node
  for (const child of node.children || []) {
    const r = findText(child)
    if (r) return r
  }
}

const textNode = findText(tree)
const start = textNode.position.start.offset
const end = textNode.position.end.offset

console.log('value:', JSON.stringify(textNode.value))
console.log('value.length:', textNode.value.length)
console.log('offset span:', end - start)
console.log('source.slice(start, end):', JSON.stringify(content.slice(start, end)))

Output:

value: "\nContinuation line."
value.length: 20
offset span: 22
source.slice(start, end): "\n> Continuation line."

Expected behavior

source.slice(position.start.offset, position.end.offset) should equal node.value (offset span should match value length). This contract holds for other constructs like list items.

Actual behavior

The text node spans a blockquote continuation line boundary. The > prefix (2 chars) is correctly stripped from node.value, but position.start.offset / position.end.offset still reference the raw source range that includes the prefix.

Each continuation line within a text node's span adds +2 drift between the offset span and value length. For a 3-line blockquote this becomes +4, etc.

This makes it impossible to reliably map a known source offset to an index within node.value using offset - position.start.offset, which breaks downstream consumers that use positions for source mapping (e.g. rehype plugins that need to locate ranges within text nodes).

A possible fix: emit separate text nodes per continuation line so each node's position only spans content after the > prefix.

[wooorm]

Hi! No, that’s not how offsets work. The actual behavior is intended.

An AST is abstract. That is intentional. Splitting things up is verbose, and thus hard to work with, and in essence, not abstract. But concrete. See https://github.com/syntax-tree/unist#syntax-tree, and look at what https://github.com/micromark/micromark supports

[github-actions]

Hi! This was closed. Team: If this was fixed, please add phase/solved. Otherwise, please add one of the no/* labels.

[wooorm]

For reference, a simplified, more conventional example:

import remarkParse from "remark-parse";
import assert from "node:assert/strict";
import { unified } from "unified";
import { visit } from "unist-util-visit";

const value = "> *a*\n> b";

const tree = unified().use(remarkParse).parse(value);

visit(tree, function (node) {
  if (node.type === "text" && node.value.includes("b")) {
    assert.ok(node.position);
    assert.ok(node.position.start.offset !== undefined);
    assert.ok(node.position.end.offset !== undefined);
    const start = node.position.start.offset;
    const end = node.position.end.offset;
    console.log("value:", JSON.stringify(node.value));
    console.log("value.length:", node.value.length);
    console.log("offset span:", end - start);
    console.log(
      "source.slice(start, end):",
      JSON.stringify(value.slice(start, end)),
    );
  }
});

value: "\nb"
value.length: 2
offset span: 4
source.slice(start, end): "\n> b"

Especially note the first log: it includes the \n. Also note that the *a* is a separate emphasis, with a sole a text node.
The other text node, in the rest of the paragraph/blockquote/root, starts at that \n after it. It intentionally does not include > of course, because that’s not part of the text/paragraph. However, the positional info of the text still starts at \n and ends at b.