Fix literal backslashes before constructs

Closes GH-19.

Author: wooorm

lib/unsafe.js

@@ -77,13 +77,10 @@ module.exports = [
   // Question mark and at sign are not used in markdown for constructs.
   // A left bracket can start definitions, references, labels,
   {atBreak: true, character: '['},
-  {
-    character: '[',
-    inConstruct: ['phrasing', 'label', 'reference']
-  },
+  {character: '[', inConstruct: ['phrasing', 'label', 'reference']},
   // A backslash can start an escape (when followed by punctuation) or a
   // hard break (when followed by an eol).
-  {character: '\\', after: '[!-/:-@[-`{-~]', collapse: false},
+  // Note: typical escapes are handled in `safe`!
   {character: '\\', after: '[\\r\\n]', inConstruct: 'phrasing'},
   // A right bracket can exit labels.
   {

lib/util/safe.js

@@ -28,20 +28,8 @@ function safe(context, input, config) {
     expression = patternCompile(pattern)
 
     while ((match = expression.exec(value))) {
-      // Often, patterns which depend on a character before or after it, such
-      // as `!` when followed by `[` (for an image), do not have to be escaped
-      // when the other character has to be escaped as well.
-      // But in the case of a backslash, such as `\` when followed by `*`, that
-      // is not correct: both have to be escaped.
-      // This is a naïve “fix” for that though, but this seems the simplest for
-      // now.
-      if (pattern.collapse === false) {
-        before = false
-        after = false
-      } else {
-        before = 'before' in pattern || pattern.atBreak
-        after = 'after' in pattern
-      }
+      before = 'before' in pattern || pattern.atBreak
+      after = 'after' in pattern
 
       position = match.index + (before ? match[1].length : 0)
 
@@ -91,7 +79,10 @@ function safe(context, input, config) {
     }
 
     if (start !== position) {
-      result.push(value.slice(start, position))
+      // If we have to use a character reference, an ampersand would be more
+      // correct, but as backslashes only care about punctuation, either will
+      // do the trick
+      result.push(escapeBackslashes(value.slice(start, position), '\\'))
     }
 
     start = position
@@ -111,11 +102,38 @@ function safe(context, input, config) {
     }
   }
 
-  result.push(value.slice(start, end))
+  result.push(escapeBackslashes(value.slice(start, end), config.after))
 
   return result.join('')
 }
 
 function numerical(a, b) {
   return a - b
 }
+
+function escapeBackslashes(value, after) {
+  var expression = /\\(?=[!-/:-@[-`{-~])/g
+  var positions = []
+  var results = []
+  var index = -1
+  var start = 0
+  var whole = value + after
+  var match
+
+  while ((match = expression.exec(whole))) {
+    positions.push(match.index)
+  }
+
+  while (++index < positions.length) {
+    if (start !== positions[index]) {
+      results.push(value.slice(start, positions[index]))
+    }
+
+    results.push('\\')
+    start = positions[index]
+  }
+
+  results.push(value.slice(start))
+
+  return results.join('')
+}

test.js

@@ -2714,6 +2714,30 @@ test('escape', function (t) {
     'should prefer extension options over subextension options'
   )
 
+  t.equal(
+    to({
+      type: 'paragraph',
+      children: [
+        {type: 'text', value: '\\'},
+        {type: 'emphasis', children: [{type: 'text', value: 'a'}]}
+      ]
+    }),
+    '\\\\*a*\n',
+    'should handle literal backslashes properly when before constructs (1)'
+  )
+
+  t.equal(
+    to({
+      type: 'paragraph',
+      children: [
+        {type: 'text', value: '\\\\'},
+        {type: 'emphasis', children: [{type: 'text', value: 'a'}]}
+      ]
+    }),
+    '\\\\\\\\*a*\n',
+    'should handle literal backslashes properly when before constructs (2)'
+  )
+
   t.end()
 })