motion-markdown-it 8.4.1.1 → 9.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ce02411a4d64cb6e09347db122e59cb409d77316
-  data.tar.gz: 130993721fe5e59734b17af32a77aa7980d60fcf
+SHA256:
+  metadata.gz: 2731c7d392eb70c89a0b583ff854d85ea277e299f86a6a3f02502427b4effdda
+  data.tar.gz: 25c49dfc9916421e4ea44878dd499c4e535e26d106f2663a594911002dd6cb21
 SHA512:
-  metadata.gz: 90fce20e2e664e6ea14def698f0a846c1e7235687164c48a7c0388d495fd431f11c83387534e6e965658e4211b7c55e4650f0a3681f5517f4a36a7c76e6c10a8
-  data.tar.gz: 77560ecca3754fb7ab767ee6837a69f3b15c0f89c7d966c29c87a937cfa702e5f4728e2127ead479a5dab18673ef264eba3e0b1dfe117aa98044950f5d7da34e
+  metadata.gz: f8a8d408d9a62779180b1176404c6f0e2f0616e0fd45e95e068eadec6780b1eb68268cda6a4339cd188e442e276f757d5cc54faa6f94eeb18ed5ac8992cbe410
+  data.tar.gz: f6b204daacb84fb2bd888d1246aab6882810d1c85bf5444bc92a2bc1dc837f750ec42f2df6a806550ae7822f516e2ebfddecbd386ae512f57ebf6105afb53edd

data/README.md

@@ -1,11 +1,13 @@
 # motion-markdown-it
 
 [![Gem Version](https://badge.fury.io/rb/motion-markdown-it.svg)](http://badge.fury.io/rb/motion-markdown-it)
-[![Build Status](https://travis-ci.org/digitalmoksha/motion-markdown-it.svg?branch=master)](https://travis-ci.org/digitalmoksha/motion-markdown-it)
+[![Build Status](https://github.com/digitalmoksha/motion-markdown-it/actions/workflows/ci.yml/badge.svg)](https://github.com/digitalmoksha/motion-markdown-it/actions/workflows/ci.yml)
 
 Ruby/RubyMotion version of Markdown-it (CommonMark compliant and extendable)
 
-This gem is a port of the [markdown-it Javascript package](https://github.com/markdown-it/markdown-it) by Vitaly Puzrin and Alex Kocharin. Currently synced with markdown-it 8.4.1
+This gem is a port of the [markdown-it Javascript package](https://github.com/markdown-it/markdown-it) by Vitaly Puzrin and Alex Kocharin. 
+
+_Currently synced with markdown-it 9.0.1_
 
 ---
 
@@ -55,6 +57,7 @@ redcarpet 3.4.0             0.0065
 - [Install](#install)
 - [Usage examples](#usage-examples)
 - [Plugins](#plugins)
+- [Upgrading](#upgrading)
 - [References / Thanks](#references--thanks)
 - [License](#license)
 
@@ -297,6 +300,44 @@ other implementations.
 
 -->
 
+## Upgrading
+
+Upgrading to `8.4.1.2` could cause some small breakage if you are using any custom plugins.  The [motion-markdown-it-plugins](https://github.com/digitalmoksha/motion-markdown-it-plugins) plugins have already been upgraded.
+
+#### charCodeAt
+
+Make sure you have
+
+```ruby
+include MarkdownIt::Common::Utils
+```
+
+at the top of your plugin file.  Then change any references to `charCodeAt`.  For example,
+
+```ruby
+state.src.charCodeAt(pos)
+```
+
+would become
+
+```ruby
+charCodeAt(state.src, pos)
+```
+
+#### slice_to_end
+
+`slice_to_end` has been removed.  Change references like this
+
+```ruby
+state.src.slice_to_end(pos)
+```
+
+to
+
+```ruby
+state.src[pos..-1]
+```
+
 ## References / Thanks
 
 Thanks to the authors of the original implementation in Javascript, [markdown-it](https://github.com/markdown-it/markdown-it):

data/lib/motion-markdown-it/common/entities.rb

@@ -3,6 +3,8 @@ module MarkdownIt
 
   # TODO this list needs to be brought up to same level as the WC3 document
   # http://www.w3.org/TR/xml-entity-names/byalpha.html
+  # Consider pulling in https://github.com/fb55/entities/blob/master/maps/entities.json,
+  # is kept up to date
   #------------------------------------------------------------------------------
   class HTMLEntities
 
@@ -626,6 +628,7 @@ module MarkdownIt
       'nearr'          => 0x2197,   # ↗                  NORTH EAST ARROW
       'nequiv'         => 0x2262,   # ≢                  NOT IDENTICAL TO
       'nexist'         => 0x2204,   # ∄                  THERE DOES NOT EXIST
+      'ngE'            => '≧̸',      # ≧̸                  from https://github.com/fb55/entities/blob/master/maps/entities.json
       'nge'            => 0x2271,   # ≱   dup            NEITHER GREATER-THAN NOR EQUAL TO
       'nges'           => 0x2271,   # ≱   dup       skip NEITHER GREATER-THAN NOR EQUAL TO
       'Ngr'            => 0x039d,   # Ν   dup       skip GREEK CAPITAL LETTER NU

data/lib/motion-markdown-it/common/simpleidn.rb

@@ -1,11 +1,6 @@
 # encoding: UTF-8
 # Borrowed from https://github.com/mmriis/simpleidn
 #------------------------------------------------------------------------------
-class Integer
-  def to_utf8_character
-    [self].pack("U*")
-  end
-end
 
 module SimpleIDN
     
@@ -21,7 +16,11 @@ module SimpleIDN
     SKEW = 38
     MAXINT = 0x7FFFFFFF
 
-    module_function  
+    module_function
+    
+    def to_utf8_character(int)
+      [int].pack("U*")
+    end  
     
     # decode_digit(cp) returns the numeric value of a basic code 
     # point (for use in representing integers) in the range 0 to
@@ -75,7 +74,7 @@ module SimpleIDN
       # Handle the basic code points: Let basic be the number of input code 
       # points before the last delimiter, or 0 if there is none, then
       # copy the first basic code points to the output.
-      basic = input.rindex(DELIMITER.to_utf8_character) || 0
+      basic = input.rindex(to_utf8_character(DELIMITER)) || 0
 
       input.unpack("U*")[0, basic].each do |char|
         raise(RangeError, "Illegal input >= 0x80") if char >= 0x80
@@ -126,7 +125,7 @@ module SimpleIDN
         i %= out
 
         # Insert n at position i of the output: 
-        output.insert(i, n.to_utf8_character)
+        output.insert(i, to_utf8_character(n))
         i += 1
       end
     
@@ -202,7 +201,7 @@ module SimpleIDN
         delta += 1
         n += 1
       end
-      return output.collect {|c| c.to_utf8_character}.join
+      return output.collect {|c| to_utf8_character(c)}.join
     end
 
   end

data/lib/motion-markdown-it/common/utils.rb

@@ -48,7 +48,10 @@ module MarkdownIt
 
       #------------------------------------------------------------------------------
       def fromCodePoint(c)
-        c.chr(Encoding::UTF_8)
+        # Some html entities are mapped directly as characters rather than code points.
+        # So if we're passed an Integer, convert to character, otherwise just return
+        # the character.  For example `≧̸`
+        c.is_a?(Integer) ? c.chr(Encoding::UTF_8) : c
       end
 
       #------------------------------------------------------------------------------
@@ -56,6 +59,10 @@ module MarkdownIt
         c.chr
       end
 
+      #------------------------------------------------------------------------------
+      def charCodeAt(str, ch)
+        str[ch].ord unless str[ch].nil?
+      end
 
       UNESCAPE_MD_RE  = /\\([\!\"\#\$\%\&\'\(\)\*\+\,\-.\/:;<=>?@\[\\\]^_`{|}~])/
 
@@ -70,8 +77,8 @@ module MarkdownIt
 
         return fromCodePoint(MarkdownIt::HTMLEntities::MAPPINGS[name]) if MarkdownIt::HTMLEntities::MAPPINGS[name]
 
-        if (name.charCodeAt(0) == 0x23 && DIGITAL_ENTITY_TEST_RE =~ name) # '#'
-          code = name[1].downcase == 'x' ? name.slice_to_end(2).to_i(16) : name.slice_to_end(1).to_i
+        if (charCodeAt(name, 0) == 0x23 && DIGITAL_ENTITY_TEST_RE =~ name) # '#'
+          code = name[1].downcase == 'x' ? name[2..-1].to_i(16) : name[1..-1].to_i
           if (isValidEntityCode(code))
             return fromCodePoint(code)
           end
@@ -212,11 +219,44 @@ module MarkdownIt
       # Hepler to unify [reference labels].
       #------------------------------------------------------------------------------
       def normalizeReference(str)
-        # use .toUpperCase() instead of .toLowerCase()
-        # here to avoid a conflict with Object.prototype
-        # members (most notably, `__proto__`)
-        return str.strip.gsub(/\s+/, ' ').upcase
+        # Trim and collapse whitespace
+        #
+        str = str.strip.gsub(/\s+/, ' ')
+
+        # .toLowerCase().toUpperCase() should get rid of all differences
+        # between letter variants.
+        #
+        # Simple .toLowerCase() doesn't normalize 125 code points correctly,
+        # and .toUpperCase doesn't normalize 6 of them (list of exceptions:
+        # İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently
+        # uppercased versions).
+        #
+        # Here's an example showing how it happens. Lets take greek letter omega:
+        # uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)
+        #
+        # Unicode entries:
+        # 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8;
+        # 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398
+        # 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398
+        # 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8;
+        #
+        # Case-insensitive comparison should treat all of them as equivalent.
+        #
+        # But .toLowerCase() doesn't change ϑ (it's already lowercase),
+        # and .toUpperCase() doesn't change ϴ (already uppercase).
+        #
+        # Applying first lower then upper case normalizes any character:
+        # '\u0398\u03f4\u03b8\u03d1'.toLowerCase().toUpperCase() === '\u0398\u0398\u0398\u0398'
+        #
+        # Note: this is equivalent to unicode case folding; unicode normalization
+        # is a different step that is not required here.
+        #
+        # Final result should be uppercased, because it's later stored in an object
+        # (this avoid a conflict with Object.prototype members,
+        # most notably, `__proto__`)
+        #
+        return str.downcase.upcase
       end
     end
   end
-end
+end

data/lib/motion-markdown-it/helpers/parse_link_destination.rb

@@ -11,11 +11,11 @@ module MarkdownIt
         start = pos
         result = {ok: false, pos: 0, lines: 0, str: ''}
 
-        if (str.charCodeAt(pos) == 0x3C ) # <
+        if (charCodeAt(str, pos) == 0x3C ) # <
           pos += 1
           while (pos < max)
-            code = str.charCodeAt(pos)
-            return result if (code == 0x0A || isSpace(code)) # \n
+            code = charCodeAt(str, pos)
+            return result if (code == 0x0A) # \n
             if (code == 0x3E) #  >
               result[:pos] = pos + 1
               result[:str] = unescapeAll(str.slice((start + 1)...pos))
@@ -38,7 +38,7 @@ module MarkdownIt
 
         level = 0
         while (pos < max)
-          code = str.charCodeAt(pos)
+          code = charCodeAt(str, pos)
 
           break if (code == 0x20)
 
@@ -73,4 +73,4 @@ module MarkdownIt
       end
     end
   end
-end
+end

data/lib/motion-markdown-it/helpers/parse_link_label.rb

@@ -15,7 +15,7 @@ module MarkdownIt
         level     = 1
 
         while (state.pos < max)
-          marker = state.src.charCodeAt(state.pos)
+          marker = charCodeAt(state.src, state.pos)
           if (marker == 0x5D) # ]
             level -= 1
             if (level == 0)

data/lib/motion-markdown-it/helpers/parse_link_title.rb

@@ -12,7 +12,7 @@ module MarkdownIt
 
         return result if (pos >= max)
 
-        marker = str.charCodeAt(pos)
+        marker = charCodeAt(str, pos)
 
         return result if (marker != 0x22 && marker != 0x27 && marker != 0x28) # " ' (
 
@@ -22,7 +22,7 @@ module MarkdownIt
         marker = 0x29 if (marker == 0x28)
 
         while (pos < max)
-          code = str.charCodeAt(pos)
+          code = charCodeAt(str, pos)
           if (code == marker)
             result[:pos]   = pos + 1
             result[:lines] = lines
@@ -33,7 +33,7 @@ module MarkdownIt
             lines += 1
           elsif (code == 0x5C && pos + 1 < max) # \
             pos += 1
-            if (str.charCodeAt(pos) == 0x0A)
+            if (charCodeAt(str, pos) == 0x0A)
               lines += 1
             end
           end

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

@@ -8,9 +8,9 @@ module MarkdownIt
   class ParserCore
 
     attr_accessor   :ruler
-    
+
     RULES = [
-      [ 'normalize',      lambda { |state| RulesCore::Normalize.inline(state) }         ],
+      [ 'normalize',      lambda { |state| RulesCore::Normalize.normalize(state) }         ],
       [ 'block',          lambda { |state| RulesCore::Block.block(state) }              ],
       [ 'inline',         lambda { |state| RulesCore::Inline.inline(state) }            ],
       [ 'linkify',        lambda { |state| RulesCore::Linkify.linkify(state) }          ],
@@ -43,4 +43,4 @@ module MarkdownIt
       end
     end
   end
-end
+end

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

@@ -16,7 +16,7 @@
 #------------------------------------------------------------------------------
 
 module MarkdownIt
-  class Ruler 
+  class Ruler
 
     def initialize
       # // List of added rules. Each element is:
@@ -94,7 +94,7 @@ module MarkdownIt
     # *
     # * ##### Example
     # *
-    # * Replace existing typorgapher replacement rule with new one:
+    # * Replace existing typographer replacement rule with new one:
     # *
     # * ```javascript
     # * var md = require('markdown-it')();
@@ -108,7 +108,7 @@ module MarkdownIt
       index = __find__(name)
 
       raise(StandardError, "Parser rule not found: #{name}") if index == -1
-      
+
       @__rules__[index][:fn] = fn
       @__rules__[index][:alt] = opt[:alt] || ['']
       @__cache__ = nil

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

@@ -15,7 +15,7 @@ module MarkdownIt
         return false if (state.sCount[startLine] - state.blkIndent >= 4)
 
         # check the block quote marker
-        return false if state.src.charCodeAt(pos) != 0x3E # >
+        return false if charCodeAt(state.src, pos) != 0x3E # >
         pos += 1
 
         # we know that it's going to be a valid blockquote,
@@ -26,7 +26,7 @@ module MarkdownIt
         initial = offset = state.sCount[startLine] + pos - (state.bMarks[startLine] + state.tShift[startLine])
 
         # skip one optional space after '>'
-        if state.src.charCodeAt(pos) == 0x20 # space
+        if charCodeAt(state.src, pos) == 0x20 # space
           # ' >   test '
           #     ^ -- position start of line here:
           pos             += 1
@@ -34,7 +34,7 @@ module MarkdownIt
           offset          +=1
           adjustTab        = false
           spaceAfterMarker = true
-        elsif state.src.charCodeAt(pos) == 0x09 # tab
+        elsif charCodeAt(state.src, pos) == 0x09 # tab
           spaceAfterMarker = true
 
           if ((state.bsCount[startLine] + offset) % 4 == 3)
@@ -58,7 +58,7 @@ module MarkdownIt
         state.bMarks[startLine] = pos
 
         while pos < max
-          ch = state.src.charCodeAt(pos)
+          ch = charCodeAt(state.src, pos)
 
           if isSpace(ch)
             if ch == 0x09
@@ -128,7 +128,7 @@ module MarkdownIt
             break
           end
 
-          if state.src.charCodeAt(pos) == 0x3E && !wasOutdented # >
+          if charCodeAt(state.src, pos) == 0x3E && !wasOutdented # >
             pos += 1
             # This line is inside the blockquote.
 
@@ -136,7 +136,7 @@ module MarkdownIt
             initial = offset = state.sCount[nextLine] + pos - (state.bMarks[nextLine] + state.tShift[nextLine])
 
             # skip one optional space after '>'
-            if state.src.charCodeAt(pos) == 0x20 # space
+            if charCodeAt(state.src, pos) == 0x20 # space
               # ' >   test '
               #     ^ -- position start of line here:
               pos             += 1
@@ -144,7 +144,7 @@ module MarkdownIt
               offset          += 1
               adjustTab        = false
               spaceAfterMarker = true
-            elsif state.src.charCodeAt(pos) == 0x09 # tab
+            elsif charCodeAt(state.src, pos) == 0x09 # tab
               spaceAfterMarker = true
 
               if ((state.bsCount[nextLine] + offset) % 4 == 3)
@@ -168,7 +168,7 @@ module MarkdownIt
             state.bMarks[nextLine] = pos
 
             while pos < max
-              ch = state.src.charCodeAt(pos)
+              ch = charCodeAt(state.src, pos)
 
               if isSpace(ch)
                 if ch == 0x09

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

@@ -16,7 +16,7 @@ module MarkdownIt
 
         return false if pos + 3 > max
 
-        marker = state.src.charCodeAt(pos)
+        marker = charCodeAt(state.src, pos)
 
         if marker != 0x7E && marker != 0x60 #  != ~ && != `
           return false
@@ -32,7 +32,9 @@ module MarkdownIt
         markup = state.src.slice(mem...pos)
         params = state.src.slice(pos...max)
 
-        return false if params.include?(fromCharCode(marker))
+        if (marker == 0x60) # `
+          return false if params.include?(fromCharCode(marker))
+        end
 
         # Since start is found, we can report success here in validation mode
         return true if silent
@@ -58,7 +60,7 @@ module MarkdownIt
             break
           end
 
-          next if state.src.charCodeAt(pos) != marker
+          next if charCodeAt(state.src, pos) != marker
 
           if state.sCount[nextLine] - state.blkIndent >= 4
             # closing fence should be indented less than 4 spaces

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

@@ -13,18 +13,18 @@ module MarkdownIt
         # if it's indented more than 3 spaces, it should be a code block
         return false if state.sCount[startLine] - state.blkIndent >= 4
 
-        ch  = state.src.charCodeAt(pos)
+        ch  = charCodeAt(state.src, pos)
 
         return false if (ch != 0x23 || pos >= max)
 
         # count heading level
         level = 1
         pos  += 1
-        ch = state.src.charCodeAt(pos)
+        ch = charCodeAt(state.src, pos)
         while (ch == 0x23 && pos < max && level <= 6)  # '#'
           level += 1
           pos   += 1
-          ch = state.src.charCodeAt(pos)
+          ch = charCodeAt(state.src, pos)
         end
 
         return false if (level > 6 || (pos < max && !isSpace(ch)))
@@ -35,7 +35,7 @@ module MarkdownIt
 
         max = state.skipSpacesBack(max, pos)
         tmp = state.skipCharsBack(max, 0x23, pos) # '#'
-        if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1)))
+        if (tmp > pos && isSpace(charCodeAt(state.src, tmp - 1)))
           max = tmp
         end
 

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

@@ -13,7 +13,7 @@ module MarkdownIt
         # if it's indented more than 3 spaces, it should be a code block
         return false if (state.sCount[startLine] - state.blkIndent >= 4)
 
-        marker = state.src.charCodeAt(pos)
+        marker = charCodeAt(state.src, pos)
         pos   += 1
 
         # Check hr marker
@@ -27,7 +27,7 @@ module MarkdownIt
 
         cnt = 1
         while (pos < max)
-          ch   = state.src.charCodeAt(pos)
+          ch   = charCodeAt(state.src, pos)
           pos += 1
           return false if ch != marker && !isSpace(ch)
           cnt += 1 if ch == marker

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

@@ -3,6 +3,7 @@
 module MarkdownIt
   module RulesBlock
     class HtmlBlock
+      extend Common::Utils
 
       HTML_OPEN_CLOSE_TAG_RE = MarkdownIt::Common::HtmlRe::HTML_OPEN_CLOSE_TAG_RE
 
@@ -28,7 +29,7 @@ module MarkdownIt
         return false if state.sCount[startLine] - state.blkIndent >= 4
 
         return false if !state.md.options[:html]
-        return false if state.src.charCodeAt(pos) != 0x3C    # <
+        return false if charCodeAt(state.src, pos) != 0x3C    # <
 
         lineText = state.src.slice(pos...max)
 

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

@@ -3,6 +3,7 @@
 module MarkdownIt
   module RulesBlock
     class Lheading
+      extend Common::Utils
 
       #------------------------------------------------------------------------------
       def self.lheading(state, startLine, endLine, silent = true)
@@ -29,7 +30,7 @@ module MarkdownIt
             max = state.eMarks[nextLine]
 
             if pos < max
-              marker = state.src.charCodeAt(pos)
+              marker = charCodeAt(state.src, pos)
 
               if marker == 0x2D || marker == 0x3D # - or =
                 pos = state.skipChars(pos, marker)

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

@@ -12,7 +12,7 @@ module MarkdownIt
         pos = state.bMarks[startLine] + state.tShift[startLine]
         max = state.eMarks[startLine]
 
-        marker = state.src.charCodeAt(pos)
+        marker = charCodeAt(state.src, pos)
         pos   += 1
         # Check bullet
         if (marker != 0x2A && # *
@@ -22,7 +22,7 @@ module MarkdownIt
         end
 
         if pos < max
-          ch = state.src.charCodeAt(pos)
+          ch = charCodeAt(state.src, pos)
 
           if !isSpace(ch)
             # " -test " - is not a list item
@@ -44,7 +44,7 @@ module MarkdownIt
         # List marker should have at least 2 chars (digit + dot)
         return -1 if (pos + 1 >= max)
 
-        ch   = state.src.charCodeAt(pos)
+        ch   = charCodeAt(state.src, pos)
         pos += 1
 
         return -1 if ch.nil?
@@ -54,7 +54,7 @@ module MarkdownIt
           # EOL -> fail
           return -1 if (pos >= max)
 
-          ch   = state.src.charCodeAt(pos)
+          ch   = charCodeAt(state.src, pos)
           pos += 1
 
           if (ch >= 0x30 && ch <= 0x39) #  >= 0 && <= 9
@@ -75,7 +75,7 @@ module MarkdownIt
         end
 
         if pos < max
-          ch = state.src.charCodeAt(pos)
+          ch = charCodeAt(state.src, pos)
 
           if !isSpace(ch)
             # " 1.test " - is not a list item
@@ -109,6 +109,18 @@ module MarkdownIt
         # if it's indented more than 3 spaces, it should be a code block
         return false if (state.sCount[startLine] - state.blkIndent >= 4)
 
+        # Special case:
+        #  - item 1
+        #   - item 2
+        #    - item 3
+        #     - item 4
+        #      - this one is a paragraph continuation
+        if (state.listIndent >= 0 &&
+            state.sCount[startLine] - state.listIndent >= 4 &&
+            state.sCount[startLine] < state.blkIndent)
+          return false
+        end
+
         # limit conditions when list can interrupt
         # a paragraph (validation mode only)
         if silent && state.parentType == 'paragraph'
@@ -144,7 +156,7 @@ module MarkdownIt
         end
 
         # We should terminate list on style change. Remember first one to compare.
-        markerCharCode = state.src.charCodeAt(posAfterMarker - 1)
+        markerCharCode = charCodeAt(state.src, posAfterMarker - 1)
 
         # For validation mode we can terminate immediately
         return true if (silent)
@@ -185,7 +197,7 @@ module MarkdownIt
           initial = offset = state.sCount[nextLine] + posAfterMarker - (state.bMarks[startLine] + state.tShift[startLine])
 
           while pos < max
-            ch = state.src.charCodeAt(pos)
+            ch = charCodeAt(state.src, pos)
 
             if ch == 0x09
               offset += 4 - (offset + state.bsCount[nextLine]) % 4
@@ -220,11 +232,19 @@ module MarkdownIt
           token.markup = markerCharCode.chr
           token.map    = itemLines = [ startLine, 0 ]
 
-          oldIndent               = state.blkIndent
+          # change current state, then restore it after parser subcall
           oldTight                = state.tight
           oldTShift               = state.tShift[startLine]
-          oldLIndent              = state.sCount[startLine]
+          oldSCount               = state.sCount[startLine]
+
+          #  - example list
+          # ^ listIndent position will be here
+          #   ^ blkIndent position will be here
+          #
+          oldListIndent           = state.listIndent
+          state.listIndent        = state.blkIndent
           state.blkIndent         = indent
+
           state.tight             = true
           state.tShift[startLine] = contentStart - state.bMarks[startLine]
           state.sCount[startLine] = offset
@@ -250,9 +270,10 @@ module MarkdownIt
           # but we should filter last element, because it means list finish
           prevEmptyEnd = (state.line - startLine) > 1 && state.isEmpty(state.line - 1)
 
-          state.blkIndent         = oldIndent
+          state.blkIndent         = state.listIndent
+          state.listIndent        = oldListIndent
           state.tShift[startLine] = oldTShift
-          state.sCount[startLine] = oldLIndent
+          state.sCount[startLine] = oldSCount
           state.tight             = oldTight
 
           token                   = state.push('list_item_close', 'li', -1)
@@ -269,6 +290,9 @@ module MarkdownIt
           #
           break if (state.sCount[nextLine] < state.blkIndent)
 
+          # if it's indented more than 3 spaces, it should be a code block
+          break if (state.sCount[startLine] - state.blkIndent >= 4)
+
           # fail if terminating block found
           terminate = false
           (0...terminatorRules.length).each do |i|
@@ -288,7 +312,7 @@ module MarkdownIt
             break if (posAfterMarker < 0)
           end
 
-          break if (markerCharCode != state.src.charCodeAt(posAfterMarker - 1))
+          break if (markerCharCode != charCodeAt(state.src, posAfterMarker - 1))
         end
 
         # Finalize list