{"version":3,"sources":["jsdelivr-header.js","/npm/markdown-it-attrs@4.3.1/markdown-it-attrs.browser.js"],"names":[],"mappings":"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","file":"/npm/markdown-it-attrs@4.3.1/markdown-it-attrs.browser.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/markdown-it-attrs@4.3.1/markdown-it-attrs.browser.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","(function(f){if(typeof exports===\"object\"&&typeof module!==\"undefined\"){module.exports=f()}else if(typeof define===\"function\"&&define.amd){define([],f)}else{var g;if(typeof window!==\"undefined\"){g=window}else if(typeof global!==\"undefined\"){g=global}else if(typeof self!==\"undefined\"){g=self}else{g=this}g.markdownItAttrs = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){\n'use strict';\n\nfunction _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nvar patternsConfig = require('./patterns.js');\n\n/**\n * @typedef {import('markdown-it')} MarkdownIt\n *\n * @typedef {import('markdown-it/lib/rules_core/state_core.mjs').default} StateCore\n *\n * @typedef {import('markdown-it/lib/token.mjs').default} Token\n *\n * @typedef {import('markdown-it/lib/token.mjs').Nesting} Nesting\n *\n * @typedef {Object} Options\n * @property {!string} leftDelimiter left delimiter, default is `{`(left curly bracket)\n * @property {!string} rightDelimiter right delimiter, default is `}`(right curly bracket)\n * @property {AllowedAttribute[]} allowedAttributes empty means no limit\n *\n * @typedef {string|RegExp} AllowedAttribute rule of allowed attribute\n *\n * @typedef {[string, string]} AttributePair\n *\n * @typedef {[number, number]} SourceLineInfo\n *\n * @typedef {Object} CurlyAttrsPattern\n * @property {string} name\n * @property {DetectingRule[]} tests\n * @property {(tokens: Token[], i: number, j?: number) => void} transform\n *\n * @typedef {Object} MatchedResult\n * @property {boolean} match true means matched\n * @property {number?} j postion index number of Array<{@link Token}>\n *\n * @typedef {(str: string) => boolean} DetectingStrRule\n *\n * @typedef {Object} DetectingRule rule for testing {@link Token}'s properties\n * @property {number=} shift offset index number of Array<{@link Token}>\n * @property {number=} position fixed index number of Array<{@link Token}>\n * @property {(string | DetectingStrRule)=} type\n * @property {(string | DetectingStrRule)=} tag\n * @property {DetectingRule[]=} children\n * @property {(string | DetectingStrRule)=} content\n * @property {(string | DetectingStrRule)=} markup\n * @property {(string | DetectingStrRule)=} info\n * @property {Nesting=} nesting\n * @property {number=} level\n * @property {boolean=} block\n * @property {boolean=} hidden\n * @property {AttributePair[]=} attrs\n * @property {SourceLineInfo[]=} map\n * @property {any=} meta\n */\n\n/** @type {Options} */\nvar defaultOptions = {\n  leftDelimiter: '{',\n  rightDelimiter: '}',\n  allowedAttributes: []\n};\n\n/**\n * @param {MarkdownIt} md\n * @param {Options=} options_\n */\nmodule.exports = function attributes(md, options_) {\n  var options = Object.assign({}, defaultOptions);\n  options = Object.assign(options, options_);\n  var patterns = patternsConfig(options);\n\n  /**\n   * @param {StateCore} state\n   */\n  function curlyAttrs(state) {\n    var tokens = state.tokens;\n    var _loop = function _loop(i) {\n      var _loop2 = function _loop2(_p) {\n        var pattern = patterns[_p];\n        var j = null; // position of child with offset 0\n        var match = pattern.tests.every(function (t) {\n          var res = test(tokens, i, t);\n          if (res.j !== null) {\n            j = res.j;\n          }\n          return res.match;\n        });\n        if (match) {\n          try {\n            pattern.transform(tokens, i, j);\n            if (pattern.name === 'inline attributes' || pattern.name === 'inline nesting 0') {\n              // retry, may be several inline attributes\n              _p--;\n            }\n          } catch (error) {\n            // eslint-disable-next-line no-console\n            console.error(\"markdown-it-attrs: Error in pattern '\".concat(pattern.name, \"': \").concat(error.message));\n            console.error(error.stack);\n          }\n        }\n        p = _p;\n      };\n      for (var p = 0; p < patterns.length; p++) {\n        _loop2(p);\n      }\n    };\n    for (var i = 0; i < tokens.length; i++) {\n      _loop(i);\n    }\n  }\n  md.core.ruler.before('linkify', 'curly_attributes', curlyAttrs);\n};\n\n/**\n * Test if t matches token stream.\n *\n * @param {Token[]} tokens\n * @param {number} i\n * @param {DetectingRule} t\n * @returns {MatchedResult}\n */\nfunction test(tokens, i, t) {\n  /** @type {MatchedResult} */\n  var res = {\n    match: false,\n    j: null // position of child\n  };\n  var ii = t.shift !== undefined ? i + t.shift : t.position;\n  if (t.shift !== undefined && ii < 0) {\n    // we should never shift to negative indexes (rolling around to back of array)\n    return res;\n  }\n  var token = get(tokens, ii); // supports negative ii\n\n  if (token === undefined) {\n    return res;\n  }\n  var _loop3 = function _loop3() {\n      var key = _Object$keys[_i];\n      if (key === 'shift' || key === 'position') {\n        return 0; // continue\n      }\n      if (token[key] === undefined) {\n        return {\n          v: res\n        };\n      }\n      if (key === 'children' && isArrayOfObjects(t.children)) {\n        if (token.children.length === 0) {\n          return {\n            v: res\n          };\n        }\n        var match;\n        /** @type {DetectingRule[]} */\n        var childTests = t.children;\n        /** @type {Token[]} */\n        var children = token.children;\n        if (childTests.every(function (tt) {\n          return tt.position !== undefined;\n        })) {\n          // positions instead of shifts, do not loop all children\n          match = childTests.every(function (tt) {\n            return test(children, tt.position, tt).match;\n          });\n          if (match) {\n            // we may need position of child in transform\n            var j = last(childTests).position;\n            res.j = j >= 0 ? j : children.length + j;\n          }\n        } else {\n          var _loop4 = function _loop4(_j) {\n            match = childTests.every(function (tt) {\n              return test(children, _j, tt).match;\n            });\n            if (match) {\n              res.j = _j;\n              // all tests true, continue with next key of pattern t\n              return 1; // break\n            }\n          };\n          for (var _j = 0; _j < children.length; _j++) {\n            if (_loop4(_j)) break;\n          }\n        }\n        if (match === false) {\n          return {\n            v: res\n          };\n        }\n        return 0; // continue\n      }\n      switch (_typeof(t[key])) {\n        case 'boolean':\n        case 'number':\n        case 'string':\n          if (token[key] !== t[key]) {\n            return {\n              v: res\n            };\n          }\n          break;\n        case 'function':\n          if (!t[key](token[key])) {\n            return {\n              v: res\n            };\n          }\n          break;\n        case 'object':\n          if (isArrayOfFunctions(t[key])) {\n            var r = t[key].every(function (tt) {\n              return tt(token[key]);\n            });\n            if (r === false) {\n              return {\n                v: res\n              };\n            }\n            break;\n          }\n        // fall through for objects !== arrays of functions\n        default:\n          throw new Error(\"Unknown type of pattern test (key: \".concat(key, \"). Test should be of type boolean, number, string, function or array of functions.\"));\n      }\n    },\n    _ret;\n  for (var _i = 0, _Object$keys = Object.keys(t); _i < _Object$keys.length; _i++) {\n    _ret = _loop3();\n    if (_ret === 0) continue;\n    if (_ret) return _ret.v;\n  }\n\n  // no tests returned false -> all tests returns true\n  res.match = true;\n  return res;\n}\nfunction isArrayOfObjects(arr) {\n  return Array.isArray(arr) && arr.length && arr.every(function (i) {\n    return _typeof(i) === 'object';\n  });\n}\nfunction isArrayOfFunctions(arr) {\n  return Array.isArray(arr) && arr.length && arr.every(function (i) {\n    return typeof i === 'function';\n  });\n}\n\n/**\n * Get n item of array. Supports negative n, where -1 is last\n * element in array.\n * @param {Token[]} arr\n * @param {number} n\n * @returns {Token=}\n */\nfunction get(arr, n) {\n  return n >= 0 ? arr[n] : arr[arr.length + n];\n}\n\n/**\n * get last element of array, safe - returns {} if not found\n * @param {DetectingRule[]} arr\n * @returns {DetectingRule}\n */\nfunction last(arr) {\n  return arr.slice(-1)[0] || {};\n}\n\n},{\"./patterns.js\":2}],2:[function(require,module,exports){\n'use strict';\n\n/**\n * If a pattern matches the token stream,\n * then run transform.\n */\nvar utils = require('./utils.js');\n\n/**\n * @param {import('.').Options} options\n * @returns {import('.').CurlyAttrsPattern[]}\n */\nmodule.exports = function (options) {\n  var __hr = new RegExp('^ {0,3}[-*_]{3,} ?' + utils.escapeRegExp(options.leftDelimiter) + '[^' + utils.escapeRegExp(options.rightDelimiter) + ']');\n  return [{\n    /**\n     * ```python {.cls}\n     * for i in range(10):\n     *     print(i)\n     * ```\n     */\n    name: 'fenced code blocks',\n    tests: [{\n      shift: 0,\n      block: true,\n      info: utils.hasDelimiters('end', options)\n    }],\n    transform: function transform(tokens, i) {\n      var token = tokens[i];\n      var start = token.info.lastIndexOf(options.leftDelimiter);\n      var attrs = utils.getAttrs(token.info, start, options);\n      utils.addAttrs(attrs, token);\n      token.info = utils.removeDelimiter(token.info, options);\n    }\n  }, {\n    /**\n     * bla `click()`{.c} ![](img.png){.d}\n     *\n     * differs from 'inline attributes' as it does\n     * not have a closing tag (nesting: -1)\n     */\n    name: 'inline nesting 0',\n    tests: [{\n      shift: 0,\n      type: 'inline',\n      children: [{\n        shift: -1,\n        type: function type(str) {\n          return str === 'image' || str === 'code_inline';\n        }\n      }, {\n        shift: 0,\n        type: 'text',\n        content: utils.hasDelimiters('start', options)\n      }]\n    }],\n    /**\n     * @param {!number} j\n     */\n    transform: function transform(tokens, i, j) {\n      var token = tokens[i].children[j];\n      var endChar = token.content.indexOf(options.rightDelimiter);\n      var attrToken = tokens[i].children[j - 1];\n      var attrs = utils.getAttrs(token.content, 0, options);\n      utils.addAttrs(attrs, attrToken);\n      if (token.content.length === endChar + options.rightDelimiter.length) {\n        tokens[i].children.splice(j, 1);\n      } else {\n        token.content = token.content.slice(endChar + options.rightDelimiter.length);\n      }\n    }\n  }, {\n    /**\n     * | h1 |\n     * | -- |\n     * | c1 |\n     *\n     * {.c}\n     */\n    name: 'tables',\n    tests: [{\n      // let this token be i, such that for-loop continues at\n      // next token after tokens.splice\n      shift: 0,\n      type: 'table_close'\n    }, {\n      shift: 1,\n      type: 'paragraph_open'\n    }, {\n      shift: 2,\n      type: 'inline',\n      content: utils.hasDelimiters('only', options)\n    }],\n    transform: function transform(tokens, i) {\n      var token = tokens[i + 2];\n      var tableOpen = utils.getMatchingOpeningToken(tokens, i);\n      var attrs = utils.getAttrs(token.content, 0, options);\n      // add attributes\n      utils.addAttrs(attrs, tableOpen);\n      // remove <p>{.c}</p>\n      tokens.splice(i + 1, 3);\n    }\n  }, {\n    /**\n     * | A | B |\n     * | -- | -- |\n     * | 1 | 2 |\n     *\n     * | C | D |\n     * | -- | -- |\n     *\n     * only `| A | B |` sets the colsnum metadata\n     */\n    name: 'tables thead metadata',\n    tests: [{\n      shift: 0,\n      type: 'tr_close'\n    }, {\n      shift: 1,\n      type: 'thead_close'\n    }, {\n      shift: 2,\n      type: 'tbody_open'\n    }],\n    transform: function transform(tokens, i) {\n      var tr = utils.getMatchingOpeningToken(tokens, i);\n      var th = tokens[i - 1];\n      var colsnum = 0;\n      var n = i;\n      while (--n) {\n        if (tokens[n] === tr) {\n          tokens[n - 1].meta = Object.assign({}, tokens[n + 2].meta, {\n            colsnum: colsnum\n          });\n          break;\n        }\n        colsnum += (tokens[n].level === th.level && tokens[n].type === th.type) >> 0;\n      }\n      tokens[i + 2].meta = Object.assign({}, tokens[i + 2].meta, {\n        colsnum: colsnum\n      });\n    }\n  }, {\n    /**\n     * | A | B | C | D |\n     * | -- | -- | -- | -- |\n     * | 1 | 11 | 111 | 1111 {rowspan=3} |\n     * | 2 {colspan=2 rowspan=2} | 22 | 222 | 2222 |\n     * | 3 | 33 | 333 | 3333 |\n     */\n    name: 'tables tbody calculate',\n    tests: [{\n      shift: 0,\n      type: 'tbody_close',\n      hidden: false\n    }],\n    /**\n     * @param {number} i index of the tbody ending\n     */\n    transform: function transform(tokens, i) {\n      /** index of the tbody beginning */\n      var idx = i - 2;\n      while (idx > 0 && 'tbody_open' !== tokens[--idx].type);\n      var calc = tokens[idx].meta.colsnum >> 0;\n      if (calc < 2) {\n        return;\n      }\n      var level = tokens[i].level + 2;\n      for (var n = idx; n < i; n++) {\n        if (tokens[n].level > level) {\n          continue;\n        }\n        var token = tokens[n];\n        var rows = token.hidden ? 0 : token.attrGet('rowspan') >> 0;\n        var cols = token.hidden ? 0 : token.attrGet('colspan') >> 0;\n        if (rows > 1) {\n          var colsnum = calc - (cols > 0 ? cols : 1);\n          for (var k = n, num = rows; k < i, num > 1; k++) {\n            if ('tr_open' == tokens[k].type) {\n              tokens[k].meta = Object.assign({}, tokens[k].meta);\n              if (tokens[k].meta && tokens[k].meta.colsnum) {\n                colsnum -= 1;\n              }\n              tokens[k].meta.colsnum = colsnum;\n              num--;\n            }\n          }\n        }\n        if ('tr_open' == token.type && token.meta && token.meta.colsnum) {\n          var max = token.meta.colsnum;\n          for (var _k = n, _num = 0; _k < i; _k++) {\n            if ('td_open' == tokens[_k].type) {\n              _num += 1;\n            } else if ('tr_close' == tokens[_k].type) {\n              break;\n            }\n            _num > max && (tokens[_k].hidden || hidden(tokens[_k]));\n          }\n        }\n        if (cols > 1) {\n          /** @type {number[]} index of one row's children */\n          var one = [];\n          /** last index of the row's children */\n          var end = n + 3;\n          /** number of the row's children */\n          var _num2 = calc;\n          for (var _k2 = n; _k2 > idx; _k2--) {\n            if ('tr_open' == tokens[_k2].type) {\n              _num2 = tokens[_k2].meta && tokens[_k2].meta.colsnum || _num2;\n              break;\n            } else if ('td_open' === tokens[_k2].type) {\n              one.unshift(_k2);\n            }\n          }\n          for (var _k3 = n + 2; _k3 < i; _k3++) {\n            if ('tr_close' == tokens[_k3].type) {\n              end = _k3;\n              break;\n            } else if ('td_open' == tokens[_k3].type) {\n              one.push(_k3);\n            }\n          }\n          var off = one.indexOf(n);\n          var real = _num2 - off;\n          real = real > cols ? cols : real;\n          cols > real && token.attrSet('colspan', real + '');\n          for (var _k4 = one.slice(_num2 + 1 - calc - real)[0]; _k4 < end; _k4++) {\n            tokens[_k4].hidden || hidden(tokens[_k4]);\n          }\n        }\n      }\n    }\n  }, {\n    /**\n     * *emphasis*{.with attrs=1}\n     */\n    name: 'inline attributes',\n    tests: [{\n      shift: 0,\n      type: 'inline',\n      children: [{\n        shift: -1,\n        nesting: -1 // closing inline tag, </em>{.a}\n      }, {\n        shift: 0,\n        type: 'text',\n        content: utils.hasDelimiters('start', options)\n      }]\n    }],\n    /**\n     * @param {!number} j\n     */\n    transform: function transform(tokens, i, j) {\n      var token = tokens[i].children[j];\n      var content = token.content;\n      var attrs = utils.getAttrs(content, 0, options);\n      var openingToken = utils.getMatchingOpeningToken(tokens[i].children, j - 1);\n      utils.addAttrs(attrs, openingToken);\n      token.content = content.slice(content.indexOf(options.rightDelimiter) + options.rightDelimiter.length);\n    }\n  }, {\n    /**\n     * - item\n     * {.a}\n     */\n    name: 'list softbreak',\n    tests: [{\n      shift: -2,\n      type: 'list_item_open'\n    }, {\n      shift: 0,\n      type: 'inline',\n      children: [{\n        position: -2,\n        type: 'softbreak'\n      }, {\n        position: -1,\n        type: 'text',\n        content: utils.hasDelimiters('only', options)\n      }]\n    }],\n    /**\n     * @param {!number} j\n     */\n    transform: function transform(tokens, i, j) {\n      var token = tokens[i].children[j];\n      var content = token.content;\n      var attrs = utils.getAttrs(content, 0, options);\n      var ii = i - 2;\n      while (tokens[ii - 1] && tokens[ii - 1].type !== 'ordered_list_open' && tokens[ii - 1].type !== 'bullet_list_open') {\n        ii--;\n      }\n      utils.addAttrs(attrs, tokens[ii - 1]);\n      tokens[i].children = tokens[i].children.slice(0, -2);\n    }\n  }, {\n    /**\n     * - nested list\n     *   - with double \\n\n     *   {.a} <-- apply to nested ul\n     *\n     * {.b} <-- apply to root <ul>\n     */\n    name: 'list double softbreak',\n    tests: [{\n      // let this token be i = 0 so that we can erase\n      // the <p>{.a}</p> tokens below\n      shift: 0,\n      type: function type(str) {\n        return str === 'bullet_list_close' || str === 'ordered_list_close';\n      }\n    }, {\n      shift: 1,\n      type: 'paragraph_open'\n    }, {\n      shift: 2,\n      type: 'inline',\n      content: utils.hasDelimiters('only', options),\n      children: function children(arr) {\n        return arr.length === 1;\n      }\n    }, {\n      shift: 3,\n      type: 'paragraph_close'\n    }],\n    transform: function transform(tokens, i) {\n      var token = tokens[i + 2];\n      var content = token.content;\n      var attrs = utils.getAttrs(content, 0, options);\n      var openingToken = utils.getMatchingOpeningToken(tokens, i);\n      utils.addAttrs(attrs, openingToken);\n      tokens.splice(i + 1, 3);\n    }\n  }, {\n    /**\n     * - end of {.list-item}\n     */\n    name: 'list item end',\n    tests: [{\n      shift: -2,\n      type: 'list_item_open'\n    }, {\n      shift: 0,\n      type: 'inline',\n      children: [{\n        position: -1,\n        type: 'text',\n        content: utils.hasDelimiters('end', options)\n      }]\n    }],\n    /**\n     * @param {!number} j\n     */\n    transform: function transform(tokens, i, j) {\n      var token = tokens[i].children[j];\n      var content = token.content;\n      var attrs = utils.getAttrs(content, content.lastIndexOf(options.leftDelimiter), options);\n      utils.addAttrs(attrs, tokens[i - 2]);\n      var trimmed = content.slice(0, content.lastIndexOf(options.leftDelimiter));\n      token.content = last(trimmed) !== ' ' ? trimmed : trimmed.slice(0, -1);\n    }\n  }, {\n    /**\n     * something with softbreak\n     * {.cls}\n     */\n    name: '\\n{.a} softbreak then curly in start',\n    tests: [{\n      shift: 0,\n      type: 'inline',\n      children: [{\n        position: -2,\n        type: 'softbreak'\n      }, {\n        position: -1,\n        type: 'text',\n        content: utils.hasDelimiters('only', options)\n      }]\n    }],\n    /**\n     * @param {!number} j\n     */\n    transform: function transform(tokens, i, j) {\n      var token = tokens[i].children[j];\n      var attrs = utils.getAttrs(token.content, 0, options);\n      // find last closing tag\n      var ii = i + 1;\n      while (tokens[ii + 1] && tokens[ii + 1].nesting === -1) {\n        ii++;\n      }\n      var openingToken = utils.getMatchingOpeningToken(tokens, ii);\n      utils.addAttrs(attrs, openingToken);\n      tokens[i].children = tokens[i].children.slice(0, -2);\n    }\n  }, {\n    /**\n     * horizontal rule --- {#id}\n     */\n    name: 'horizontal rule',\n    tests: [{\n      shift: 0,\n      type: 'paragraph_open'\n    }, {\n      shift: 1,\n      type: 'inline',\n      children: function children(arr) {\n        return arr.length === 1;\n      },\n      content: function content(str) {\n        return str.match(__hr) !== null;\n      }\n    }, {\n      shift: 2,\n      type: 'paragraph_close'\n    }],\n    transform: function transform(tokens, i) {\n      var token = tokens[i];\n      token.type = 'hr';\n      token.tag = 'hr';\n      token.nesting = 0;\n      var content = tokens[i + 1].content;\n      var start = content.lastIndexOf(options.leftDelimiter);\n      var attrs = utils.getAttrs(content, start, options);\n      utils.addAttrs(attrs, token);\n      token.markup = content;\n      tokens.splice(i + 1, 2);\n    }\n  }, {\n    /**\n     * end of {.block}\n     */\n    name: 'end of block',\n    tests: [{\n      shift: 0,\n      type: 'inline',\n      children: [{\n        position: -1,\n        content: utils.hasDelimiters('end', options),\n        type: function type(t) {\n          return t !== 'code_inline' && t !== 'math_inline';\n        }\n      }]\n    }],\n    /**\n     * @param {!number} j\n     */\n    transform: function transform(tokens, i, j) {\n      var token = tokens[i].children[j];\n      var content = token.content;\n      var attrs = utils.getAttrs(content, content.lastIndexOf(options.leftDelimiter), options);\n      var ii = i + 1;\n      do if (tokens[ii] && tokens[ii].nesting === -1) {\n        break;\n      } while (ii++ < tokens.length);\n      var openingToken = utils.getMatchingOpeningToken(tokens, ii);\n      utils.addAttrs(attrs, openingToken);\n      var trimmed = content.slice(0, content.lastIndexOf(options.leftDelimiter));\n      token.content = last(trimmed) !== ' ' ? trimmed : trimmed.slice(0, -1);\n    }\n  }];\n};\n\n// get last element of array or string\nfunction last(arr) {\n  return arr.slice(-1)[0];\n}\n\n/**\n * Hidden table's cells and them inline children,\n * specially cast inline's content as empty\n * to prevent that escapes the table's box model\n * @see https://github.com/markdown-it/markdown-it/issues/639\n * @param {import('.').Token} token\n */\nfunction hidden(token) {\n  token.hidden = true;\n  token.children && token.children.forEach(function (t) {\n    return t.content = '', hidden(t), undefined;\n  });\n}\n\n},{\"./utils.js\":3}],3:[function(require,module,exports){\n\"use strict\";\n\n/**\n * @typedef {import('.').Token} Token\n * @typedef {import('.').Options} Options\n * @typedef {import('.').AttributePair} AttributePair\n * @typedef {import('.').AllowedAttribute} AllowedAttribute\n * @typedef {import('.').DetectingStrRule} DetectingStrRule\n */\n/**\n * parse {.class #id key=val} strings\n * @param {string} str: string to parse\n * @param {number} start: where to start parsing (including {)\n * @param {Options} options\n * @returns {AttributePair[]}: [['key', 'val'], ['class', 'red']]\n */\nexports.getAttrs = function (str, start, options) {\n  // not tab, line feed, form feed, space, solidus, greater than sign, quotation mark, apostrophe and equals sign\n  var allowedKeyChars = /[^\\t\\n\\f />\"'=]/;\n  var pairSeparator = ' ';\n  var keySeparator = '=';\n  var classChar = '.';\n  var idChar = '#';\n  var attrs = [];\n  var key = '';\n  var value = '';\n  var parsingKey = true;\n  var valueInsideQuotes = false;\n\n  // read inside {}\n  // start + left delimiter length to avoid beginning {\n  // breaks when } is found or end of string\n  for (var i = start + options.leftDelimiter.length; i < str.length; i++) {\n    if (str.slice(i, i + options.rightDelimiter.length) === options.rightDelimiter) {\n      if (key !== '') {\n        attrs.push([key, value]);\n      }\n      break;\n    }\n    var char_ = str.charAt(i);\n\n    // switch to reading value if equal sign\n    if (char_ === keySeparator && parsingKey) {\n      parsingKey = false;\n      continue;\n    }\n\n    // {.class} {..css-module}\n    if (char_ === classChar && key === '') {\n      if (str.charAt(i + 1) === classChar) {\n        key = 'css-module';\n        i += 1;\n      } else {\n        key = 'class';\n      }\n      parsingKey = false;\n      continue;\n    }\n\n    // {#id}\n    if (char_ === idChar && key === '') {\n      key = 'id';\n      parsingKey = false;\n      continue;\n    }\n\n    // {value=\"inside quotes\"}\n    if (char_ === '\"' && value === '' && !valueInsideQuotes) {\n      valueInsideQuotes = true;\n      continue;\n    }\n    if (char_ === '\"' && valueInsideQuotes) {\n      valueInsideQuotes = false;\n      continue;\n    }\n\n    // read next key/value pair\n    if (char_ === pairSeparator && !valueInsideQuotes) {\n      if (key === '') {\n        // beginning or ending space: { .red } vs {.red}\n        continue;\n      }\n      attrs.push([key, value]);\n      key = '';\n      value = '';\n      parsingKey = true;\n      continue;\n    }\n\n    // continue if character not allowed\n    if (parsingKey && char_.search(allowedKeyChars) === -1) {\n      continue;\n    }\n\n    // no other conditions met; append to key/value\n    if (parsingKey) {\n      key += char_;\n      continue;\n    }\n    value += char_;\n  }\n  if (options.allowedAttributes && options.allowedAttributes.length) {\n    var allowedAttributes = options.allowedAttributes;\n    return attrs.filter(function (attrPair) {\n      var attr = attrPair[0];\n\n      /**\n       * @param {AllowedAttribute} allowedAttribute\n       */\n      function isAllowedAttribute(allowedAttribute) {\n        return attr === allowedAttribute || allowedAttribute instanceof RegExp && allowedAttribute.test(attr);\n      }\n      return allowedAttributes.some(isAllowedAttribute);\n    });\n  }\n  return attrs;\n};\n\n/**\n * add attributes from [['key', 'val']] list\n * @param {AttributePair[]} attrs: [['key', 'val']]\n * @param {Token} token: which token to add attributes\n * @returns token\n */\nexports.addAttrs = function (attrs, token) {\n  for (var j = 0, l = attrs.length; j < l; ++j) {\n    var key = attrs[j][0];\n    if (key === 'class') {\n      token.attrJoin('class', attrs[j][1]);\n    } else if (key === 'css-module') {\n      token.attrJoin('css-module', attrs[j][1]);\n    } else {\n      token.attrPush(attrs[j]);\n    }\n  }\n  return token;\n};\n\n/**\n * Does string have properly formatted curly?\n *\n * start: '{.a} asdf'\n * end: 'asdf {.a}'\n * only: '{.a}'\n *\n * @param {'start'|'end'|'only'} where to expect {} curly. start, end or only.\n * @param {Options} options\n * @return {DetectingStrRule} Function which testes if string has curly.\n */\nexports.hasDelimiters = function (where, options) {\n  if (!where) {\n    throw new Error('Parameter `where` not passed. Should be \"start\", \"end\" or \"only\".');\n  }\n\n  /**\n   * @param {string} str\n   * @return {boolean}\n   */\n  return function (str) {\n    // we need minimum three chars, for example {b}\n    var minCurlyLength = options.leftDelimiter.length + 1 + options.rightDelimiter.length;\n    if (!str || typeof str !== 'string' || str.length < minCurlyLength) {\n      return false;\n    }\n\n    /**\n     * @param {string} curly\n     */\n    function validCurlyLength(curly) {\n      var isClass = curly.charAt(options.leftDelimiter.length) === '.';\n      var isId = curly.charAt(options.leftDelimiter.length) === '#';\n      return isClass || isId ? curly.length >= minCurlyLength + 1 : curly.length >= minCurlyLength;\n    }\n    var start, end, slice, nextChar;\n    var rightDelimiterMinimumShift = minCurlyLength - options.rightDelimiter.length;\n    switch (where) {\n      case 'start':\n        // first char should be {, } found in char 2 or more\n        slice = str.slice(0, options.leftDelimiter.length);\n        start = slice === options.leftDelimiter ? 0 : -1;\n        end = start === -1 ? -1 : str.indexOf(options.rightDelimiter, rightDelimiterMinimumShift);\n        // check if next character is not one of the delimiters\n        nextChar = str.charAt(end + options.rightDelimiter.length);\n        if (nextChar && options.rightDelimiter.indexOf(nextChar) !== -1) {\n          end = -1;\n        }\n        break;\n      case 'end':\n        // last char should be }\n        start = str.lastIndexOf(options.leftDelimiter);\n        end = start === -1 ? -1 : str.indexOf(options.rightDelimiter, start + rightDelimiterMinimumShift);\n        end = end === str.length - options.rightDelimiter.length ? end : -1;\n        break;\n      case 'only':\n        // '{.a}'\n        slice = str.slice(0, options.leftDelimiter.length);\n        start = slice === options.leftDelimiter ? 0 : -1;\n        slice = str.slice(str.length - options.rightDelimiter.length);\n        end = slice === options.rightDelimiter ? str.length - options.rightDelimiter.length : -1;\n        break;\n      default:\n        throw new Error(\"Unexpected case \".concat(where, \", expected 'start', 'end' or 'only'\"));\n    }\n    return start !== -1 && end !== -1 && validCurlyLength(str.substring(start, end + options.rightDelimiter.length));\n  };\n};\n\n/**\n * Removes last curly from string.\n * @param {string} str\n * @param {Options} options\n */\nexports.removeDelimiter = function (str, options) {\n  var start = escapeRegExp(options.leftDelimiter);\n  var end = escapeRegExp(options.rightDelimiter);\n  var curly = new RegExp('[ \\\\n]?' + start + '[^' + start + end + ']+' + end + '$');\n  var pos = str.search(curly);\n  return pos !== -1 ? str.slice(0, pos) : str;\n};\n\n/**\n * Escapes special characters in string s such that the string\n * can be used in `new RegExp`. For example \"[\" becomes \"\\\\[\".\n *\n * @param {string} s Regex string.\n * @return {string} Escaped string.\n */\nfunction escapeRegExp(s) {\n  return s.replace(/[-/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&');\n}\nexports.escapeRegExp = escapeRegExp;\n\n/**\n * find corresponding opening block\n * @param {Token[]} tokens\n * @param {number} i\n */\nexports.getMatchingOpeningToken = function (tokens, i) {\n  if (tokens[i].type === 'softbreak') {\n    return false;\n  }\n  // non closing blocks, example img\n  if (tokens[i].nesting === 0) {\n    return tokens[i];\n  }\n  var level = tokens[i].level;\n  var type = tokens[i].type.replace('_close', '_open');\n  for (; i >= 0; --i) {\n    if (tokens[i].type === type && tokens[i].level === level) {\n      return tokens[i];\n    }\n  }\n  return false;\n};\n\n/**\n * from https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.js\n */\nvar HTML_ESCAPE_TEST_RE = /[&<>\"]/;\nvar HTML_ESCAPE_REPLACE_RE = /[&<>\"]/g;\nvar HTML_REPLACEMENTS = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;'\n};\n\n/**\n * @param {string} ch\n * @returns {string}\n */\nfunction replaceUnsafeChar(ch) {\n  return HTML_REPLACEMENTS[ch];\n}\n\n/**\n * @param {string} str\n * @returns {string}\n */\nexports.escapeHtml = function (str) {\n  if (HTML_ESCAPE_TEST_RE.test(str)) {\n    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);\n  }\n  return str;\n};\n\n},{}]},{},[1])(1)\n});\n"]}