motion-markdown-it 8.4.1.2 → 10.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 650922a627efaf3a0b14a2b615a77fa2368f3fa9521aebd02fa8102a9d472c03
-  data.tar.gz: e615b7de9baa7f930d2e69f3e8d6562d4796373e112602cc19b9472d5e4ed628
+  metadata.gz: a7f2ac0d111cfc878b1017c5e3c32d1e9a6b9468176051937bac57f0378e5ac8
+  data.tar.gz: 13b8f19a17c53fca0f8ae6c8e373f219bb90b9e6152e7d3a9a0b1ad54c3f7c63
 SHA512:
-  metadata.gz: 13890868afe5b3eb188a35fbcd0042c9334e5047a7e05fe46262ca45cd8bd919442e129856b74dfd8844edf66884899f3c36bf350664cd2e9b057d2d43690985
-  data.tar.gz: 73b64c8811203fb281a8ab9d802ca59ae330b2134d6d2cf0142c8fd20ca526efc97667ef8f080485f4d1e6f4f37813ee45b925df5e661a90f377e561fce636b2
+  metadata.gz: d632e566f5280d655dac450d8e5c9532dc17829ec8c40aee01c1b35df2909f55e467940e2598bf557aa8c4ee85285a0d6bb1801a28ed1ddd3c1a1767a306c9eb
+  data.tar.gz: f669a717a5d9f56c2f9d9d7669bd329610b0120a2dceeca3334eb72411184b371448d71a03ad04e4ff9d4f7c7d499750f98b091bd1415ba709011193b0fd385b

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 10.0.0_
 
 ---
 
@@ -52,12 +54,15 @@ redcarpet 3.4.0             0.0065
 
 ## Table of content
 
-- [Install](#install)
-- [Usage examples](#usage-examples)
-- [Plugins](#plugins)
-- [Upgrading](#upgrading)
-- [References / Thanks](#references--thanks)
-- [License](#license)
+- [markdown-it](#markdown-it)
+  - [Install](#install)
+  - [Usage examples](#usage-examples)
+    - [Simple](#simple)
+    - [Init with presets and options](#init-with-presets-and-options)
+  - [Plugins](#plugins)
+  - [Upgrading](#upgrading)
+  - [References / Thanks](#references--thanks)
+  - [License](#license)
 
 <!--
 - [API](#api)

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/utils.rb

@@ -48,14 +48,17 @@ 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
 
       #------------------------------------------------------------------------------
       def fromCharCode(c)
         c.chr
       end
-      
+
       #------------------------------------------------------------------------------
       def charCodeAt(str, ch)
         str[ch].ord unless str[ch].nil?
@@ -216,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

@@ -15,7 +15,7 @@ module MarkdownIt
           pos += 1
           while (pos < max)
             code = charCodeAt(str, pos)
-            return result if (code == 0x0A || isSpace(code)) # \n
+            return result if (code == 0x0A) # \n
             if (code == 0x3E) #  >
               result[:pos] = pos + 1
               result[:str] = unescapeAll(str.slice((start + 1)...pos))
@@ -73,4 +73,4 @@ module MarkdownIt
       end
     end
   end
-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/fence.rb

@@ -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

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

@@ -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'
@@ -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|

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

@@ -6,7 +6,7 @@ module MarkdownIt
       include MarkdownIt::Common::Utils
 
       attr_accessor     :src, :md, :env, :tokens, :bMarks, :eMarks, :tShift, :sCount, :bsCount
-      attr_accessor     :blkIndent, :line, :lineMax, :tight, :parentType, :ddIndent
+      attr_accessor     :blkIndent, :line, :lineMax, :tight, :parentType, :ddIndent, :listIndent
       attr_accessor     :level, :result
 
       #------------------------------------------------------------------------------
@@ -39,12 +39,14 @@ module MarkdownIt
         @bsCount    = []
 
         # block parser variables
-        @blkIndent  = 0       # required block content indent (for example, if we are in list)
+        @blkIndent  = 0       # equired block content indent (for example, if we are
+                              # inside a list, it would be positioned after list marker)
         @line       = 0       # line index in src
         @lineMax    = 0       # lines count
         @tight      = false   # loose/tight mode for lists
         @parentType = 'root'  # if `list`, block parser stops on two newlines
         @ddIndent   = -1      # indent of the current dd block (-1 if there isn't any)
+        @listIndent = -1      # indent of the current list block (-1 if there isn't any)
 
         # can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'
         # used in lists to determine if they interrupt a paragraph
@@ -113,9 +115,9 @@ module MarkdownIt
         token       = Token.new(type, tag, nesting)
         token.block = true
 
-        @level -= 1 if nesting < 0
+        @level -= 1 if nesting < 0 # closing tag
         token.level = @level
-        @level += 1 if nesting > 0
+        @level += 1 if nesting > 0 # opening tag
 
         @tokens.push(token)
         return token
@@ -236,4 +238,4 @@ module MarkdownIt
 
     end
   end
-end
+end

data/lib/motion-markdown-it/rules_core/normalize.rb

@@ -4,11 +4,12 @@ module MarkdownIt
   module RulesCore
     class Normalize
 
-      NEWLINES_RE  = /\r[\n\u0085]?|[\u2424\u2028\u0085]/
-      NULL_RE      = /\u0000/
+      # https://spec.commonmark.org/0.29/#line-ending
+      NEWLINES_RE  = /\r\n?|\n/
+      NULL_RE      = /\0/
 
       #------------------------------------------------------------------------------
-      def self.inline(state)
+      def self.normalize(state)
         # Normalize newlines
         str = state.src.gsub(NEWLINES_RE, "\n")
 
@@ -19,4 +20,4 @@ module MarkdownIt
       end
     end
   end
-end
+end

data/lib/motion-markdown-it/rules_core/replacements.rb

@@ -1,4 +1,4 @@
-# Simple typographyc replacements
+# Simple typographic replacements
 #
 # (c) (C) → ©
 # (tm) (TM) → ™

data/lib/motion-markdown-it/rules_inline/backticks.rb

@@ -35,7 +35,9 @@ module MarkdownIt
             if (!silent)
               token         = state.push('code_inline', 'code', 0)
               token.markup  = marker
-              token.content = state.src.slice(pos...matchStart).gsub(/[ \n]+/, ' ').strip
+              token.content = state.src.slice(pos...matchStart)
+                .gsub(/\n/, ' ')
+                .gsub(/^ (.+) $/, '\1')
             end
             state.pos = matchEnd
             return true

data/lib/motion-markdown-it/rules_inline/balance_pairs.rb

@@ -5,44 +5,107 @@ module MarkdownIt
     class BalancePairs
 
       #------------------------------------------------------------------------------
-      def self.link_pairs(state)
-        delimiters = state.delimiters
-        max = state.delimiters.length
-
-        0.upto(max - 1) do |i|
-          lastDelim = delimiters[i]
-
-          next if !lastDelim[:close]
-
-          j = i - lastDelim[:jump] - 1
-
-          while j >= 0
-            currDelim = delimiters[j]
-
-            if currDelim[:open] &&
-               currDelim[:marker] == lastDelim[:marker] &&
-               currDelim[:end] < 0 &&
-               currDelim[:level] == lastDelim[:level]
-
-              # typeofs are for backward compatibility with plugins
-              # not needed:  typeof currDelim.length !== 'undefined' &&
-              #              typeof lastDelim.length !== 'undefined' &&
-              odd_match = (currDelim[:close] || lastDelim[:open]) &&
-                          (currDelim[:length] + lastDelim[:length]) % 3 == 0
-
-              if !odd_match
-                lastDelim[:jump] = i - j
-                lastDelim[:open] = false
-                currDelim[:end]  = i
-                currDelim[:jump] = 0
+      def self.processDelimiters(state, delimiters)
+        openersBottom = {}
+        max = delimiters.length
+        
+        0.upto(max - 1) do |closerIdx|
+          closer = delimiters[closerIdx]
+      
+          # Length is only used for emphasis-specific "rule of 3",
+          # if it's not defined (in strikethrough or 3rd party plugins),
+          # we can default it to 0 to disable those checks.
+          #
+          closer[:length] = closer[:length] || 0
+      
+          next if (!closer[:close])
+      
+          # Previously calculated lower bounds (previous fails)
+          # for each marker and each delimiter length modulo 3.
+          unless openersBottom[closer[:marker]]
+            openersBottom[closer[:marker]] = [ -1, -1, -1 ]
+          end
+      
+          minOpenerIdx = openersBottom[closer[:marker]][closer[:length] % 3]
+          newMinOpenerIdx = -1
+      
+          openerIdx = closerIdx - closer[:jump] - 1
+      
+          while openerIdx > minOpenerIdx
+            opener = delimiters[openerIdx]
+      
+            (openerIdx -= opener[:jump] + 1) && next if (opener[:marker] != closer[:marker])
+      
+            newMinOpenerIdx = openerIdx if (newMinOpenerIdx == -1)
+      
+            if (opener[:open] &&
+                opener[:end] < 0 &&
+                opener[:level] == closer[:level])
+      
+              isOddMatch = false
+      
+              # from spec:
+              #
+              # If one of the delimiters can both open and close emphasis, then the
+              # sum of the lengths of the delimiter runs containing the opening and
+              # closing delimiters must not be a multiple of 3 unless both lengths
+              # are multiples of 3.
+              #
+              if (opener[:close] || closer[:open])
+                if ((opener[:length] + closer[:length]) % 3 == 0)
+                  if (opener[:length] % 3 != 0 || closer[:length] % 3 != 0)
+                    isOddMatch = true
+                  end
+                end
+              end
+      
+              if (!isOddMatch)
+                # If previous delimiter cannot be an opener, we can safely skip
+                # the entire sequence in future checks. This is required to make
+                # sure algorithm has linear complexity (see *_*_*_*_*_... case).
+                #
+                lastJump = openerIdx > 0 && !delimiters[openerIdx - 1][:open] ?
+                  delimiters[openerIdx - 1][:jump] + 1 : 0
+      
+                closer[:jump]  = closerIdx - openerIdx + lastJump
+                closer[:open]  = false
+                opener[:end]   = closerIdx
+                opener[:jump]  = lastJump
+                opener[:close] = false
+                newMinOpenerIdx = -1
                 break
               end
             end
+            
+            openerIdx -= opener[:jump] + 1
+          end
+      
+          if (newMinOpenerIdx != -1)
+            # If match for this delimiter run failed, we want to set lower bound for
+            # future lookups. This is required to make sure algorithm has linear
+            # complexity.
+            #
+            # See details here:
+            # https://github.com/commonmark/cmark/issues/178#issuecomment-270417442
+            #
+            openersBottom[closer[:marker]][(closer[:length] || 0) % 3] = newMinOpenerIdx
+          end
+        end
+      end
+
+      #------------------------------------------------------------------------------
+      def self.link_pairs(state)
+        tokens_meta = state.tokens_meta
+        max = state.tokens_meta.length
 
-            j -= currDelim[:jump] + 1
+        processDelimiters(state, state.delimiters)
+      
+        0.upto(max - 1) do |curr|
+          if (tokens_meta[curr] && tokens_meta[curr][:delimiters])
+            processDelimiters(state, tokens_meta[curr][:delimiters])
           end
         end
       end
     end
   end
-end
+end

data/lib/motion-markdown-it/rules_inline/emphasis.rb

@@ -43,10 +43,6 @@ module MarkdownIt
             #
             token:  state.tokens.length - 1,
 
-            # Token level.
-            #
-            level:  state.level,
-
             # If this delimiter is matched as a valid opener, `end` will be
             # equal to its position, otherwise it's `-1`.
             #
@@ -65,12 +61,8 @@ module MarkdownIt
         return true
       end
 
-
-      # Walk through delimiter list and replace text tokens with tags
-      #
-      def self.postProcess(state)
-        delimiters = state.delimiters
-        max = state.delimiters.length
+      def self.private_postProcess(state, delimiters)
+        max = delimiters.length
 
         i = max - 1
         while i >= 0
@@ -119,6 +111,21 @@ module MarkdownIt
           i -= 1
         end
       end
+      
+      # Walk through delimiter list and replace text tokens with tags
+      #
+      def self.postProcess(state)
+        tokens_meta = state.tokens_meta
+        max = state.tokens_meta.length
+      
+        private_postProcess(state, state.delimiters)
+
+        0.upto(max - 1) do |curr|
+          if (tokens_meta[curr] && tokens_meta[curr][:delimiters])
+            private_postProcess(state, tokens_meta[curr][:delimiters])
+          end
+        end
+      end
     end
   end
 end

data/lib/motion-markdown-it/rules_inline/entity.rb

@@ -5,7 +5,7 @@ module MarkdownIt
     class Entity
       extend Common::Utils
 
-      DIGITAL_RE = /^&#((?:x[a-f0-9]{1,8}|[0-9]{1,8}));/i
+      DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i
       NAMED_RE   = /^&([a-z][a-z0-9]{1,31});/i
 
 

data/lib/motion-markdown-it/rules_inline/state_inline.rb

@@ -5,7 +5,7 @@ module MarkdownIt
     class StateInline
       include MarkdownIt::Common::Utils
 
-      attr_accessor   :src, :env, :md, :tokens, :pos, :posMax, :level
+      attr_accessor   :src, :env, :md, :tokens, :pos, :posMax, :level, :tokens_meta
       attr_accessor   :pending, :pendingLevel, :cache, :delimiters
 
       #------------------------------------------------------------------------------
@@ -14,6 +14,7 @@ module MarkdownIt
         @env          = env
         @md           = md
         @tokens       = outTokens
+        @tokens_meta  = Array.new(outTokens.length)
 
         @pos          = 0
         @posMax       = @src.length
@@ -21,9 +22,15 @@ module MarkdownIt
         @pending      = ''
         @pendingLevel = 0
 
-        @cache        = {}      # Stores { start: end } pairs. Useful for backtrack
-                                # optimization of pairs parse (emphasis, strikes).
-        @delimiters   = []
+        # Stores { start: end } pairs. Useful for backtrack
+        # optimization of pairs parse (emphasis, strikes).
+        @cache = {}
+                          
+        # List of emphasis-like delimiters for current tag
+        @delimiters = []
+
+        # Stack of delimiter lists for upper level tags
+        @_prev_delimiters = [];
       end
 
 
@@ -44,13 +51,29 @@ module MarkdownIt
       def push(type, tag, nesting)
         pushPending unless @pending.empty?
 
-        token       = Token.new(type, tag, nesting);
-        @level     -= 1 if nesting < 0
+        token      = Token.new(type, tag, nesting)
+        token_meta = nil
+
+        if nesting < 0
+          # closing tag
+          @level -= 1 
+          @delimiters = @_prev_delimiters.pop
+        end
+
         token.level = @level
-        @level     += 1 if nesting > 0
+
+        if nesting > 0
+          # opening tag
+          @level += 1
+          @_prev_delimiters.push(@delimiters)
+          @delimiters = []
+          token_meta = { delimiters: @delimiters }
+        end
 
         @pendingLevel = @level
         @tokens.push(token)
+        @tokens_meta.push(token_meta)
+
         return token
       end
 
@@ -113,4 +136,4 @@ module MarkdownIt
       end
     end
   end
-end
+end

data/lib/motion-markdown-it/rules_inline/strikethrough.rb

@@ -34,10 +34,9 @@ module MarkdownIt
 
           state.delimiters.push({
             marker: marker,
-            length: scanned[:length],
+            length: 0, # disable "rule of 3" length checks meant for emphasis
             jump:   i,
             token:  state.tokens.length - 1,
-            level:  state.level,
             end:    -1,
             open:   scanned[:can_open],
             close:  scanned[:can_close]
@@ -50,12 +49,9 @@ module MarkdownIt
         return true
       end
 
-      # Walk through delimiter list and replace text tokens with tags
-      #------------------------------------------------------------------------------
-      def self.postProcess(state)
+      def self.private_postProcess(state, delimiters)
         loneMarkers = []
-        delimiters  = state.delimiters
-        max         = state.delimiters.length
+        max         = delimiters.length
 
         0.upto(max - 1) do |i|
           startDelim = delimiters[i]
@@ -109,6 +105,21 @@ module MarkdownIt
           end
         end
       end
+
+      # Walk through delimiter list and replace text tokens with tags
+      #
+      def self.postProcess(state)
+        tokens_meta = state.tokens_meta
+        max = state.tokens_meta.length
+      
+        private_postProcess(state, state.delimiters)
+
+        0.upto(max - 1) do |curr|
+          if (tokens_meta[curr] && tokens_meta[curr][:delimiters])
+            private_postProcess(state, tokens_meta[curr][:delimiters])
+          end
+        end
+      end
     end
   end
 end

data/lib/motion-markdown-it/rules_inline/text_collapse.rb

@@ -1,4 +1,10 @@
+# Clean up tokens after emphasis and strikethrough postprocessing:
 # Merge adjacent text nodes into one, and re-calculate all token levels
+#
+# This is necessary because initially emphasis delimiter markers (*, _, ~)
+# are treated as their own separate text tokens. Then emphasis rule either
+# leaves them as text (needed to merge with adjacent text) or turns them
+# into opening/closing tags (which messes up levels inside).
 #------------------------------------------------------------------------------
 module MarkdownIt
   module RulesInline
@@ -12,9 +18,11 @@ module MarkdownIt
 
         last = curr = 0
         while curr < max
-          # re-calculate levels
-          level += tokens[curr].nesting
+          # re-calculate levels after emphasis/strikethrough turns some text nodes
+          # into opening/closing tags
+          level -= 1 if tokens[curr].nesting < 0 # closing tag
           tokens[curr].level = level
+          level += 1 if tokens[curr].nesting > 0 # opening tag
 
           if tokens[curr].type == 'text' &&
               curr + 1 < max &&

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

@@ -1,5 +1,3 @@
 module MotionMarkdownIt
-
-  VERSION = '8.4.1.2'
-
+  VERSION = '10.0.0'
 end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 # make sure to have `--require spec_helper` in `.rspec` to have the
 # spec_helper.rb included automatically in spec files
-require 'pry-byebug'
 require 'motion-markdown-it/testgen_helper'
 require 'motion-markdown-it'
+
+require 'pry'

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: motion-markdown-it
 version: !ruby/object:Gem::Version
-  version: 8.4.1.2
+  version: 10.0.0
 platform: ruby
 authors:
 - Brett Walker
 - Vitaly Puzrin
 - Alex Kocharin
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-06-08 00:00:00.000000000 Z
+date: 2023-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mdurl-rb
@@ -46,28 +46,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
-  name: bacon-expect
+  name: motion-expect
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
 description: Ruby/RubyMotion version of markdown-it
 email: github@digitalmoksha.com
 executables: []
@@ -141,7 +141,7 @@ homepage: https://github.com/digitalmoksha/motion-markdown-it
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -156,9 +156,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.3.23
+signing_key:
 specification_version: 4
 summary: Ruby version markdown-it
 test_files: