Allow sequence of 4+ markers in pairs

lib/rules_inline/del.js

@@ -1,62 +1,80 @@
-// Process ~~deleted text~~
-
 'use strict';
 
-module.exports = function del(state, silent) {
-  var found,
-      pos,
+
+// parse sequence of markers,
+// "start" should point at a valid marker
+function scanDelims(state, start) {
+  var pos = start, lastChar, nextChar, count,
+      can_open = true,
+      can_close = true,
+      max = state.posMax,
+      marker = state.src.charCodeAt(start);
+
+  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;
+
+  while (pos < max && state.src.charCodeAt(pos) === marker) { pos++; }
+  if (pos >= max) { can_open = false; }
+  count = pos - start;
+
+  nextChar = pos < max ? state.src.charCodeAt(pos) : -1;
+
+  // check whitespace conditions
+  if (nextChar === 0x20 || nextChar === 0x0A) { can_open = false; }
+  if (lastChar === 0x20 || lastChar === 0x0A) { can_close = false; }
+
+  return {
+    can_open: can_open,
+    can_close: can_close,
+    delims: count
+  };
+}
+
+module.exports = function(state, silent) {
+  var startCount,
+      count,
+      tagCount,
+      found,
       stack,
+      res,
       max = state.posMax,
       start = state.pos,
-      lastChar,
-      nextChar;
+      marker = state.src.charCodeAt(start);
 
-  if (state.src.charCodeAt(start) !== 0x7E/* ~ */) { return false; }
+  if (marker !== 0x7E/* ~ */) { return false; }
   if (silent) { return false; } // don't run any pairs in validation mode
-  if (start + 4 >= max) { return false; }
-  if (state.src.charCodeAt(start + 1) !== 0x7E/* ~ */) { return false; }
-  if (state.level >= state.options.maxNesting) { return false; }
 
-  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;
-  nextChar = state.src.charCodeAt(start + 2);
-
-  if (lastChar === 0x7E/* ~ */) { return false; }
-  if (nextChar === 0x7E/* ~ */) { return false; }
-  if (nextChar === 0x20 || nextChar === 0x0A) { return false; }
-
-  pos = start + 2;
-  while (pos < max && state.src.charCodeAt(pos) === 0x7E/* ~ */) { pos++; }
-  if (pos > start + 3) {
-    // sequence of 4+ markers taking as literal, same as in a emphasis
-    state.pos += pos - start;
-    if (!silent) { state.pending += state.src.slice(start, pos); }
+  res = scanDelims(state, start);
+  startCount = res.delims;
+  if (!res.can_open) {
+    state.pos += startCount;
+    if (!silent) { state.pending += state.src.slice(start, state.pos); }
     return true;
   }
 
-  state.pos = start + 2;
-  stack = 1;
-
-  while (state.pos + 1 < max) {
-    if (state.src.charCodeAt(state.pos) === 0x7E/* ~ */) {
-      if (state.src.charCodeAt(state.pos + 1) === 0x7E/* ~ */) {
-        lastChar = state.src.charCodeAt(state.pos - 1);
-        nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1;
-        if (nextChar !== 0x7E/* ~ */ && lastChar !== 0x7E/* ~ */) {
-          if (lastChar !== 0x20 && lastChar !== 0x0A) {
-            // closing '~~'
-            stack--;
-          } else if (nextChar !== 0x20 && nextChar !== 0x0A) {
-            // opening '~~'
-            stack++;
-          } // else {
-            //  // standalone ' ~~ ' indented with spaces
-            // }
-          if (stack <= 0) {
-            found = true;
-            break;
-          }
+  if (state.level >= state.options.maxNesting) { return false; }
+  stack = Math.floor(startCount / 2);
+  if (stack <= 0) { return false; }
+  state.pos = start + startCount;
+
+  while (state.pos < max) {
+    if (state.src.charCodeAt(state.pos) === marker) {
+      res = scanDelims(state, state.pos);
+      count = res.delims;
+      tagCount = Math.floor(count / 2);
+      if (res.can_close) {
+        if (tagCount >= stack) {
+          state.pos += count - 2;
+          found = true;
+          break;
         }
+        stack -= tagCount;
+        state.pos += count;
+        continue;
       }
+
+      if (res.can_open) { stack += tagCount; }
+      state.pos += count;
+      continue;
     }
 
     state.parser.skipToken(state);

lib/rules_inline/ins.js

@@ -1,62 +1,80 @@
-// Process ++inserted text++
-
 'use strict';
 
-module.exports = function ins(state, silent) {
-  var found,
-      pos,
+
+// parse sequence of markers,
+// "start" should point at a valid marker
+function scanDelims(state, start) {
+  var pos = start, lastChar, nextChar, count,
+      can_open = true,
+      can_close = true,
+      max = state.posMax,
+      marker = state.src.charCodeAt(start);
+
+  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;
+
+  while (pos < max && state.src.charCodeAt(pos) === marker) { pos++; }
+  if (pos >= max) { can_open = false; }
+  count = pos - start;
+
+  nextChar = pos < max ? state.src.charCodeAt(pos) : -1;
+
+  // check whitespace conditions
+  if (nextChar === 0x20 || nextChar === 0x0A) { can_open = false; }
+  if (lastChar === 0x20 || lastChar === 0x0A) { can_close = false; }
+
+  return {
+    can_open: can_open,
+    can_close: can_close,
+    delims: count
+  };
+}
+
+module.exports = function(state, silent) {
+  var startCount,
+      count,
+      tagCount,
+      found,
       stack,
+      res,
       max = state.posMax,
       start = state.pos,
-      lastChar,
-      nextChar;
+      marker = state.src.charCodeAt(start);
 
-  if (state.src.charCodeAt(start) !== 0x2B/* + */) { return false; }
+  if (marker !== 0x2B/* + */) { return false; }
   if (silent) { return false; } // don't run any pairs in validation mode
-  if (start + 4 >= max) { return false; }
-  if (state.src.charCodeAt(start + 1) !== 0x2B/* + */) { return false; }
-  if (state.level >= state.options.maxNesting) { return false; }
 
-  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;
-  nextChar = state.src.charCodeAt(start + 2);
-
-  if (lastChar === 0x2B/* + */) { return false; }
-  if (nextChar === 0x2B/* + */) { return false; }
-  if (nextChar === 0x20 || nextChar === 0x0A) { return false; }
-
-  pos = start + 2;
-  while (pos < max && state.src.charCodeAt(pos) === 0x2B/* + */) { pos++; }
-  if (pos !== start + 2) {
-    // sequence of 3+ markers taking as literal, same as in a emphasis
-    state.pos += pos - start;
-    if (!silent) { state.pending += state.src.slice(start, pos); }
+  res = scanDelims(state, start);
+  startCount = res.delims;
+  if (!res.can_open) {
+    state.pos += startCount;
+    if (!silent) { state.pending += state.src.slice(start, state.pos); }
     return true;
   }
 
-  state.pos = start + 2;
-  stack = 1;
-
-  while (state.pos + 1 < max) {
-    if (state.src.charCodeAt(state.pos) === 0x2B/* + */) {
-      if (state.src.charCodeAt(state.pos + 1) === 0x2B/* + */) {
-        lastChar = state.src.charCodeAt(state.pos - 1);
-        nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1;
-        if (nextChar !== 0x2B/* + */ && lastChar !== 0x2B/* + */) {
-          if (lastChar !== 0x20 && lastChar !== 0x0A) {
-            // closing '++'
-            stack--;
-          } else if (nextChar !== 0x20 && nextChar !== 0x0A) {
-            // opening '++'
-            stack++;
-          } // else {
-            //  // standalone ' ++ ' indented with spaces
-            // }
-          if (stack <= 0) {
-            found = true;
-            break;
-          }
+  if (state.level >= state.options.maxNesting) { return false; }
+  stack = Math.floor(startCount / 2);
+  if (stack <= 0) { return false; }
+  state.pos = start + startCount;
+
+  while (state.pos < max) {
+    if (state.src.charCodeAt(state.pos) === marker) {
+      res = scanDelims(state, state.pos);
+      count = res.delims;
+      tagCount = Math.floor(count / 2);
+      if (res.can_close) {
+        if (tagCount >= stack) {
+          state.pos += count - 2;
+          found = true;
+          break;
         }
+        stack -= tagCount;
+        state.pos += count;
+        continue;
       }
+
+      if (res.can_open) { stack += tagCount; }
+      state.pos += count;
+      continue;
     }
 
     state.parser.skipToken(state);

lib/rules_inline/mark.js

@@ -1,62 +1,80 @@
-// Process ==highlighted text==
-
 'use strict';
 
-module.exports = function del(state, silent) {
-  var found,
-      pos,
+
+// parse sequence of markers,
+// "start" should point at a valid marker
+function scanDelims(state, start) {
+  var pos = start, lastChar, nextChar, count,
+      can_open = true,
+      can_close = true,
+      max = state.posMax,
+      marker = state.src.charCodeAt(start);
+
+  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;
+
+  while (pos < max && state.src.charCodeAt(pos) === marker) { pos++; }
+  if (pos >= max) { can_open = false; }
+  count = pos - start;
+
+  nextChar = pos < max ? state.src.charCodeAt(pos) : -1;
+
+  // check whitespace conditions
+  if (nextChar === 0x20 || nextChar === 0x0A) { can_open = false; }
+  if (lastChar === 0x20 || lastChar === 0x0A) { can_close = false; }
+
+  return {
+    can_open: can_open,
+    can_close: can_close,
+    delims: count
+  };
+}
+
+module.exports = function(state, silent) {
+  var startCount,
+      count,
+      tagCount,
+      found,
       stack,
+      res,
       max = state.posMax,
       start = state.pos,
-      lastChar,
-      nextChar;
+      marker = state.src.charCodeAt(start);
 
-  if (state.src.charCodeAt(start) !== 0x3D/* = */) { return false; }
+  if (marker !== 0x3D/* = */) { return false; }
   if (silent) { return false; } // don't run any pairs in validation mode
-  if (start + 4 >= max) { return false; }
-  if (state.src.charCodeAt(start + 1) !== 0x3D/* = */) { return false; }
-  if (state.level >= state.options.maxNesting) { return false; }
 
-  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;
-  nextChar = state.src.charCodeAt(start + 2);
-
-  if (lastChar === 0x3D/* = */) { return false; }
-  if (nextChar === 0x3D/* = */) { return false; }
-  if (nextChar === 0x20 || nextChar === 0x0A) { return false; }
-
-  pos = start + 2;
-  while (pos < max && state.src.charCodeAt(pos) === 0x3D/* = */) { pos++; }
-  if (pos !== start + 2) {
-    // sequence of 3+ markers taking as literal, same as in a emphasis
-    state.pos += pos - start;
-    if (!silent) { state.pending += state.src.slice(start, pos); }
+  res = scanDelims(state, start);
+  startCount = res.delims;
+  if (!res.can_open) {
+    state.pos += startCount;
+    if (!silent) { state.pending += state.src.slice(start, state.pos); }
     return true;
   }
 
-  state.pos = start + 2;
-  stack = 1;
-
-  while (state.pos + 1 < max) {
-    if (state.src.charCodeAt(state.pos) === 0x3D/* = */) {
-      if (state.src.charCodeAt(state.pos + 1) === 0x3D/* = */) {
-        lastChar = state.src.charCodeAt(state.pos - 1);
-        nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1;
-        if (nextChar !== 0x3D/* = */ && lastChar !== 0x3D/* = */) {
-          if (lastChar !== 0x20 && lastChar !== 0x0A) {
-            // closing '=='
-            stack--;
-          } else if (nextChar !== 0x20 && nextChar !== 0x0A) {
-            // opening '=='
-            stack++;
-          } // else {
-            //  // standalone ' == ' indented with spaces
-            // }
-          if (stack <= 0) {
-            found = true;
-            break;
-          }
+  if (state.level >= state.options.maxNesting) { return false; }
+  stack = Math.floor(startCount / 2);
+  if (stack <= 0) { return false; }
+  state.pos = start + startCount;
+
+  while (state.pos < max) {
+    if (state.src.charCodeAt(state.pos) === marker) {
+      res = scanDelims(state, state.pos);
+      count = res.delims;
+      tagCount = Math.floor(count / 2);
+      if (res.can_close) {
+        if (tagCount >= stack) {
+          state.pos += count - 2;
+          found = true;
+          break;
         }
+        stack -= tagCount;
+        state.pos += count;
+        continue;
       }
+
+      if (res.can_open) { stack += tagCount; }
+      state.pos += count;
+      continue;
     }
 
     state.parser.skipToken(state);

test/fixtures/markdown-it/del.txt

@@ -4,6 +4,30 @@
 <p><del>Strikeout</del></p>
 .
 
+.
+x ~~~~foo~~ bar~~
+.
+<p>x <del><del>foo</del> bar</del></p>
+.
+
+.
+x ~~foo ~~bar~~~~
+.
+<p>x <del>foo <del>bar</del></del></p>
+.
+
+.
+x ~~~~foo~~~~
+.
+<p>x <del><del>foo</del></del></p>
+.
+
+.
+x ~~~foo~~~
+.
+<p>x <del><sub>foo</sub></del></p>
+.
+
 Strikeouts have the same priority as emphases:
 
 .

test/fixtures/markdown-it/ins.txt

@@ -5,17 +5,28 @@
 .
 
 
-These are not inserts, you have to use exactly two "++":
 .
-x +++foo+++
+x ++++foo++ bar++
+.
+<p>x <ins><ins>foo</ins> bar</ins></p>
+.
+
+.
+x ++foo ++bar++++
+.
+<p>x <ins>foo <ins>bar</ins></ins></p>
+.
 
-x ++foo+++
+.
+x ++++foo++++
+.
+<p>x <ins><ins>foo</ins></ins></p>
+.
 
-x +++foo++
 .
-<p>x +++foo+++</p>
-<p>x ++foo+++</p>
-<p>x +++foo++</p>
+x +++foo+++
+.
+<p>x <ins>+foo+</ins></p>
 .
 
 Inserts have the same priority as emphases:

test/fixtures/markdown-it/mark.txt

@@ -4,18 +4,28 @@
 <p><mark>Mark</mark></p>
 .
 
+.
+x ====foo== bar==
+.
+<p>x <mark><mark>foo</mark> bar</mark></p>
+.
 
-These are not marks, you have to use exactly two "==":
 .
-x ===foo===
+x ==foo ==bar====
+.
+<p>x <mark>foo <mark>bar</mark></mark></p>
+.
 
-x ==foo===
+.
+x ====foo====
+.
+<p>x <mark><mark>foo</mark></mark></p>
+.
 
-x ===foo==
 .
-<p>x ===foo===</p>
-<p>x ==foo===</p>
-<p>x ===foo==</p>
+x ===foo===
+.
+<p>x <mark>=foo=</mark></p>
 .
 
 Marks have the same priority as emphases: