fix: flip attention marker to avoid nested-emphasis fusion

Problem: when an emphasis or strong node contains another emphasis or
strong node at its first or last child position, both handlers emit the
same configured marker (`*` by default). The adjacent opening or
closing markers fuse (`*` + `*` = `**`) and re-tokenize as a
different construct. For example, `emphasis > emphasis > text"a"`
serialized to `**a**`, which re-parses as `strong`.

Goal: pick a marker for each attention node that does not fuse with its
neighbors, mirroring how list.js already flips bullets via
checkBulletOther when collisions would form a thematic break.

Changes:
- add lib/util/emphasis-strong-marker.js to pick the marker per node
  using two tests: adjacency via info.before/info.after, and a
  boundary-chain check that forces the outer marker to `_` when three
  or more same-type emphasis are nested along the first or last child
  path and the primary marker is `*` (CommonMark's flanking rules
  only allow three-deep round-trip when the outer is `_`)
- switch lib/handle/emphasis.js and lib/handle/strong.js to use the
  new utility in place of checkEmphasis / checkStrong
- add tests covering emphasis-in-emphasis, strong-in-emphasis,
  emphasis-in-strong, three-deep emphasis, last-child boundary
  detection, and round-trip equivalence for the reproducer

Notes: considered an escape-based fix (`*\\*a\\**`) and a
character-reference approach; both are noisier than flipping and do
not match the shape users write. A four-deep same-type chain is not
addressed: no pure flip resolves it because CommonMark's pairing
algorithm fuses delimiters regardless of outer choice.

Closes #12

Author: Chad Murphy

lib/handle/emphasis.js

@@ -3,7 +3,7 @@
  * @import {Emphasis, Parents} from 'mdast'
  */
 
-import {checkEmphasis} from '../util/check-emphasis.js'
+import {emphasisStrongMarker} from '../util/emphasis-strong-marker.js'
 import {encodeCharacterReference} from '../util/encode-character-reference.js'
 import {encodeInfo} from '../util/encode-info.js'
 
@@ -17,7 +17,7 @@ emphasis.peek = emphasisPeek
  * @returns {string}
  */
 export function emphasis(node, _, state, info) {
-  const marker = checkEmphasis(state)
+  const marker = emphasisStrongMarker(node, state, info)
   const exit = state.enter('emphasis')
   const tracker = state.createTracker(info)
   const before = tracker.move(marker)

lib/handle/strong.js

@@ -3,7 +3,7 @@
  * @import {Parents, Strong} from 'mdast'
  */
 
-import {checkStrong} from '../util/check-strong.js'
+import {emphasisStrongMarker} from '../util/emphasis-strong-marker.js'
 import {encodeCharacterReference} from '../util/encode-character-reference.js'
 import {encodeInfo} from '../util/encode-info.js'
 
@@ -17,7 +17,7 @@ strong.peek = strongPeek
  * @returns {string}
  */
 export function strong(node, _, state, info) {
-  const marker = checkStrong(state)
+  const marker = emphasisStrongMarker(node, state, info)
   const exit = state.enter('strong')
   const tracker = state.createTracker(info)
   const before = tracker.move(marker + marker)

lib/util/emphasis-strong-marker.js

@@ -0,0 +1,73 @@
+/**
+ * @import {Emphasis, Strong} from 'mdast'
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ */
+
+import {checkEmphasis} from './check-emphasis.js'
+import {checkStrong} from './check-strong.js'
+
+/**
+ * Pick the marker for an emphasis or strong node, flipping to the opposite
+ * marker when the configured marker would fuse with a surrounding attention
+ * delimiter and re-parse as a different construct.
+ *
+ * Two collisions are detected:
+ *
+ * 1.  Adjacency: when this node sits at the first or last position of an
+ *     outer attention, its opening or closing marker butts up against the
+ *     outer marker; using the same character would merge `*` + `*` into `**`
+ *     which re-tokenizes as `strong` rather than nested `emphasis`.
+ * 2.  Three-deep same-type chains with `*` as the primary marker: the spec's
+ *     flanking rules are asymmetric between `*` and `_`, and three-deep
+ *     nesting only round-trips when the outermost marker is `_`.
+ *
+ * @param {Emphasis | Strong} node
+ * @param {State} state
+ * @param {Info} info
+ * @returns {'*' | '_'}
+ */
+export function emphasisStrongMarker(node, state, info) {
+  const primary =
+    node.type === 'emphasis' ? checkEmphasis(state) : checkStrong(state)
+  const other = primary === '*' ? '_' : '*'
+  const before = info.before.charAt(info.before.length - 1)
+  const after = info.after.charAt(0)
+
+  if (before === primary || after === primary) return other
+  if (primary === '*' && boundaryChainDepth(node, node.type) >= 2) return other
+
+  return primary
+}
+
+/**
+ * Count how many same-type attention nodes form a chain along the
+ * first-child or last-child boundary below `node`.
+ *
+ * @param {Emphasis | Strong} node
+ * @param {'emphasis' | 'strong'} type
+ * @returns {number}
+ */
+function boundaryChainDepth(node, type) {
+  const children = node.children
+  if (!children || children.length === 0) return 0
+
+  const first = children[0]
+  const last = children[children.length - 1]
+  let depth = 0
+
+  if (first.type === type) {
+    depth = Math.max(
+      depth,
+      1 + boundaryChainDepth(/** @type {Emphasis | Strong} */ (first), type)
+    )
+  }
+
+  if (last && last !== first && last.type === type) {
+    depth = Math.max(
+      depth,
+      1 + boundaryChainDepth(/** @type {Emphasis | Strong} */ (last), type)
+    )
+  }
+
+  return depth
+}

test/index.js

@@ -1262,6 +1262,129 @@ test('emphasis', async function (t) {
       )
     }
   )
+
+  await t.test(
+    'should flip the inner marker when emphasis wraps emphasis',
+    async function () {
+      assert.equal(
+        to({
+          type: 'emphasis',
+          children: [
+            {
+              type: 'emphasis',
+              children: [{type: 'text', value: 'a'}]
+            }
+          ]
+        }),
+        '*_a_*\n'
+      )
+    }
+  )
+
+  await t.test(
+    'should flip the inner marker when strong wraps emphasis',
+    async function () {
+      assert.equal(
+        to({
+          type: 'strong',
+          children: [
+            {
+              type: 'emphasis',
+              children: [{type: 'text', value: 'a'}]
+            }
+          ]
+        }),
+        '**_a_**\n'
+      )
+    }
+  )
+
+  await t.test(
+    'should flip the inner marker when emphasis wraps strong',
+    async function () {
+      assert.equal(
+        to({
+          type: 'emphasis',
+          children: [
+            {
+              type: 'strong',
+              children: [{type: 'text', value: 'a'}]
+            }
+          ]
+        }),
+        '*__a__*\n'
+      )
+    }
+  )
+
+  await t.test(
+    'should start with `_` when three-deep same-type emphasis is nested',
+    async function () {
+      assert.equal(
+        to({
+          type: 'emphasis',
+          children: [
+            {
+              type: 'emphasis',
+              children: [
+                {
+                  type: 'emphasis',
+                  children: [{type: 'text', value: 'a'}]
+                }
+              ]
+            }
+          ]
+        }),
+        '_*_a_*_\n'
+      )
+    }
+  )
+
+  await t.test(
+    'should roundtrip emphasis wrapping emphasis',
+    async function () {
+      const tree = from('*_a_*')
+      removePosition(tree, {force: true})
+      const out = from(to(tree))
+      removePosition(out, {force: true})
+      assert.deepEqual(out, tree)
+    }
+  )
+
+  await t.test(
+    'should roundtrip three-deep nested emphasis',
+    async function () {
+      const tree = from('_*_a_*_')
+      removePosition(tree, {force: true})
+      const out = from(to(tree))
+      removePosition(out, {force: true})
+      assert.deepEqual(out, tree)
+    }
+  )
+
+  await t.test(
+    'should consider the last child when picking the marker',
+    async function () {
+      assert.equal(
+        to({
+          type: 'emphasis',
+          children: [
+            {type: 'text', value: 'x '},
+            {
+              type: 'emphasis',
+              children: [
+                {
+                  type: 'emphasis',
+                  children: [{type: 'text', value: 'a'}]
+                }
+              ]
+            }
+          ]
+        }),
+        '_x *_a_*_\n'
+      )
+    }
+  )
 })
 
 test('heading', async function (t) {