motion-markdown-it 4.4.0 → 8.4.1

data/lib/motion-markdown-it/parser_block.rb

@@ -7,20 +7,20 @@ module MarkdownIt
   class ParserBlock
 
     attr_accessor   :ruler
-    
+
     RULES = [
       # First 2 params - rule name & source. Secondary array - list of rules,
       # which can be terminated by this one.
+      [ 'table',        lambda { |state, startLine, endLine, silent| RulesBlock::Table.table(state, startLine, endLine, silent) },      [ 'paragraph', 'reference' ] ],
       [ 'code',         lambda { |state, startLine, endLine, silent| RulesBlock::Code.code(state, startLine, endLine, silent) } ],
       [ 'fence',        lambda { |state, startLine, endLine, silent| RulesBlock::Fence.fence(state, startLine, endLine, silent) },      [ 'paragraph', 'reference', 'blockquote', 'list' ] ],
-      [ 'blockquote',   lambda { |state, startLine, endLine, silent| RulesBlock::Blockquote.blockquote(state, startLine, endLine, silent) }, [ 'paragraph', 'reference', 'list' ] ],
+      [ 'blockquote',   lambda { |state, startLine, endLine, silent| RulesBlock::Blockquote.blockquote(state, startLine, endLine, silent) }, [ 'paragraph', 'reference', 'blockquote', 'list' ] ],
       [ 'hr',           lambda { |state, startLine, endLine, silent| RulesBlock::Hr.hr(state, startLine, endLine, silent) },         [ 'paragraph', 'reference', 'blockquote', 'list' ] ],
       [ 'list',         lambda { |state, startLine, endLine, silent| RulesBlock::List.list(state, startLine, endLine, silent) },       [ 'paragraph', 'reference', 'blockquote' ] ],
       [ 'reference',    lambda { |state, startLine, endLine, silent| RulesBlock::Reference.reference(state, startLine, endLine, silent) } ],
       [ 'heading',      lambda { |state, startLine, endLine, silent| RulesBlock::Heading.heading(state, startLine, endLine, silent) },    [ 'paragraph', 'reference', 'blockquote' ] ],
       [ 'lheading',     lambda { |state, startLine, endLine, silent| RulesBlock::Lheading.lheading(state, startLine, endLine, silent) } ],
       [ 'html_block',   lambda { |state, startLine, endLine, silent| RulesBlock::HtmlBlock.html_block(state, startLine, endLine, silent) }, [ 'paragraph', 'reference', 'blockquote' ] ],
-      [ 'table',        lambda { |state, startLine, endLine, silent| RulesBlock::Table.table(state, startLine, endLine, silent) },      [ 'paragraph', 'reference' ] ],
       [ 'paragraph',    lambda { |state, startLine, endLine, silent| RulesBlock::Paragraph.paragraph(state, startLine) } ]
     ]
 
@@ -47,14 +47,14 @@ module MarkdownIt
       line          = startLine
       hasEmptyLines = false
       maxNesting    = state.md.options[:maxNesting]
-      
+
       while line < endLine
         state.line = line = state.skipEmptyLines(line)
         break if line >= endLine
 
         # Termination condition for nested calls.
         # Nested calls currently used for blockquotes & lists
-        break if state.tShift[line] < state.blkIndent
+        break if state.sCount[line] < state.blkIndent
 
         # If nesting level exceeded - skip tail to the end. That's not ordinary
         # situation and we should not care about content.
@@ -74,7 +74,7 @@ module MarkdownIt
           break if ok
         end
 
-        # set state.tight iff we had an empty line before current tag
+        # set state.tight if we had an empty line before current tag
         # i.e. latest empty line should not count
         state.tight = !hasEmptyLines
 
@@ -88,9 +88,6 @@ module MarkdownIt
         if line < endLine && state.isEmpty(line)
           hasEmptyLines = true
           line += 1
-
-          # two empty lines should stop the parser in list mode
-          break if line < endLine && state.parentType == 'list' && state.isEmpty(line)
           state.line = line
         end
       end
@@ -102,7 +99,7 @@ module MarkdownIt
     #------------------------------------------------------------------------------
     def parse(src, md, env, outTokens)
 
-      reutrn [] if !src
+      return if !src
 
       state = RulesBlock::StateBlock.new(src, md, env, outTokens)
 

data/lib/motion-markdown-it/parser_inline.rb

@@ -5,9 +5,9 @@
 #------------------------------------------------------------------------------
 module MarkdownIt
   class ParserInline
-    
-    attr_accessor   :ruler
-    
+
+    attr_accessor   :ruler, :ruler2
+
     #------------------------------------------------------------------------------
     # Parser rules
 
@@ -16,8 +16,8 @@ module MarkdownIt
       [ 'newline',         lambda { |state, startLine| RulesInline::Newline.newline(state, startLine) } ],
       [ 'escape',          lambda { |state, startLine| RulesInline::Escape.escape(state, startLine) } ],
       [ 'backticks',       lambda { |state, startLine| RulesInline::Backticks.backtick(state, startLine) } ],
-      [ 'strikethrough',   lambda { |state, startLine| RulesInline::Strikethrough.strikethrough(state, startLine) } ],
-      [ 'emphasis',        lambda { |state, startLine| RulesInline::Emphasis.emphasis(state, startLine) } ],
+      [ 'strikethrough',   lambda { |state, silent|    RulesInline::Strikethrough.tokenize(state, silent) } ],
+      [ 'emphasis',        lambda { |state, silent|    RulesInline::Emphasis.tokenize(state, silent) } ],
       [ 'link',            lambda { |state, startLine| RulesInline::Link.link(state, startLine) } ],
       [ 'image',           lambda { |state, startLine| RulesInline::Image.image(state, startLine) } ],
       [ 'autolink',        lambda { |state, startLine| RulesInline::Autolink.autolink(state, startLine) } ],
@@ -25,6 +25,12 @@ module MarkdownIt
       [ 'entity',          lambda { |state, startLine| RulesInline::Entity.entity(state, startLine) } ],
     ]
 
+    RULES2 = [
+      [ 'balance_pairs',   lambda { |state| RulesInline::BalancePairs.link_pairs(state) } ],
+      [ 'strikethrough',   lambda { |state| RulesInline::Strikethrough.postProcess(state) } ],
+      [ 'emphasis',        lambda { |state| RulesInline::Emphasis.postProcess(state) } ],
+      [ 'text_collapse',   lambda { |state| RulesInline::TextCollapse.text_collapse(state) } ]
+    ];
 
     #------------------------------------------------------------------------------
     def initialize
@@ -36,6 +42,16 @@ module MarkdownIt
       RULES.each do |rule|
         @ruler.push(rule[0], rule[1])
       end
+
+      # ParserInline#ruler2 -> Ruler
+      #
+      # [[Ruler]] instance. Second ruler used for post-processing
+      # (e.g. in emphasis-like rules).
+      @ruler2 = Ruler.new
+
+      RULES2.each do |rule|
+        @ruler2.push(rule[0], rule[1])
+      end
     end
 
     # Skip single token by running all rules in validation mode;
@@ -47,28 +63,42 @@ module MarkdownIt
       len        = rules.length
       maxNesting = state.md.options[:maxNesting]
       cache      = state.cache
-
+      ok         = false
 
       if cache[pos] != nil
         state.pos = cache[pos]
         return
       end
 
-      # istanbul ignore else
       if state.level < maxNesting
         0.upto(len -1) do |i|
-          if rules[i].call(state, true)
-            cache[pos] = state.pos
-            return
-          end
+          # Increment state.level and decrement it later to limit recursion.
+          # It's harmless to do here, because no tokens are created. But ideally,
+          # we'd need a separate private state variable for this purpose.
+          state.level += 1
+          ok = rules[i].call(state, true)
+          state.level -= 1
+
+          break if ok
         end
+      else
+        # Too much nesting, just skip until the end of the paragraph.
+        #
+        # NOTE: this will cause links to behave incorrectly in the following case,
+        #       when an amount of `[` is exactly equal to `maxNesting + 1`:
+        #
+        #       [[[[[[[[[[[[[[[[[[[[[foo]()
+        #
+        # TODO: remove this workaround when CM standard will allow nested links
+        #       (we can replace it by preventing links from being parsed in
+        #       validation mode)
+        state.pos = state.posMax
       end
 
-      state.pos += 1
+      state.pos += 1 if !ok
       cache[pos] = state.pos
     end
 
-
     # Generate tokens for input range
     #------------------------------------------------------------------------------
     def tokenize(state)
@@ -115,7 +145,13 @@ module MarkdownIt
       state = RulesInline::StateInline.new(str, md, env, outTokens)
 
       tokenize(state)
-    end
 
+      rules = @ruler2.getRules('')
+      len = rules.length
+
+      0.upto(len - 1) do |i|
+        rules[i].call(state)
+      end
+    end
   end
 end

data/lib/motion-markdown-it/presets/commonmark.rb

@@ -23,7 +23,8 @@ module MarkdownIt
             quotes: "\u201c\u201d\u2018\u2019", # “”‘’
 
             # Highlighter function. Should return escaped HTML,
-            # or '' if input not changed
+            # or '' if the source string is not changed and should be escaped externaly.
+            # If result starts with <pre... internal wrapper is skipped.
             #
             # function (/*str, lang*/) { return ''; }
             #
@@ -69,6 +70,11 @@ module MarkdownIt
                 'link',
                 'newline',
                 'text'
+              ],
+              rules2: [
+                'balance_pairs',
+                'emphasis',
+                'text_collapse'
               ]
             }
           }

data/lib/motion-markdown-it/presets/default.rb

@@ -20,16 +20,17 @@ module MarkdownIt
             #
             # For example, you can use '«»„“' for Russian, '„“‚‘' for German,
             # and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
-            quotes: "\u201c\u201d\u2018\u2019", # “”‘’ 
+            quotes: "\u201c\u201d\u2018\u2019", # “”‘’
 
             # Highlighter function. Should return escaped HTML,
-            # or '' if input not changed
+            # or '' if the source string is not changed and should be escaped externaly.
+            # If result starts with <pre... internal wrapper is skipped.
             #
             # function (/*str, lang*/) { return ''; }
             #
             highlight: nil,
 
-            maxNesting:   20            # Internal protection, recursion limit
+            maxNesting:   100            # Internal protection, recursion limit
           },
 
           components: {

data/lib/motion-markdown-it/presets/zero.rb

@@ -24,7 +24,8 @@ module MarkdownIt
             quotes: "\u201c\u201d\u2018\u2019", # “”‘’
 
             # Highlighter function. Should return escaped HTML,
-            # or '' if input not changed
+            # or '' if the source string is not changed and should be escaped externaly.
+            # If result starts with <pre... internal wrapper is skipped.
             #
             # function (/*str, lang*/) { return ''; }
             #
@@ -52,6 +53,10 @@ module MarkdownIt
             inline: {
               rules: [
                 'text'
+              ],
+              rules2: [
+                'balance_pairs',
+                'text_collapse'
               ]
             }
           }

data/lib/motion-markdown-it/renderer.rb

@@ -10,16 +10,24 @@ module MarkdownIt
     extend  MarkdownIt::Common::Utils
 
     attr_accessor   :rules
-    
+
     # Default Rules
     #------------------------------------------------------------------------------
-    def self.code_inline(tokens, idx)
-      return '<code>' + escapeHtml(tokens[idx].content) + '</code>'
+    def self.code_inline(tokens, idx, options, env, renderer)
+      token = tokens[idx]
+
+      return '<code' + renderer.renderAttrs(token) + '>' +
+             escapeHtml(tokens[idx].content) +
+             '</code>'
     end
 
     #------------------------------------------------------------------------------
-    def self.code_block(tokens, idx)
-      return '<pre><code>' + escapeHtml(tokens[idx].content) + "</code></pre>\n"
+    def self.code_block(tokens, idx, options, env, renderer)
+      token = tokens[idx]
+
+      return  '<pre' + renderer.renderAttrs(token) + '><code>' +
+              escapeHtml(tokens[idx].content) +
+              "</code></pre>\n"
     end
 
     #------------------------------------------------------------------------------
@@ -30,7 +38,6 @@ module MarkdownIt
 
       if !info.empty?
         langName = info.split(/\s+/)[0]
-        token.attrPush([ 'class', options[:langPrefix] + langName ])
       end
 
       if options[:highlight]
@@ -39,7 +46,33 @@ module MarkdownIt
         highlighted = escapeHtml(token.content)
       end
 
-      return  '<pre><code' + renderer.renderAttrs(token) + '>' + highlighted + "</code></pre>\n"
+      if highlighted.start_with?('<pre')
+        return highlighted + "\n"
+      end
+
+      # If language exists, inject class gently, without modifying original token.
+      # May be, one day we will add .clone() for token and simplify this part, but
+      # now we prefer to keep things local.
+      if !info.empty?
+        i        = token.attrIndex('class')
+        tmpAttrs = token.attrs ? token.attrs.dup : []
+
+        if i < 0
+          tmpAttrs.push([ 'class', options[:langPrefix] + langName ])
+        else
+          tmpAttrs[i][1] += ' ' + options[:langPrefix] + langName
+        end
+
+        # Fake token just to render attributes
+        tmpToken       = Token.new(nil, nil, nil)
+        tmpToken.attrs = tmpAttrs
+
+        return  '<pre><code' + renderer.renderAttrs(tmpToken) + '>' +
+                highlighted +
+                "</code></pre>\n"
+      end
+
+      return '<pre><code' + renderer.renderAttrs(token) + '>' + highlighted + "</code></pre>\n"
     end
 
     #------------------------------------------------------------------------------
@@ -84,8 +117,8 @@ module MarkdownIt
     #------------------------------------------------------------------------------
     def initialize
       @default_rules = {
-        'code_inline' => lambda {|tokens, idx, options, env, renderer| Renderer.code_inline(tokens, idx)},
-        'code_block'  => lambda {|tokens, idx, options, env, renderer| Renderer.code_block(tokens, idx)},
+        'code_inline' => lambda {|tokens, idx, options, env, renderer| Renderer.code_inline(tokens, idx, options, env, renderer)},
+        'code_block'  => lambda {|tokens, idx, options, env, renderer| Renderer.code_block(tokens, idx, options, env, renderer)},
         'fence'       => lambda {|tokens, idx, options, env, renderer| Renderer.fence(tokens, idx, options, env, renderer)},
         'image'       => lambda {|tokens, idx, options, env, renderer| Renderer.image(tokens, idx, options, env, renderer)},
         'hardbreak'   => lambda {|tokens, idx, options, env, renderer| Renderer.hardbreak(tokens, idx, options)},
@@ -94,7 +127,7 @@ module MarkdownIt
         'html_block'  => lambda {|tokens, idx, options, env, renderer| Renderer.html_block(tokens, idx)},
         'html_inline' => lambda {|tokens, idx, options, env, renderer| Renderer.html_inline(tokens, idx)}
       }
-      
+
       # Renderer#rules -> Object
       #
       # Contains render rules for tokens. Can be updated and extended.
@@ -110,7 +143,7 @@ module MarkdownIt
       # var result = md.renderInline(...);
       # ```
       #
-      # Each rule is called as independed static function with fixed signature:
+      # Each rule is called as independet static function with fixed signature:
       #
       # ```javascript
       # function my_token_render(tokens, idx, options, env, renderer) {
@@ -220,7 +253,7 @@ module MarkdownIt
 
       0.upto(tokens.length - 1) do |i|
         type = tokens[i].type
-        
+
         if rules[type] != nil
           result += rules[type].call(tokens, i, options, env, self)
         else
@@ -244,11 +277,10 @@ module MarkdownIt
     #------------------------------------------------------------------------------
     def renderInlineAsText(tokens, options, env)
       result = ''
-      rules  = @rules
 
       0.upto(tokens.length - 1) do |i|
         if tokens[i].type == 'text'
-          result += rules['text'].call(tokens, i, options, env, self)
+          result += tokens[i].content
         elsif tokens[i].type == 'image'
           result += renderInlineAsText(tokens[i].children, options, env)
         end

data/lib/motion-markdown-it/rules_block/blockquote.rb

@@ -3,38 +3,93 @@
 module MarkdownIt
   module RulesBlock
     class Blockquote
+      extend Common::Utils
 
       #------------------------------------------------------------------------------
       def self.blockquote(state, startLine, endLine, silent)
-        pos = state.bMarks[startLine] + state.tShift[startLine]
-        max = state.eMarks[startLine]
+        oldLineMax  = state.lineMax
+        pos         = state.bMarks[startLine] + state.tShift[startLine]
+        max         = state.eMarks[startLine]
+
+        # if it's indented more than 3 spaces, it should be a code block
+        return false if (state.sCount[startLine] - state.blkIndent >= 4)
 
         # check the block quote marker
         return false if state.src.charCodeAt(pos) != 0x3E # >
         pos += 1
-        
+
         # we know that it's going to be a valid blockquote,
         # so no point trying to find the end of it in silent mode
         return true if silent
 
+        # skip spaces after ">" and re-calculate offset
+        initial = offset = state.sCount[startLine] + pos - (state.bMarks[startLine] + state.tShift[startLine])
+
         # skip one optional space after '>'
-        pos += 1 if state.src.charCodeAt(pos) == 0x20
+        if state.src.charCodeAt(pos) == 0x20 # space
+          # ' >   test '
+          #     ^ -- position start of line here:
+          pos             += 1
+          initial         += 1
+          offset          +=1
+          adjustTab        = false
+          spaceAfterMarker = true
+        elsif state.src.charCodeAt(pos) == 0x09 # tab
+          spaceAfterMarker = true
 
-        oldIndent               = state.blkIndent
-        state.blkIndent         = 0
+          if ((state.bsCount[startLine] + offset) % 4 == 3)
+            # '  >\t  test '
+            #       ^ -- position start of line here (tab has width===1)
+            pos       += 1
+            initial   += 1
+            offset    += 1
+            adjustTab  = false
+          else
+            # ' >\t  test '
+            #    ^ -- position start of line here + shift bsCount slightly
+            #         to make extra space appear
+            adjustTab = true
+          end
+        else
+          spaceAfterMarker = false
+        end
 
         oldBMarks               = [ state.bMarks[startLine] ]
         state.bMarks[startLine] = pos
 
-        # check if we have an empty blockquote
-        pos                     = pos < max ? state.skipSpaces(pos) : pos
-        lastLineEmpty           = pos >= max
+        while pos < max
+          ch = state.src.charCodeAt(pos)
+
+          if isSpace(ch)
+            if ch == 0x09
+              offset += 4 - (offset + state.bsCount[startLine] + (adjustTab ? 1 : 0)) % 4
+            else
+              offset += 1
+            end
+          else
+            break
+          end
+
+          pos += 1
+        end
+
+        oldBSCount = [ state.bsCount[startLine] ]
+        state.bsCount[startLine] = state.sCount[startLine] + 1 + (spaceAfterMarker ? 1 : 0)
+
+        lastLineEmpty = pos >= max
+
+        oldSCount = [ state.sCount[startLine] ]
+        state.sCount[startLine] = offset - initial
 
         oldTShift               = [ state.tShift[startLine] ]
         state.tShift[startLine] = pos - state.bMarks[startLine]
 
         terminatorRules         = state.md.block.ruler.getRules('blockquote')
 
+        oldParentType     = state.parentType
+        state.parentType  = 'blockquote'
+        wasOutdented      = false
+
         # Search the end of the block
         #
         # Block ends with either:
@@ -48,15 +103,23 @@ module MarkdownIt
         #     >
         #     test
         #     ```
-        #  3. another tag
+        #  3. another tag:
         #     ```
         #     > test
         #      - - -
         #     ```
         nextLine = startLine + 1
         while nextLine < endLine
-          break if state.tShift[nextLine] < oldIndent
-          
+          # check if it's outdented, i.e. it's inside list item and indented
+          # less than said list item:
+          #
+          # ```
+          # 1. anything
+          #    > current blockquote
+          # 2. checking this line
+          # ```
+          wasOutdented = true if (state.sCount[nextLine] < state.blkIndent)
+
           pos = state.bMarks[nextLine] + state.tShift[nextLine]
           max = state.eMarks[nextLine]
 
@@ -65,19 +128,69 @@ module MarkdownIt
             break
           end
 
-          if state.src.charCodeAt(pos) == 0x3E   # >
+          if state.src.charCodeAt(pos) == 0x3E && !wasOutdented # >
             pos += 1
             # This line is inside the blockquote.
 
+            # skip spaces after ">" and re-calculate offset
+            initial = offset = state.sCount[nextLine] + pos - (state.bMarks[nextLine] + state.tShift[nextLine])
+
             # skip one optional space after '>'
-            pos += 1 if state.src.charCodeAt(pos) == 0x20
+            if state.src.charCodeAt(pos) == 0x20 # space
+              # ' >   test '
+              #     ^ -- position start of line here:
+              pos             += 1
+              initial         += 1
+              offset          += 1
+              adjustTab        = false
+              spaceAfterMarker = true
+            elsif state.src.charCodeAt(pos) == 0x09 # tab
+              spaceAfterMarker = true
+
+              if ((state.bsCount[nextLine] + offset) % 4 == 3)
+                # '  >\t  test '
+                #       ^ -- position start of line here (tab has width===1)
+                pos       += 1
+                initial   += 1
+                offset    += 1
+                adjustTab  = false
+              else
+                # ' >\t  test '
+                #    ^ -- position start of line here + shift bsCount slightly
+                #         to make extra space appear
+                adjustTab = true
+              end
+            else
+              spaceAfterMarker = false
+            end
 
             oldBMarks.push(state.bMarks[nextLine])
             state.bMarks[nextLine] = pos
 
-            pos = pos < max ? state.skipSpaces(pos) : pos
+            while pos < max
+              ch = state.src.charCodeAt(pos)
+
+              if isSpace(ch)
+                if ch == 0x09
+                  offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4
+                else
+                  offset += 1
+                end
+              else
+                break
+              end
+
+              pos += 1
+            end
+
             lastLineEmpty = pos >= max
 
+            oldBSCount.push(state.bsCount[nextLine])
+            state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0)
+
+            oldSCount.push(state.sCount[nextLine])
+            state.sCount[nextLine] = offset - initial\
+
             oldTShift.push(state.tShift[nextLine])
             state.tShift[nextLine] = pos - state.bMarks[nextLine]
             nextLine += 1
@@ -97,39 +210,62 @@ module MarkdownIt
               break
             end
           end
-          break if terminate
+
+          if terminate
+            # Quirk to enforce "hard termination mode" for paragraphs;
+            # normally if you call `tokenize(state, startLine, nextLine)`,
+            # paragraphs will look below nextLine for paragraph continuation,
+            # but if blockquote is terminated by another tag, they shouldn't
+            state.lineMax = nextLine
+
+            if state.blkIndent != 0
+              # state.blkIndent was non-zero, we now set it to zero,
+              # so we need to re-calculate all offsets to appear as
+              # if indent wasn't changed
+              oldBMarks.push(state.bMarks[nextLine])
+              oldBSCount.push(state.bsCount[nextLine])
+              oldTShift.push(state.tShift[nextLine])
+              oldSCount.push(state.sCount[nextLine])
+              state.sCount[nextLine] -= state.blkIndent
+            end
+
+            break
+          end
 
           oldBMarks.push(state.bMarks[nextLine])
+          oldBSCount.push(state.bsCount[nextLine])
           oldTShift.push(state.tShift[nextLine])
+          oldSCount.push(state.sCount[nextLine])
 
-          # A negative number means that this is a paragraph continuation
+          # A negative indentation means that this is a paragraph continuation
           #
-          # Any negative number will do the job here, but it's better for it
-          # to be large enough to make any bugs obvious.
-          state.tShift[nextLine] = -1
+          state.sCount[nextLine] = -1
           nextLine += 1
         end
 
-        oldParentType    = state.parentType
-        state.parentType = 'blockquote'
+        oldIndent         = state.blkIndent
+        state.blkIndent   = 0
 
-        token            = state.push('blockquote_open', 'blockquote', 1)
-        token.markup     = '>'
-        token.map        = lines = [ startLine, 0 ]
+        token             = state.push('blockquote_open', 'blockquote', 1)
+        token.markup      = '>'
+        token.map         = lines = [ startLine, 0 ]
 
         state.md.block.tokenize(state, startLine, nextLine)
 
-        token            = state.push('blockquote_close', 'blockquote', -1)
-        token.markup     = '>'
+        token             = state.push('blockquote_close', 'blockquote', -1)
+        token.markup      = '>'
 
-        state.parentType = oldParentType
-        lines[1]         = state.line
+        state.lineMax     = oldLineMax;
+        state.parentType  = oldParentType
+        lines[1]          = state.line
 
         # Restore original tShift; this might not be necessary since the parser
         # has already been here, but just to make sure we can do that.
         (0...oldTShift.length).each do |i|
-          state.bMarks[i + startLine] = oldBMarks[i]
-          state.tShift[i + startLine] = oldTShift[i]
+          state.bMarks[i + startLine]   = oldBMarks[i]
+          state.tShift[i + startLine]   = oldTShift[i]
+          state.sCount[i + startLine]   = oldSCount[i]
+          state.bsCount[i + startLine]  = oldBSCount[i]
         end
         state.blkIndent = oldIndent
         return true