{"version":3,"file":"064c7cc9d6b209d3d796a40bda8151ccd6d475ca-c98e1beda1fdffe070fd.js","mappings":"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","sources":["webpack://pannal-village-hall-website/./node_modules/bail/index.js","webpack://pannal-village-hall-website/./node_modules/collapse-white-space/index.js","webpack://pannal-village-hall-website/./node_modules/extend/index.js","webpack://pannal-village-hall-website/./node_modules/inherits/inherits_browser.js","webpack://pannal-village-hall-website/./node_modules/is-whitespace-character/index.js","webpack://pannal-village-hall-website/./node_modules/is-word-character/index.js","webpack://pannal-village-hall-website/./node_modules/markdown-escapes/index.js","webpack://pannal-village-hall-website/./node_modules/mdast-add-list-metadata/index.js","webpack://pannal-village-hall-website/./node_modules/path-browserify/index.js","webpack://pannal-village-hall-website/./node_modules/process/browser.js","webpack://pannal-village-hall-website/./node_modules/react-is/cjs/react-is.production.min.js","webpack://pannal-village-hall-website/./node_modules/react-is/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/lib/ast-to-react.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/lib/get-definitions.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/lib/plugins/disallow-node.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/lib/plugins/naive-html.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/lib/react-markdown.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/lib/renderers.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/lib/symbols.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/lib/uri-transformer.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/lib/wrap-table-rows.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/is-alphabetical/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/is-alphanumerical/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/is-buffer/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/is-decimal/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/is-hexadecimal/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/is-plain-obj/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/parse-entities/decode-entity.browser.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/parse-entities/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/decode.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/defaults.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/locate/break.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/locate/code-inline.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/locate/delete.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/locate/emphasis.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/locate/escape.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/locate/link.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/locate/strong.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/locate/tag.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/locate/url.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/parse.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/parser.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/set-options.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/auto-link.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/blockquote.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/break.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/code-fenced.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/code-indented.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/code-inline.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/definition.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/delete.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/emphasis.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/escape.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/footnote-definition.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/heading-atx.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/heading-setext.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/html-block.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/html-inline.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/link.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/list.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/newline.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/paragraph.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/reference.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/strong.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/table.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/text.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/thematic-break.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenize/url.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/tokenizer.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/unescape.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/util/get-indentation.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/util/html.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/util/interrupt.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/util/normalize.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/remark-parse/lib/util/remove-indentation.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/unified/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/unist-util-is/convert.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/unist-util-remove-position/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/unist-util-stringify-position/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/unist-util-visit-parents/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/unist-util-visit/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/vfile-message/index.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/vfile/core.js","webpack://pannal-village-hall-website/./node_modules/react-markdown/node_modules/vfile/index.js","webpack://pannal-village-hall-website/./node_modules/repeat-string/index.js","webpack://pannal-village-hall-website/./node_modules/replace-ext/index.js","webpack://pannal-village-hall-website/./node_modules/state-toggle/index.js","webpack://pannal-village-hall-website/./node_modules/trim-trailing-lines/index.js","webpack://pannal-village-hall-website/./node_modules/trim/index.js","webpack://pannal-village-hall-website/./node_modules/trough/index.js","webpack://pannal-village-hall-website/./node_modules/trough/wrap.js","webpack://pannal-village-hall-website/./node_modules/unherit/index.js","webpack://pannal-village-hall-website/./node_modules/unist-util-visit-parents/index.js","webpack://pannal-village-hall-website/./node_modules/vfile-location/index.js","webpack://pannal-village-hall-website/./node_modules/x-is-string/index.js","webpack://pannal-village-hall-website/./node_modules/xtend/immutable.js"],"sourcesContent":["'use strict';\n\nmodule.exports = bail;\nfunction bail(err) {\n  if (err) {\n    throw err;\n  }\n}","'use strict';\n\nmodule.exports = collapse;\n\n// `collapse(' \\t\\nbar \\nbaz\\t') // ' bar baz '`\nfunction collapse(value) {\n  return String(value).replace(/\\s+/g, ' ');\n}","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\nvar isArray = function isArray(arr) {\n  if (typeof Array.isArray === 'function') {\n    return Array.isArray(arr);\n  }\n  return toStr.call(arr) === '[object Array]';\n};\nvar isPlainObject = function isPlainObject(obj) {\n  if (!obj || toStr.call(obj) !== '[object Object]') {\n    return false;\n  }\n  var hasOwnConstructor = hasOwn.call(obj, 'constructor');\n  var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n  // Not own constructor property must be Object\n  if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n    return false;\n  }\n\n  // Own properties are enumerated firstly, so to speed up,\n  // if last one is own, then all properties are own.\n  var key;\n  for (key in obj) {/**/}\n  return typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n  if (defineProperty && options.name === '__proto__') {\n    defineProperty(target, options.name, {\n      enumerable: true,\n      configurable: true,\n      value: options.newValue,\n      writable: true\n    });\n  } else {\n    target[options.name] = options.newValue;\n  }\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n  if (name === '__proto__') {\n    if (!hasOwn.call(obj, name)) {\n      return void 0;\n    } else if (gOPD) {\n      // In early versions of node, obj['__proto__'] is buggy when obj has\n      // __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n      return gOPD(obj, name).value;\n    }\n  }\n  return obj[name];\n};\nmodule.exports = function extend() {\n  var options, name, src, copy, copyIsArray, clone;\n  var target = arguments[0];\n  var i = 1;\n  var length = arguments.length;\n  var deep = false;\n\n  // Handle a deep copy situation\n  if (typeof target === 'boolean') {\n    deep = target;\n    target = arguments[1] || {};\n    // skip the boolean and the target\n    i = 2;\n  }\n  if (target == null || typeof target !== 'object' && typeof target !== 'function') {\n    target = {};\n  }\n  for (; i < length; ++i) {\n    options = arguments[i];\n    // Only deal with non-null/undefined values\n    if (options != null) {\n      // Extend the base object\n      for (name in options) {\n        src = getProperty(target, name);\n        copy = getProperty(options, name);\n\n        // Prevent never-ending loop\n        if (target !== copy) {\n          // Recurse if we're merging plain objects or arrays\n          if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n            if (copyIsArray) {\n              copyIsArray = false;\n              clone = src && isArray(src) ? src : [];\n            } else {\n              clone = src && isPlainObject(src) ? src : {};\n            }\n\n            // Never move original objects, clone them\n            setProperty(target, {\n              name: name,\n              newValue: extend(deep, clone, copy)\n            });\n\n            // Don't bring in undefined values\n          } else if (typeof copy !== 'undefined') {\n            setProperty(target, {\n              name: name,\n              newValue: copy\n            });\n          }\n        }\n      }\n    }\n  }\n\n  // Return the modified object\n  return target;\n};","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor;\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      });\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor;\n      var TempCtor = function () {};\n      TempCtor.prototype = superCtor.prototype;\n      ctor.prototype = new TempCtor();\n      ctor.prototype.constructor = ctor;\n    }\n  };\n}","'use strict';\n\nmodule.exports = whitespace;\nvar fromCode = String.fromCharCode;\nvar re = /\\s/;\n\n// Check if the given character code, or the character code at the first\n// character, is a whitespace character.\nfunction whitespace(character) {\n  return re.test(typeof character === 'number' ? fromCode(character) : character.charAt(0));\n}","'use strict';\n\nmodule.exports = wordCharacter;\nvar fromCode = String.fromCharCode;\nvar re = /\\w/;\n\n// Check if the given character code, or the character code at the first\n// character, is a word character.\nfunction wordCharacter(character) {\n  return re.test(typeof character === 'number' ? fromCode(character) : character.charAt(0));\n}","'use strict';\n\nmodule.exports = escapes;\nvar defaults = ['\\\\', '`', '*', '{', '}', '[', ']', '(', ')', '#', '+', '-', '.', '!', '_', '>'];\nvar gfm = defaults.concat(['~', '|']);\nvar commonmark = gfm.concat(['\\n', '\"', '$', '%', '&', \"'\", ',', '/', ':', ';', '<', '=', '?', '@', '^']);\nescapes.default = defaults;\nescapes.gfm = gfm;\nescapes.commonmark = commonmark;\n\n// Get markdown escapes.\nfunction escapes(options) {\n  var settings = options || {};\n  if (settings.commonmark) {\n    return commonmark;\n  }\n  return settings.gfm ? gfm : defaults;\n}","var visitWithParents = require('unist-util-visit-parents');\nfunction addListMetadata() {\n  return function (ast) {\n    visitWithParents(ast, 'list', function (listNode, parents) {\n      var depth = 0,\n        i,\n        n;\n      for (i = 0, n = parents.length; i < n; i++) {\n        if (parents[i].type === 'list') depth += 1;\n      }\n      for (i = 0, n = listNode.children.length; i < n; i++) {\n        var child = listNode.children[i];\n        child.index = i;\n        child.ordered = listNode.ordered;\n      }\n      listNode.depth = depth;\n    });\n    return ast;\n  };\n}\nmodule.exports = addListMetadata;","// 'path' module extracted from Node.js v8.11.1 (only the posix part)\n// transplited with Babel\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\n  }\n}\n\n// Resolves . and .. elements in a path with directory names\nfunction normalizeStringPosix(path, allowAboveRoot) {\n  var res = '';\n  var lastSegmentLength = 0;\n  var lastSlash = -1;\n  var dots = 0;\n  var code;\n  for (var i = 0; i <= path.length; ++i) {\n    if (i < path.length) code = path.charCodeAt(i);else if (code === 47 /*/*/) break;else code = 47 /*/*/;\n    if (code === 47 /*/*/) {\n      if (lastSlash === i - 1 || dots === 1) {\n        // NOOP\n      } else if (lastSlash !== i - 1 && dots === 2) {\n        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {\n          if (res.length > 2) {\n            var lastSlashIndex = res.lastIndexOf('/');\n            if (lastSlashIndex !== res.length - 1) {\n              if (lastSlashIndex === -1) {\n                res = '';\n                lastSegmentLength = 0;\n              } else {\n                res = res.slice(0, lastSlashIndex);\n                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');\n              }\n              lastSlash = i;\n              dots = 0;\n              continue;\n            }\n          } else if (res.length === 2 || res.length === 1) {\n            res = '';\n            lastSegmentLength = 0;\n            lastSlash = i;\n            dots = 0;\n            continue;\n          }\n        }\n        if (allowAboveRoot) {\n          if (res.length > 0) res += '/..';else res = '..';\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (res.length > 0) res += '/' + path.slice(lastSlash + 1, i);else res = path.slice(lastSlash + 1, i);\n        lastSegmentLength = i - lastSlash - 1;\n      }\n      lastSlash = i;\n      dots = 0;\n    } else if (code === 46 /*.*/ && dots !== -1) {\n      ++dots;\n    } else {\n      dots = -1;\n    }\n  }\n  return res;\n}\nfunction _format(sep, pathObject) {\n  var dir = pathObject.dir || pathObject.root;\n  var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');\n  if (!dir) {\n    return base;\n  }\n  if (dir === pathObject.root) {\n    return dir + base;\n  }\n  return dir + sep + base;\n}\nvar posix = {\n  // path.resolve([from ...], to)\n  resolve: function resolve() {\n    var resolvedPath = '';\n    var resolvedAbsolute = false;\n    var cwd;\n    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n      var path;\n      if (i >= 0) path = arguments[i];else {\n        if (cwd === undefined) cwd = process.cwd();\n        path = cwd;\n      }\n      assertPath(path);\n\n      // Skip empty entries\n      if (path.length === 0) {\n        continue;\n      }\n      resolvedPath = path + '/' + resolvedPath;\n      resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    }\n\n    // At this point the path should be resolved to a full absolute path, but\n    // handle relative paths to be safe (might happen when process.cwd() fails)\n\n    // Normalize the path\n    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);\n    if (resolvedAbsolute) {\n      if (resolvedPath.length > 0) return '/' + resolvedPath;else return '/';\n    } else if (resolvedPath.length > 0) {\n      return resolvedPath;\n    } else {\n      return '.';\n    }\n  },\n  normalize: function normalize(path) {\n    assertPath(path);\n    if (path.length === 0) return '.';\n    var isAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;\n\n    // Normalize the path\n    path = normalizeStringPosix(path, !isAbsolute);\n    if (path.length === 0 && !isAbsolute) path = '.';\n    if (path.length > 0 && trailingSeparator) path += '/';\n    if (isAbsolute) return '/' + path;\n    return path;\n  },\n  isAbsolute: function isAbsolute(path) {\n    assertPath(path);\n    return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;\n  },\n  join: function join() {\n    if (arguments.length === 0) return '.';\n    var joined;\n    for (var i = 0; i < arguments.length; ++i) {\n      var arg = arguments[i];\n      assertPath(arg);\n      if (arg.length > 0) {\n        if (joined === undefined) joined = arg;else joined += '/' + arg;\n      }\n    }\n    if (joined === undefined) return '.';\n    return posix.normalize(joined);\n  },\n  relative: function relative(from, to) {\n    assertPath(from);\n    assertPath(to);\n    if (from === to) return '';\n    from = posix.resolve(from);\n    to = posix.resolve(to);\n    if (from === to) return '';\n\n    // Trim any leading backslashes\n    var fromStart = 1;\n    for (; fromStart < from.length; ++fromStart) {\n      if (from.charCodeAt(fromStart) !== 47 /*/*/) break;\n    }\n    var fromEnd = from.length;\n    var fromLen = fromEnd - fromStart;\n\n    // Trim any leading backslashes\n    var toStart = 1;\n    for (; toStart < to.length; ++toStart) {\n      if (to.charCodeAt(toStart) !== 47 /*/*/) break;\n    }\n    var toEnd = to.length;\n    var toLen = toEnd - toStart;\n\n    // Compare paths to find the longest common path from root\n    var length = fromLen < toLen ? fromLen : toLen;\n    var lastCommonSep = -1;\n    var i = 0;\n    for (; i <= length; ++i) {\n      if (i === length) {\n        if (toLen > length) {\n          if (to.charCodeAt(toStart + i) === 47 /*/*/) {\n            // We get here if `from` is the exact base path for `to`.\n            // For example: from='/foo/bar'; to='/foo/bar/baz'\n            return to.slice(toStart + i + 1);\n          } else if (i === 0) {\n            // We get here if `from` is the root\n            // For example: from='/'; to='/foo'\n            return to.slice(toStart + i);\n          }\n        } else if (fromLen > length) {\n          if (from.charCodeAt(fromStart + i) === 47 /*/*/) {\n            // We get here if `to` is the exact base path for `from`.\n            // For example: from='/foo/bar/baz'; to='/foo/bar'\n            lastCommonSep = i;\n          } else if (i === 0) {\n            // We get here if `to` is the root.\n            // For example: from='/foo'; to='/'\n            lastCommonSep = 0;\n          }\n        }\n        break;\n      }\n      var fromCode = from.charCodeAt(fromStart + i);\n      var toCode = to.charCodeAt(toStart + i);\n      if (fromCode !== toCode) break;else if (fromCode === 47 /*/*/) lastCommonSep = i;\n    }\n    var out = '';\n    // Generate the relative path based on the path difference between `to`\n    // and `from`\n    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n      if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {\n        if (out.length === 0) out += '..';else out += '/..';\n      }\n    }\n\n    // Lastly, append the rest of the destination (`to`) path that comes after\n    // the common path parts\n    if (out.length > 0) return out + to.slice(toStart + lastCommonSep);else {\n      toStart += lastCommonSep;\n      if (to.charCodeAt(toStart) === 47 /*/*/) ++toStart;\n      return to.slice(toStart);\n    }\n  },\n  _makeLong: function _makeLong(path) {\n    return path;\n  },\n  dirname: function dirname(path) {\n    assertPath(path);\n    if (path.length === 0) return '.';\n    var code = path.charCodeAt(0);\n    var hasRoot = code === 47 /*/*/;\n    var end = -1;\n    var matchedSlash = true;\n    for (var i = path.length - 1; i >= 1; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n        if (!matchedSlash) {\n          end = i;\n          break;\n        }\n      } else {\n        // We saw the first non-path separator\n        matchedSlash = false;\n      }\n    }\n    if (end === -1) return hasRoot ? '/' : '.';\n    if (hasRoot && end === 1) return '//';\n    return path.slice(0, end);\n  },\n  basename: function basename(path, ext) {\n    if (ext !== undefined && typeof ext !== 'string') throw new TypeError('\"ext\" argument must be a string');\n    assertPath(path);\n    var start = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i;\n    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n      if (ext.length === path.length && ext === path) return '';\n      var extIdx = ext.length - 1;\n      var firstNonSlashEnd = -1;\n      for (i = path.length - 1; i >= 0; --i) {\n        var code = path.charCodeAt(i);\n        if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            start = i + 1;\n            break;\n          }\n        } else {\n          if (firstNonSlashEnd === -1) {\n            // We saw the first non-path separator, remember this index in case\n            // we need it if the extension ends up not matching\n            matchedSlash = false;\n            firstNonSlashEnd = i + 1;\n          }\n          if (extIdx >= 0) {\n            // Try to match the explicit extension\n            if (code === ext.charCodeAt(extIdx)) {\n              if (--extIdx === -1) {\n                // We matched the extension, so mark this as the end of our path\n                // component\n                end = i;\n              }\n            } else {\n              // Extension does not match, so our result is the entire path\n              // component\n              extIdx = -1;\n              end = firstNonSlashEnd;\n            }\n          }\n        }\n      }\n      if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;\n      return path.slice(start, end);\n    } else {\n      for (i = path.length - 1; i >= 0; --i) {\n        if (path.charCodeAt(i) === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            start = i + 1;\n            break;\n          }\n        } else if (end === -1) {\n          // We saw the first non-path separator, mark this as the end of our\n          // path component\n          matchedSlash = false;\n          end = i + 1;\n        }\n      }\n      if (end === -1) return '';\n      return path.slice(start, end);\n    }\n  },\n  extname: function extname(path) {\n    assertPath(path);\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n    for (var i = path.length - 1; i >= 0; --i) {\n      var code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          startPart = i + 1;\n          break;\n        }\n        continue;\n      }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n        // If this is our first dot, mark it as the start of our extension\n        if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;\n      } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n    if (startDot === -1 || end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      return '';\n    }\n    return path.slice(startDot, end);\n  },\n  format: function format(pathObject) {\n    if (pathObject === null || typeof pathObject !== 'object') {\n      throw new TypeError('The \"pathObject\" argument must be of type Object. Received type ' + typeof pathObject);\n    }\n    return _format('/', pathObject);\n  },\n  parse: function parse(path) {\n    assertPath(path);\n    var ret = {\n      root: '',\n      dir: '',\n      base: '',\n      ext: '',\n      name: ''\n    };\n    if (path.length === 0) return ret;\n    var code = path.charCodeAt(0);\n    var isAbsolute = code === 47 /*/*/;\n    var start;\n    if (isAbsolute) {\n      ret.root = '/';\n      start = 1;\n    } else {\n      start = 0;\n    }\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i = path.length - 1;\n\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n\n    // Get non-dir info\n    for (; i >= start; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          startPart = i + 1;\n          break;\n        }\n        continue;\n      }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n        // If this is our first dot, mark it as the start of our extension\n        if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;\n      } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n    if (startDot === -1 || end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      if (end !== -1) {\n        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);\n      }\n    } else {\n      if (startPart === 0 && isAbsolute) {\n        ret.name = path.slice(1, startDot);\n        ret.base = path.slice(1, end);\n      } else {\n        ret.name = path.slice(startPart, startDot);\n        ret.base = path.slice(startPart, end);\n      }\n      ret.ext = path.slice(startDot, end);\n    }\n    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';\n    return ret;\n  },\n  sep: '/',\n  delimiter: ':',\n  win32: null,\n  posix: null\n};\nposix.posix = posix;\nmodule.exports = posix;","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\nfunction defaultSetTimout() {\n  throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout() {\n  throw new Error('clearTimeout has not been defined');\n}\n(function () {\n  try {\n    if (typeof setTimeout === 'function') {\n      cachedSetTimeout = setTimeout;\n    } else {\n      cachedSetTimeout = defaultSetTimout;\n    }\n  } catch (e) {\n    cachedSetTimeout = defaultSetTimout;\n  }\n  try {\n    if (typeof clearTimeout === 'function') {\n      cachedClearTimeout = clearTimeout;\n    } else {\n      cachedClearTimeout = defaultClearTimeout;\n    }\n  } catch (e) {\n    cachedClearTimeout = defaultClearTimeout;\n  }\n})();\nfunction runTimeout(fun) {\n  if (cachedSetTimeout === setTimeout) {\n    //normal enviroments in sane situations\n    return setTimeout(fun, 0);\n  }\n  // if setTimeout wasn't available but was latter defined\n  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n    cachedSetTimeout = setTimeout;\n    return setTimeout(fun, 0);\n  }\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedSetTimeout(fun, 0);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n      return cachedSetTimeout.call(null, fun, 0);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n      return cachedSetTimeout.call(this, fun, 0);\n    }\n  }\n}\nfunction runClearTimeout(marker) {\n  if (cachedClearTimeout === clearTimeout) {\n    //normal enviroments in sane situations\n    return clearTimeout(marker);\n  }\n  // if clearTimeout wasn't available but was latter defined\n  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n    cachedClearTimeout = clearTimeout;\n    return clearTimeout(marker);\n  }\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedClearTimeout(marker);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n      return cachedClearTimeout.call(null, marker);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n      // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n      return cachedClearTimeout.call(this, marker);\n    }\n  }\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\nfunction cleanUpNextTick() {\n  if (!draining || !currentQueue) {\n    return;\n  }\n  draining = false;\n  if (currentQueue.length) {\n    queue = currentQueue.concat(queue);\n  } else {\n    queueIndex = -1;\n  }\n  if (queue.length) {\n    drainQueue();\n  }\n}\nfunction drainQueue() {\n  if (draining) {\n    return;\n  }\n  var timeout = runTimeout(cleanUpNextTick);\n  draining = true;\n  var len = queue.length;\n  while (len) {\n    currentQueue = queue;\n    queue = [];\n    while (++queueIndex < len) {\n      if (currentQueue) {\n        currentQueue[queueIndex].run();\n      }\n    }\n    queueIndex = -1;\n    len = queue.length;\n  }\n  currentQueue = null;\n  draining = false;\n  runClearTimeout(timeout);\n}\nprocess.nextTick = function (fun) {\n  var args = new Array(arguments.length - 1);\n  if (arguments.length > 1) {\n    for (var i = 1; i < arguments.length; i++) {\n      args[i - 1] = arguments[i];\n    }\n  }\n  queue.push(new Item(fun, args));\n  if (queue.length === 1 && !draining) {\n    runTimeout(drainQueue);\n  }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n  this.fun = fun;\n  this.array = array;\n}\nItem.prototype.run = function () {\n  this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\nfunction noop() {}\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\nprocess.listeners = function (name) {\n  return [];\n};\nprocess.binding = function (name) {\n  throw new Error('process.binding is not supported');\n};\nprocess.cwd = function () {\n  return '/';\n};\nprocess.chdir = function (dir) {\n  throw new Error('process.chdir is not supported');\n};\nprocess.umask = function () {\n  return 0;\n};","/** @license React v16.13.1\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar b = \"function\" === typeof Symbol && Symbol.for,\n  c = b ? Symbol.for(\"react.element\") : 60103,\n  d = b ? Symbol.for(\"react.portal\") : 60106,\n  e = b ? Symbol.for(\"react.fragment\") : 60107,\n  f = b ? Symbol.for(\"react.strict_mode\") : 60108,\n  g = b ? Symbol.for(\"react.profiler\") : 60114,\n  h = b ? Symbol.for(\"react.provider\") : 60109,\n  k = b ? Symbol.for(\"react.context\") : 60110,\n  l = b ? Symbol.for(\"react.async_mode\") : 60111,\n  m = b ? Symbol.for(\"react.concurrent_mode\") : 60111,\n  n = b ? Symbol.for(\"react.forward_ref\") : 60112,\n  p = b ? Symbol.for(\"react.suspense\") : 60113,\n  q = b ? Symbol.for(\"react.suspense_list\") : 60120,\n  r = b ? Symbol.for(\"react.memo\") : 60115,\n  t = b ? Symbol.for(\"react.lazy\") : 60116,\n  v = b ? Symbol.for(\"react.block\") : 60121,\n  w = b ? Symbol.for(\"react.fundamental\") : 60117,\n  x = b ? Symbol.for(\"react.responder\") : 60118,\n  y = b ? Symbol.for(\"react.scope\") : 60119;\nfunction z(a) {\n  if (\"object\" === typeof a && null !== a) {\n    var u = a.$$typeof;\n    switch (u) {\n      case c:\n        switch (a = a.type, a) {\n          case l:\n          case m:\n          case e:\n          case g:\n          case f:\n          case p:\n            return a;\n          default:\n            switch (a = a && a.$$typeof, a) {\n              case k:\n              case n:\n              case t:\n              case r:\n              case h:\n                return a;\n              default:\n                return u;\n            }\n        }\n      case d:\n        return u;\n    }\n  }\n}\nfunction A(a) {\n  return z(a) === m;\n}\nexports.AsyncMode = l;\nexports.ConcurrentMode = m;\nexports.ContextConsumer = k;\nexports.ContextProvider = h;\nexports.Element = c;\nexports.ForwardRef = n;\nexports.Fragment = e;\nexports.Lazy = t;\nexports.Memo = r;\nexports.Portal = d;\nexports.Profiler = g;\nexports.StrictMode = f;\nexports.Suspense = p;\nexports.isAsyncMode = function (a) {\n  return A(a) || z(a) === l;\n};\nexports.isConcurrentMode = A;\nexports.isContextConsumer = function (a) {\n  return z(a) === k;\n};\nexports.isContextProvider = function (a) {\n  return z(a) === h;\n};\nexports.isElement = function (a) {\n  return \"object\" === typeof a && null !== a && a.$$typeof === c;\n};\nexports.isForwardRef = function (a) {\n  return z(a) === n;\n};\nexports.isFragment = function (a) {\n  return z(a) === e;\n};\nexports.isLazy = function (a) {\n  return z(a) === t;\n};\nexports.isMemo = function (a) {\n  return z(a) === r;\n};\nexports.isPortal = function (a) {\n  return z(a) === d;\n};\nexports.isProfiler = function (a) {\n  return z(a) === g;\n};\nexports.isStrictMode = function (a) {\n  return z(a) === f;\n};\nexports.isSuspense = function (a) {\n  return z(a) === p;\n};\nexports.isValidElementType = function (a) {\n  return \"string\" === typeof a || \"function\" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || \"object\" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);\n};\nexports.typeOf = z;","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}","'use strict';\n\nvar React = require('react');\nvar xtend = require('xtend');\nvar ReactIs = require('react-is');\nvar defaultNodePosition = {\n  start: {\n    line: 1,\n    column: 1,\n    offset: 0\n  },\n  end: {\n    line: 1,\n    column: 1,\n    offset: 0\n  }\n};\nfunction astToReact(node, options) {\n  var parent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n  var renderer = options.renderers[node.type]; // nodes generated by plugins may not have position data\n  // much of the code after this point will attempt to access properties of the node.position\n  // this will set the node position to the parent node's position to prevent errors\n\n  if (node.position === undefined) {\n    node.position = parent.node && parent.node.position || defaultNodePosition;\n  }\n  var pos = node.position.start;\n  var key = [node.type, pos.line, pos.column, index].join('-');\n  if (!ReactIs.isValidElementType(renderer)) {\n    throw new Error(\"Renderer for type `\".concat(node.type, \"` not defined or is not renderable\"));\n  }\n  var nodeProps = getNodeProps(node, key, options, renderer, parent, index);\n  return React.createElement(renderer, nodeProps, nodeProps.children || resolveChildren() || undefined);\n  function resolveChildren() {\n    return node.children && node.children.map(function (childNode, i) {\n      return astToReact(childNode, options, {\n        node: node,\n        props: nodeProps\n      }, i);\n    });\n  }\n} // eslint-disable-next-line max-params, complexity\n\nfunction getNodeProps(node, key, opts, renderer, parent, index) {\n  var props = {\n    key: key\n  };\n  var isTagRenderer = typeof renderer === 'string'; // `sourcePos` is true if the user wants source information (line/column info from markdown source)\n\n  if (opts.sourcePos && node.position) {\n    props['data-sourcepos'] = flattenPosition(node.position);\n  }\n  if (opts.rawSourcePos && !isTagRenderer) {\n    props.sourcePosition = node.position;\n  } // If `includeNodeIndex` is true, pass node index info to all non-tag renderers\n\n  if (opts.includeNodeIndex && parent.node && parent.node.children && !isTagRenderer) {\n    props.index = parent.node.children.indexOf(node);\n    props.parentChildCount = parent.node.children.length;\n  }\n  var ref = node.identifier !== null && node.identifier !== undefined ? opts.definitions[node.identifier] || {} : null;\n  switch (node.type) {\n    case 'root':\n      assignDefined(props, {\n        className: opts.className\n      });\n      break;\n    case 'text':\n      props.nodeKey = key;\n      props.children = node.value;\n      break;\n    case 'heading':\n      props.level = node.depth;\n      break;\n    case 'list':\n      props.start = node.start;\n      props.ordered = node.ordered;\n      props.tight = !node.loose;\n      props.depth = node.depth;\n      break;\n    case 'listItem':\n      props.checked = node.checked;\n      props.tight = !node.loose;\n      props.ordered = node.ordered;\n      props.index = node.index;\n      props.children = getListItemChildren(node, parent).map(function (childNode, i) {\n        return astToReact(childNode, opts, {\n          node: node,\n          props: props\n        }, i);\n      });\n      break;\n    case 'definition':\n      assignDefined(props, {\n        identifier: node.identifier,\n        title: node.title,\n        url: node.url\n      });\n      break;\n    case 'code':\n      assignDefined(props, {\n        language: node.lang && node.lang.split(/\\s/, 1)[0]\n      });\n      break;\n    case 'inlineCode':\n      props.children = node.value;\n      props.inline = true;\n      break;\n    case 'link':\n      assignDefined(props, {\n        title: node.title || undefined,\n        target: typeof opts.linkTarget === 'function' ? opts.linkTarget(node.url, node.children, node.title) : opts.linkTarget,\n        href: opts.transformLinkUri ? opts.transformLinkUri(node.url, node.children, node.title) : node.url\n      });\n      break;\n    case 'image':\n      assignDefined(props, {\n        alt: node.alt || undefined,\n        title: node.title || undefined,\n        src: opts.transformImageUri ? opts.transformImageUri(node.url, node.children, node.title, node.alt) : node.url\n      });\n      break;\n    case 'linkReference':\n      assignDefined(props, xtend(ref, {\n        href: opts.transformLinkUri ? opts.transformLinkUri(ref.href) : ref.href\n      }));\n      break;\n    case 'imageReference':\n      assignDefined(props, {\n        src: opts.transformImageUri && ref.href ? opts.transformImageUri(ref.href, node.children, ref.title, node.alt) : ref.href,\n        title: ref.title || undefined,\n        alt: node.alt || undefined\n      });\n      break;\n    case 'table':\n    case 'tableHead':\n    case 'tableBody':\n      props.columnAlignment = node.align;\n      break;\n    case 'tableRow':\n      props.isHeader = parent.node.type === 'tableHead';\n      props.columnAlignment = parent.props.columnAlignment;\n      break;\n    case 'tableCell':\n      assignDefined(props, {\n        isHeader: parent.props.isHeader,\n        align: parent.props.columnAlignment[index]\n      });\n      break;\n    case 'virtualHtml':\n      props.tag = node.tag;\n      break;\n    case 'html':\n      // @todo find a better way than this\n      props.isBlock = node.position.start.line !== node.position.end.line;\n      props.escapeHtml = opts.escapeHtml;\n      props.skipHtml = opts.skipHtml;\n      break;\n    case 'parsedHtml':\n      {\n        var parsedChildren;\n        if (node.children) {\n          parsedChildren = node.children.map(function (child, i) {\n            return astToReact(child, opts, {\n              node: node,\n              props: props\n            }, i);\n          });\n        }\n        props.escapeHtml = opts.escapeHtml;\n        props.skipHtml = opts.skipHtml;\n        props.element = mergeNodeChildren(node, parsedChildren);\n        break;\n      }\n    default:\n      assignDefined(props, xtend(node, {\n        type: undefined,\n        position: undefined,\n        children: undefined\n      }));\n  }\n  if (!isTagRenderer && node.value) {\n    props.value = node.value;\n  }\n  return props;\n}\nfunction assignDefined(target, attrs) {\n  for (var key in attrs) {\n    if (typeof attrs[key] !== 'undefined') {\n      target[key] = attrs[key];\n    }\n  }\n}\nfunction mergeNodeChildren(node, parsedChildren) {\n  var el = node.element;\n  if (Array.isArray(el)) {\n    var Fragment = React.Fragment || 'div';\n    return React.createElement(Fragment, null, el);\n  }\n  if (el.props.children || parsedChildren) {\n    var children = React.Children.toArray(el.props.children).concat(parsedChildren);\n    return React.cloneElement(el, null, children);\n  }\n  return React.cloneElement(el, null);\n}\nfunction flattenPosition(pos) {\n  return [pos.start.line, ':', pos.start.column, '-', pos.end.line, ':', pos.end.column].map(String).join('');\n}\nfunction getListItemChildren(node, parent) {\n  if (node.loose) {\n    return node.children;\n  }\n  if (parent.node && node.index > 0 && parent.node.children[node.index - 1].loose) {\n    return node.children;\n  }\n  return unwrapParagraphs(node);\n}\nfunction unwrapParagraphs(node) {\n  return node.children.reduce(function (array, child) {\n    return array.concat(child.type === 'paragraph' ? child.children || [] : [child]);\n  }, []);\n}\nmodule.exports = astToReact;","'use strict';\n\nmodule.exports = function getDefinitions(node) {\n  var defs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return (node.children || []).reduce(function (definitions, child) {\n    if (child.type === 'definition') {\n      definitions[child.identifier] = {\n        href: child.url,\n        title: child.title\n      };\n    }\n    return getDefinitions(child, definitions);\n  }, defs);\n};","\"use strict\";\n\nvar visit = require('unist-util-visit');\nexports.ofType = function (types, mode) {\n  return function (node) {\n    types.forEach(function (type) {\n      return visit(node, type, disallow, true);\n    });\n    return node;\n  };\n  function disallow(node, index, parent) {\n    if (parent) {\n      untangle(node, index, parent, mode);\n    }\n  }\n};\nexports.ifNotMatch = function (allowNode, mode) {\n  return function (node) {\n    visit(node, disallow, true);\n    return node;\n  };\n  function disallow(node, index, parent) {\n    if (parent && !allowNode(node, index, parent)) {\n      untangle(node, index, parent, mode);\n    }\n  }\n};\nfunction untangle(node, index, parent, mode) {\n  if (mode === 'remove') {\n    parent.children.splice(index, 1);\n  } else if (mode === 'unwrap') {\n    var args = [index, 1];\n    if (node.children) {\n      args = args.concat(node.children);\n    }\n    Array.prototype.splice.apply(parent.children, args);\n  }\n}","\"use strict\";\n\n/**\n * Naive, simple plugin to match inline nodes without attributes\n * This allows say <strong>foo</strong>, but not <strong class=\"very\">foo</strong>\n * For proper HTML support, you'll want a different plugin\n **/\nvar visit = require('unist-util-visit');\nvar type = 'virtualHtml';\nvar selfClosingRe = /^<(area|base|br|col|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)\\s*\\/?>$/i;\nvar simpleTagRe = /^<(\\/?)([a-z]+)\\s*>$/;\nmodule.exports = function (tree) {\n  var open;\n  var currentParent;\n  visit(tree, 'html', function (node, index, parent) {\n    if (currentParent !== parent) {\n      open = [];\n      currentParent = parent;\n    }\n    var selfClosing = getSelfClosing(node);\n    if (selfClosing) {\n      parent.children.splice(index, 1, {\n        type: type,\n        tag: selfClosing,\n        position: node.position\n      });\n      return true;\n    }\n    var current = getSimpleTag(node, parent);\n    if (!current) {\n      return true;\n    }\n    var matching = findAndPull(open, current.tag);\n    if (matching) {\n      parent.children.splice(index, 0, virtual(current, matching, parent));\n    } else if (!current.opening) {\n      open.push(current);\n    }\n    return true;\n  }, true // Iterate in reverse\n  );\n  return tree;\n};\nfunction findAndPull(open, matchingTag) {\n  var i = open.length;\n  while (i--) {\n    if (open[i].tag === matchingTag) {\n      return open.splice(i, 1)[0];\n    }\n  }\n  return false;\n}\nfunction getSimpleTag(node, parent) {\n  var match = node.value.match(simpleTagRe);\n  return match ? {\n    tag: match[2],\n    opening: !match[1],\n    node: node\n  } : false;\n}\nfunction getSelfClosing(node) {\n  var match = node.value.match(selfClosingRe);\n  return match ? match[1] : false;\n}\nfunction virtual(fromNode, toNode, parent) {\n  var fromIndex = parent.children.indexOf(fromNode.node);\n  var toIndex = parent.children.indexOf(toNode.node);\n  var extracted = parent.children.splice(fromIndex, toIndex - fromIndex + 1);\n  var children = extracted.slice(1, -1);\n  return {\n    type: type,\n    children: children,\n    tag: fromNode.tag,\n    position: {\n      start: fromNode.node.position.start,\n      end: toNode.node.position.end,\n      indent: []\n    }\n  };\n}","'use strict';\n\nfunction _toConsumableArray(arr) {\n  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n}\nfunction _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\nfunction _iterableToArray(iter) {\n  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n    return arr2;\n  }\n}\nvar xtend = require('xtend');\nvar unified = require('unified');\nvar parse = require('remark-parse');\nvar PropTypes = require('prop-types');\nvar addListMetadata = require('mdast-add-list-metadata');\nvar naiveHtml = require('./plugins/naive-html');\nvar disallowNode = require('./plugins/disallow-node');\nvar astToReact = require('./ast-to-react');\nvar wrapTableRows = require('./wrap-table-rows');\nvar getDefinitions = require('./get-definitions');\nvar uriTransformer = require('./uri-transformer');\nvar defaultRenderers = require('./renderers');\nvar symbols = require('./symbols');\nvar allTypes = Object.keys(defaultRenderers);\nvar ReactMarkdown = function ReactMarkdown(props) {\n  var src = props.source || props.children || '';\n  var parserOptions = props.parserOptions;\n  if (props.allowedTypes && props.disallowedTypes) {\n    throw new Error('Only one of `allowedTypes` and `disallowedTypes` should be defined');\n  }\n  var renderers = xtend(defaultRenderers, props.renderers);\n  var plugins = [[parse, parserOptions]].concat(props.plugins || []);\n  var parser = plugins.reduce(applyParserPlugin, unified());\n  var rawAst = parser.parse(src);\n  var renderProps = xtend(props, {\n    renderers: renderers,\n    definitions: getDefinitions(rawAst)\n  });\n  var astPlugins = determineAstPlugins(props); // eslint-disable-next-line no-sync\n\n  var transformedAst = parser.runSync(rawAst);\n  var ast = astPlugins.reduce(function (node, plugin) {\n    return plugin(node, renderProps);\n  }, transformedAst);\n  return astToReact(ast, renderProps);\n};\nfunction applyParserPlugin(parser, plugin) {\n  return Array.isArray(plugin) ? parser.use.apply(parser, _toConsumableArray(plugin)) : parser.use(plugin);\n}\nfunction determineAstPlugins(props) {\n  var plugins = [wrapTableRows, addListMetadata()];\n  var disallowedTypes = props.disallowedTypes;\n  if (props.allowedTypes) {\n    disallowedTypes = allTypes.filter(function (type) {\n      return type !== 'root' && props.allowedTypes.indexOf(type) === -1;\n    });\n  }\n  var removalMethod = props.unwrapDisallowed ? 'unwrap' : 'remove';\n  if (disallowedTypes && disallowedTypes.length > 0) {\n    plugins.push(disallowNode.ofType(disallowedTypes, removalMethod));\n  }\n  if (props.allowNode) {\n    plugins.push(disallowNode.ifNotMatch(props.allowNode, removalMethod));\n  }\n  var renderHtml = !props.escapeHtml && !props.skipHtml;\n  var hasHtmlParser = (props.astPlugins || []).some(function (item) {\n    var plugin = Array.isArray(item) ? item[0] : item;\n    return plugin.identity === symbols.HtmlParser;\n  });\n  if (renderHtml && !hasHtmlParser) {\n    plugins.push(naiveHtml);\n  }\n  return props.astPlugins ? plugins.concat(props.astPlugins) : plugins;\n}\nReactMarkdown.defaultProps = {\n  renderers: {},\n  escapeHtml: true,\n  skipHtml: false,\n  sourcePos: false,\n  rawSourcePos: false,\n  transformLinkUri: uriTransformer,\n  astPlugins: [],\n  plugins: [],\n  parserOptions: {}\n};\nReactMarkdown.propTypes = {\n  className: PropTypes.string,\n  source: PropTypes.string,\n  children: PropTypes.string,\n  sourcePos: PropTypes.bool,\n  rawSourcePos: PropTypes.bool,\n  escapeHtml: PropTypes.bool,\n  skipHtml: PropTypes.bool,\n  allowNode: PropTypes.func,\n  allowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  disallowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n  linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  transformImageUri: PropTypes.func,\n  astPlugins: PropTypes.arrayOf(PropTypes.func),\n  unwrapDisallowed: PropTypes.bool,\n  renderers: PropTypes.object,\n  plugins: PropTypes.array,\n  parserOptions: PropTypes.object\n};\nReactMarkdown.types = allTypes;\nReactMarkdown.renderers = defaultRenderers;\nReactMarkdown.uriTransformer = uriTransformer;\nmodule.exports = ReactMarkdown;","/* eslint-disable react/prop-types, react/no-multi-comp */\n'use strict';\n\nvar xtend = require('xtend');\nvar React = require('react');\nvar supportsStringRender = parseInt((React.version || '16').slice(0, 2), 10) >= 16;\nvar createElement = React.createElement;\nmodule.exports = {\n  break: 'br',\n  paragraph: 'p',\n  emphasis: 'em',\n  strong: 'strong',\n  thematicBreak: 'hr',\n  blockquote: 'blockquote',\n  delete: 'del',\n  link: 'a',\n  image: 'img',\n  linkReference: 'a',\n  imageReference: 'img',\n  table: SimpleRenderer.bind(null, 'table'),\n  tableHead: SimpleRenderer.bind(null, 'thead'),\n  tableBody: SimpleRenderer.bind(null, 'tbody'),\n  tableRow: SimpleRenderer.bind(null, 'tr'),\n  tableCell: TableCell,\n  root: Root,\n  text: TextRenderer,\n  list: List,\n  listItem: ListItem,\n  definition: NullRenderer,\n  heading: Heading,\n  inlineCode: InlineCode,\n  code: CodeBlock,\n  html: Html,\n  virtualHtml: VirtualHtml,\n  parsedHtml: ParsedHtml\n};\nfunction TextRenderer(props) {\n  return supportsStringRender ? props.children : createElement('span', null, props.children);\n}\nfunction Root(props) {\n  var useFragment = !props.className;\n  var root = useFragment ? React.Fragment || 'div' : 'div';\n  return createElement(root, useFragment ? null : props, props.children);\n}\nfunction SimpleRenderer(tag, props) {\n  return createElement(tag, getCoreProps(props), props.children);\n}\nfunction TableCell(props) {\n  var style = props.align ? {\n    textAlign: props.align\n  } : undefined;\n  var coreProps = getCoreProps(props);\n  return createElement(props.isHeader ? 'th' : 'td', style ? xtend({\n    style: style\n  }, coreProps) : coreProps, props.children);\n}\nfunction Heading(props) {\n  return createElement(\"h\".concat(props.level), getCoreProps(props), props.children);\n}\nfunction List(props) {\n  var attrs = getCoreProps(props);\n  if (props.start !== null && props.start !== 1 && props.start !== undefined) {\n    attrs.start = props.start.toString();\n  }\n  return createElement(props.ordered ? 'ol' : 'ul', attrs, props.children);\n}\nfunction ListItem(props) {\n  var checkbox = null;\n  if (props.checked !== null && props.checked !== undefined) {\n    var checked = props.checked;\n    checkbox = createElement('input', {\n      type: 'checkbox',\n      checked: checked,\n      readOnly: true\n    });\n  }\n  return createElement('li', getCoreProps(props), checkbox, props.children);\n}\nfunction CodeBlock(props) {\n  var className = props.language && \"language-\".concat(props.language);\n  var code = createElement('code', className ? {\n    className: className\n  } : null, props.value);\n  return createElement('pre', getCoreProps(props), code);\n}\nfunction InlineCode(props) {\n  return createElement('code', getCoreProps(props), props.children);\n}\nfunction Html(props) {\n  if (props.skipHtml) {\n    return null;\n  }\n  var tag = props.isBlock ? 'div' : 'span';\n  if (props.escapeHtml) {\n    var comp = React.Fragment || tag;\n    return createElement(comp, null, props.value);\n  }\n  var nodeProps = {\n    dangerouslySetInnerHTML: {\n      __html: props.value\n    }\n  };\n  return createElement(tag, nodeProps);\n}\nfunction ParsedHtml(props) {\n  return props['data-sourcepos'] ? React.cloneElement(props.element, {\n    'data-sourcepos': props['data-sourcepos']\n  }) : props.element;\n}\nfunction VirtualHtml(props) {\n  return createElement(props.tag, getCoreProps(props), props.children);\n}\nfunction NullRenderer() {\n  return null;\n}\nfunction getCoreProps(props) {\n  return props['data-sourcepos'] ? {\n    'data-sourcepos': props['data-sourcepos']\n  } : {};\n}","\"use strict\";\n\nvar HtmlParser = '__RMD_HTML_PARSER__';\nexports.HtmlParser = typeof Symbol === 'undefined' ? HtmlParser : Symbol(HtmlParser);","\"use strict\";\n\nvar protocols = ['http', 'https', 'mailto', 'tel'];\nmodule.exports = function uriTransformer(uri) {\n  var url = (uri || '').trim();\n  var first = url.charAt(0);\n  if (first === '#' || first === '/') {\n    return url;\n  }\n  var colon = url.indexOf(':');\n  if (colon === -1) {\n    return url;\n  }\n  var length = protocols.length;\n  var index = -1;\n  while (++index < length) {\n    var protocol = protocols[index];\n    if (colon === protocol.length && url.slice(0, protocol.length).toLowerCase() === protocol) {\n      return url;\n    }\n  }\n  index = url.indexOf('?');\n  if (index !== -1 && colon > index) {\n    return url;\n  }\n  index = url.indexOf('#');\n  if (index !== -1 && colon > index) {\n    return url;\n  } // eslint-disable-next-line no-script-url\n\n  return 'javascript:void(0)';\n};","'use strict';\n\nvar visit = require('unist-util-visit');\nmodule.exports = function (node) {\n  visit(node, 'table', wrap);\n  return node;\n};\nfunction wrap(table) {\n  var children = table.children;\n  table.children = [{\n    type: 'tableHead',\n    align: table.align,\n    children: [children[0]],\n    position: children[0].position\n  }];\n  if (children.length > 1) {\n    table.children.push({\n      type: 'tableBody',\n      align: table.align,\n      children: children.slice(1),\n      position: {\n        start: children[1].position.start,\n        end: children[children.length - 1].position.end\n      }\n    });\n  }\n}","'use strict';\n\nmodule.exports = alphabetical;\n\n// Check if the given character code, or the character code at the first\n// character, is alphabetical.\nfunction alphabetical(character) {\n  var code = typeof character === 'string' ? character.charCodeAt(0) : character;\n  return code >= 97 && code <= 122 /* a-z */ || code >= 65 && code <= 90 /* A-Z */;\n}","'use strict';\n\nvar alphabetical = require('is-alphabetical');\nvar decimal = require('is-decimal');\nmodule.exports = alphanumerical;\n\n// Check if the given character code, or the character code at the first\n// character, is alphanumerical.\nfunction alphanumerical(character) {\n  return alphabetical(character) || decimal(character);\n}","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n\n// The _isBuffer check is for Safari 5-7 support, because it's missing\n// Object.prototype.constructor. Remove this eventually\nmodule.exports = function (obj) {\n  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer);\n};\nfunction isBuffer(obj) {\n  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj);\n}\n\n// For Node v0.10 support. Remove this eventually.\nfunction isSlowBuffer(obj) {\n  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0));\n}","'use strict';\n\nmodule.exports = decimal;\n\n// Check if the given character code, or the character code at the first\n// character, is decimal.\nfunction decimal(character) {\n  var code = typeof character === 'string' ? character.charCodeAt(0) : character;\n  return code >= 48 && code <= 57; /* 0-9 */\n}","'use strict';\n\nmodule.exports = hexadecimal;\n\n// Check if the given character code, or the character code at the first\n// character, is hexadecimal.\nfunction hexadecimal(character) {\n  var code = typeof character === 'string' ? character.charCodeAt(0) : character;\n  return code >= 97 /* a */ && code <= 102 /* z */ || code >= 65 /* A */ && code <= 70 /* Z */ || code >= 48 /* A */ && code <= 57 /* Z */;\n}","'use strict';\n\nvar toString = Object.prototype.toString;\nmodule.exports = function (x) {\n  var prototype;\n  return toString.call(x) === '[object Object]' && (prototype = Object.getPrototypeOf(x), prototype === null || prototype === Object.getPrototypeOf({}));\n};","'use strict';\n\n/* eslint-env browser */\nvar el;\nvar semicolon = 59; //  ';'\n\nmodule.exports = decodeEntity;\nfunction decodeEntity(characters) {\n  var entity = '&' + characters + ';';\n  var char;\n  el = el || document.createElement('i');\n  el.innerHTML = entity;\n  char = el.textContent;\n\n  // Some entities do not require the closing semicolon (`&not` - for instance),\n  // which leads to situations where parsing the assumed entity of &notit; will\n  // result in the string `¬it;`.  When we encounter a trailing semicolon after\n  // parsing and the entity to decode was not a semicolon (`&semi;`), we can\n  // assume that the matching was incomplete\n  if (char.charCodeAt(char.length - 1) === semicolon && characters !== 'semi') {\n    return false;\n  }\n\n  // If the decoded string is equal to the input, the entity was not valid\n  return char === entity ? false : char;\n}","'use strict';\n\nvar legacy = require('character-entities-legacy');\nvar invalid = require('character-reference-invalid');\nvar decimal = require('is-decimal');\nvar hexadecimal = require('is-hexadecimal');\nvar alphanumerical = require('is-alphanumerical');\nvar decodeEntity = require('./decode-entity');\nmodule.exports = parseEntities;\nvar own = {}.hasOwnProperty;\nvar fromCharCode = String.fromCharCode;\nvar noop = Function.prototype;\n\n// Default settings.\nvar defaults = {\n  warning: null,\n  reference: null,\n  text: null,\n  warningContext: null,\n  referenceContext: null,\n  textContext: null,\n  position: {},\n  additional: null,\n  attribute: false,\n  nonTerminated: true\n};\n\n// Characters.\nvar tab = 9; // '\\t'\nvar lineFeed = 10; // '\\n'\nvar formFeed = 12; //  '\\f'\nvar space = 32; // ' '\nvar ampersand = 38; //  '&'\nvar semicolon = 59; //  ';'\nvar lessThan = 60; //  '<'\nvar equalsTo = 61; //  '='\nvar numberSign = 35; //  '#'\nvar uppercaseX = 88; //  'X'\nvar lowercaseX = 120; //  'x'\nvar replacementCharacter = 65533; // '�'\n\n// Reference types.\nvar name = 'named';\nvar hexa = 'hexadecimal';\nvar deci = 'decimal';\n\n// Map of bases.\nvar bases = {};\nbases[hexa] = 16;\nbases[deci] = 10;\n\n// Map of types to tests.\n// Each type of character reference accepts different characters.\n// This test is used to detect whether a reference has ended (as the semicolon\n// is not strictly needed).\nvar tests = {};\ntests[name] = alphanumerical;\ntests[deci] = decimal;\ntests[hexa] = hexadecimal;\n\n// Warning types.\nvar namedNotTerminated = 1;\nvar numericNotTerminated = 2;\nvar namedEmpty = 3;\nvar numericEmpty = 4;\nvar namedUnknown = 5;\nvar numericDisallowed = 6;\nvar numericProhibited = 7;\n\n// Warning messages.\nvar messages = {};\nmessages[namedNotTerminated] = 'Named character references must be terminated by a semicolon';\nmessages[numericNotTerminated] = 'Numeric character references must be terminated by a semicolon';\nmessages[namedEmpty] = 'Named character references cannot be empty';\nmessages[numericEmpty] = 'Numeric character references cannot be empty';\nmessages[namedUnknown] = 'Named character references must be known';\nmessages[numericDisallowed] = 'Numeric character references cannot be disallowed';\nmessages[numericProhibited] = 'Numeric character references cannot be outside the permissible Unicode range';\n\n// Wrap to ensure clean parameters are given to `parse`.\nfunction parseEntities(value, options) {\n  var settings = {};\n  var option;\n  var key;\n  if (!options) {\n    options = {};\n  }\n  for (key in defaults) {\n    option = options[key];\n    settings[key] = option === null || option === undefined ? defaults[key] : option;\n  }\n  if (settings.position.indent || settings.position.start) {\n    settings.indent = settings.position.indent || [];\n    settings.position = settings.position.start;\n  }\n  return parse(value, settings);\n}\n\n// Parse entities.\n// eslint-disable-next-line complexity\nfunction parse(value, settings) {\n  var additional = settings.additional;\n  var nonTerminated = settings.nonTerminated;\n  var handleText = settings.text;\n  var handleReference = settings.reference;\n  var handleWarning = settings.warning;\n  var textContext = settings.textContext;\n  var referenceContext = settings.referenceContext;\n  var warningContext = settings.warningContext;\n  var pos = settings.position;\n  var indent = settings.indent || [];\n  var length = value.length;\n  var index = 0;\n  var lines = -1;\n  var column = pos.column || 1;\n  var line = pos.line || 1;\n  var queue = '';\n  var result = [];\n  var entityCharacters;\n  var namedEntity;\n  var terminated;\n  var characters;\n  var character;\n  var reference;\n  var following;\n  var warning;\n  var reason;\n  var output;\n  var entity;\n  var begin;\n  var start;\n  var type;\n  var test;\n  var prev;\n  var next;\n  var diff;\n  var end;\n  if (typeof additional === 'string') {\n    additional = additional.charCodeAt(0);\n  }\n\n  // Cache the current point.\n  prev = now();\n\n  // Wrap `handleWarning`.\n  warning = handleWarning ? parseError : noop;\n\n  // Ensure the algorithm walks over the first character and the end (inclusive).\n  index--;\n  length++;\n  while (++index < length) {\n    // If the previous character was a newline.\n    if (character === lineFeed) {\n      column = indent[lines] || 1;\n    }\n    character = value.charCodeAt(index);\n    if (character === ampersand) {\n      following = value.charCodeAt(index + 1);\n\n      // The behaviour depends on the identity of the next character.\n      if (following === tab || following === lineFeed || following === formFeed || following === space || following === ampersand || following === lessThan || following !== following || additional && following === additional) {\n        // Not a character reference.\n        // No characters are consumed, and nothing is returned.\n        // This is not an error, either.\n        queue += fromCharCode(character);\n        column++;\n        continue;\n      }\n      start = index + 1;\n      begin = start;\n      end = start;\n      if (following === numberSign) {\n        // Numerical entity.\n        end = ++begin;\n\n        // The behaviour further depends on the next character.\n        following = value.charCodeAt(end);\n        if (following === uppercaseX || following === lowercaseX) {\n          // ASCII hex digits.\n          type = hexa;\n          end = ++begin;\n        } else {\n          // ASCII digits.\n          type = deci;\n        }\n      } else {\n        // Named entity.\n        type = name;\n      }\n      entityCharacters = '';\n      entity = '';\n      characters = '';\n      test = tests[type];\n      end--;\n      while (++end < length) {\n        following = value.charCodeAt(end);\n        if (!test(following)) {\n          break;\n        }\n        characters += fromCharCode(following);\n\n        // Check if we can match a legacy named reference.\n        // If so, we cache that as the last viable named reference.\n        // This ensures we do not need to walk backwards later.\n        if (type === name && own.call(legacy, characters)) {\n          entityCharacters = characters;\n          entity = legacy[characters];\n        }\n      }\n      terminated = value.charCodeAt(end) === semicolon;\n      if (terminated) {\n        end++;\n        namedEntity = type === name ? decodeEntity(characters) : false;\n        if (namedEntity) {\n          entityCharacters = characters;\n          entity = namedEntity;\n        }\n      }\n      diff = 1 + end - start;\n      if (!terminated && !nonTerminated) {\n        // Empty.\n      } else if (!characters) {\n        // An empty (possible) entity is valid, unless it’s numeric (thus an\n        // ampersand followed by an octothorp).\n        if (type !== name) {\n          warning(numericEmpty, diff);\n        }\n      } else if (type === name) {\n        // An ampersand followed by anything unknown, and not terminated, is\n        // invalid.\n        if (terminated && !entity) {\n          warning(namedUnknown, 1);\n        } else {\n          // If theres something after an entity name which is not known, cap\n          // the reference.\n          if (entityCharacters !== characters) {\n            end = begin + entityCharacters.length;\n            diff = 1 + end - begin;\n            terminated = false;\n          }\n\n          // If the reference is not terminated, warn.\n          if (!terminated) {\n            reason = entityCharacters ? namedNotTerminated : namedEmpty;\n            if (settings.attribute) {\n              following = value.charCodeAt(end);\n              if (following === equalsTo) {\n                warning(reason, diff);\n                entity = null;\n              } else if (alphanumerical(following)) {\n                entity = null;\n              } else {\n                warning(reason, diff);\n              }\n            } else {\n              warning(reason, diff);\n            }\n          }\n        }\n        reference = entity;\n      } else {\n        if (!terminated) {\n          // All non-terminated numeric entities are not rendered, and trigger a\n          // warning.\n          warning(numericNotTerminated, diff);\n        }\n\n        // When terminated and number, parse as either hexadecimal or decimal.\n        reference = parseInt(characters, bases[type]);\n\n        // Trigger a warning when the parsed number is prohibited, and replace\n        // with replacement character.\n        if (prohibited(reference)) {\n          warning(numericProhibited, diff);\n          reference = fromCharCode(replacementCharacter);\n        } else if (reference in invalid) {\n          // Trigger a warning when the parsed number is disallowed, and replace\n          // by an alternative.\n          warning(numericDisallowed, diff);\n          reference = invalid[reference];\n        } else {\n          // Parse the number.\n          output = '';\n\n          // Trigger a warning when the parsed number should not be used.\n          if (disallowed(reference)) {\n            warning(numericDisallowed, diff);\n          }\n\n          // Stringify the number.\n          if (reference > 0xffff) {\n            reference -= 0x10000;\n            output += fromCharCode(reference >>> (10 & 0x3ff) | 0xd800);\n            reference = 0xdc00 | reference & 0x3ff;\n          }\n          reference = output + fromCharCode(reference);\n        }\n      }\n\n      // Found it!\n      // First eat the queued characters as normal text, then eat an entity.\n      if (reference) {\n        flush();\n        prev = now();\n        index = end - 1;\n        column += end - start + 1;\n        result.push(reference);\n        next = now();\n        next.offset++;\n        if (handleReference) {\n          handleReference.call(referenceContext, reference, {\n            start: prev,\n            end: next\n          }, value.slice(start - 1, end));\n        }\n        prev = next;\n      } else {\n        // If we could not find a reference, queue the checked characters (as\n        // normal characters), and move the pointer to their end.\n        // This is possible because we can be certain neither newlines nor\n        // ampersands are included.\n        characters = value.slice(start - 1, end);\n        queue += characters;\n        column += characters.length;\n        index = end - 1;\n      }\n    } else {\n      // Handle anything other than an ampersand, including newlines and EOF.\n      if (character === 10 // Line feed\n      ) {\n        line++;\n        lines++;\n        column = 0;\n      }\n      if (character === character) {\n        queue += fromCharCode(character);\n        column++;\n      } else {\n        flush();\n      }\n    }\n  }\n\n  // Return the reduced nodes, and any possible warnings.\n  return result.join('');\n\n  // Get current position.\n  function now() {\n    return {\n      line: line,\n      column: column,\n      offset: index + (pos.offset || 0)\n    };\n  }\n\n  // “Throw” a parse-error: a warning.\n  function parseError(code, offset) {\n    var position = now();\n    position.column += offset;\n    position.offset += offset;\n    handleWarning.call(warningContext, messages[code], position, code);\n  }\n\n  // Flush `queue` (normal text).\n  // Macro invoked before each entity and at the end of `value`.\n  // Does nothing when `queue` is empty.\n  function flush() {\n    if (queue) {\n      result.push(queue);\n      if (handleText) {\n        handleText.call(textContext, queue, {\n          start: prev,\n          end: now()\n        });\n      }\n      queue = '';\n    }\n  }\n}\n\n// Check if `character` is outside the permissible unicode range.\nfunction prohibited(code) {\n  return code >= 0xd800 && code <= 0xdfff || code > 0x10ffff;\n}\n\n// Check if `character` is disallowed.\nfunction disallowed(code) {\n  return code >= 0x0001 && code <= 0x0008 || code === 0x000b || code >= 0x000d && code <= 0x001f || code >= 0x007f && code <= 0x009f || code >= 0xfdd0 && code <= 0xfdef || (code & 0xffff) === 0xffff || (code & 0xffff) === 0xfffe;\n}","'use strict';\n\nvar unherit = require('unherit');\nvar xtend = require('xtend');\nvar Parser = require('./lib/parser.js');\nmodule.exports = parse;\nparse.Parser = Parser;\nfunction parse(options) {\n  var Local = unherit(Parser);\n  Local.prototype.options = xtend(Local.prototype.options, this.data('settings'), options);\n  this.Parser = Local;\n}","'use strict';\n\nvar xtend = require('xtend');\nvar entities = require('parse-entities');\nmodule.exports = factory;\n\n/* Factory to create an entity decoder. */\nfunction factory(ctx) {\n  decoder.raw = decodeRaw;\n  return decoder;\n\n  /* Normalize `position` to add an `indent`. */\n  function normalize(position) {\n    var offsets = ctx.offset;\n    var line = position.line;\n    var result = [];\n    while (++line) {\n      if (!(line in offsets)) {\n        break;\n      }\n      result.push((offsets[line] || 0) + 1);\n    }\n    return {\n      start: position,\n      indent: result\n    };\n  }\n\n  /* Handle a warning.\n   * See https://github.com/wooorm/parse-entities\n   * for the warnings. */\n  function handleWarning(reason, position, code) {\n    if (code === 3) {\n      return;\n    }\n    ctx.file.message(reason, position);\n  }\n\n  /* Decode `value` (at `position`) into text-nodes. */\n  function decoder(value, position, handler) {\n    entities(value, {\n      position: normalize(position),\n      warning: handleWarning,\n      text: handler,\n      reference: handler,\n      textContext: ctx,\n      referenceContext: ctx\n    });\n  }\n\n  /* Decode `value` (at `position`) into a string. */\n  function decodeRaw(value, position, options) {\n    return entities(value, xtend(options, {\n      position: normalize(position),\n      warning: handleWarning\n    }));\n  }\n}","'use strict';\n\nmodule.exports = {\n  position: true,\n  gfm: true,\n  commonmark: false,\n  footnotes: false,\n  pedantic: false,\n  blocks: require('./block-elements.json')\n};","'use strict';\n\nmodule.exports = locate;\nfunction locate(value, fromIndex) {\n  var index = value.indexOf('\\n', fromIndex);\n  while (index > fromIndex) {\n    if (value.charAt(index - 1) !== ' ') {\n      break;\n    }\n    index--;\n  }\n  return index;\n}","'use strict';\n\nmodule.exports = locate;\nfunction locate(value, fromIndex) {\n  return value.indexOf('`', fromIndex);\n}","'use strict';\n\nmodule.exports = locate;\nfunction locate(value, fromIndex) {\n  return value.indexOf('~~', fromIndex);\n}","'use strict';\n\nmodule.exports = locate;\nfunction locate(value, fromIndex) {\n  var asterisk = value.indexOf('*', fromIndex);\n  var underscore = value.indexOf('_', fromIndex);\n  if (underscore === -1) {\n    return asterisk;\n  }\n  if (asterisk === -1) {\n    return underscore;\n  }\n  return underscore < asterisk ? underscore : asterisk;\n}","'use strict';\n\nmodule.exports = locate;\nfunction locate(value, fromIndex) {\n  return value.indexOf('\\\\', fromIndex);\n}","'use strict';\n\nmodule.exports = locate;\nfunction locate(value, fromIndex) {\n  var link = value.indexOf('[', fromIndex);\n  var image = value.indexOf('![', fromIndex);\n  if (image === -1) {\n    return link;\n  }\n\n  /* Link can never be `-1` if an image is found, so we don’t need\n   * to check for that :) */\n  return link < image ? link : image;\n}","'use strict';\n\nmodule.exports = locate;\nfunction locate(value, fromIndex) {\n  var asterisk = value.indexOf('**', fromIndex);\n  var underscore = value.indexOf('__', fromIndex);\n  if (underscore === -1) {\n    return asterisk;\n  }\n  if (asterisk === -1) {\n    return underscore;\n  }\n  return underscore < asterisk ? underscore : asterisk;\n}","'use strict';\n\nmodule.exports = locate;\nfunction locate(value, fromIndex) {\n  return value.indexOf('<', fromIndex);\n}","'use strict';\n\nmodule.exports = locate;\nvar PROTOCOLS = ['https://', 'http://', 'mailto:'];\nfunction locate(value, fromIndex) {\n  var length = PROTOCOLS.length;\n  var index = -1;\n  var min = -1;\n  var position;\n  if (!this.options.gfm) {\n    return -1;\n  }\n  while (++index < length) {\n    position = value.indexOf(PROTOCOLS[index], fromIndex);\n    if (position !== -1 && (position < min || min === -1)) {\n      min = position;\n    }\n  }\n  return min;\n}","'use strict';\n\nvar xtend = require('xtend');\nvar removePosition = require('unist-util-remove-position');\nmodule.exports = parse;\nvar C_NEWLINE = '\\n';\nvar EXPRESSION_LINE_BREAKS = /\\r\\n|\\r/g;\n\n/* Parse the bound file. */\nfunction parse() {\n  var self = this;\n  var value = String(self.file);\n  var start = {\n    line: 1,\n    column: 1,\n    offset: 0\n  };\n  var content = xtend(start);\n  var node;\n\n  /* Clean non-unix newlines: `\\r\\n` and `\\r` are all\n   * changed to `\\n`.  This should not affect positional\n   * information. */\n  value = value.replace(EXPRESSION_LINE_BREAKS, C_NEWLINE);\n  if (value.charCodeAt(0) === 0xFEFF) {\n    value = value.slice(1);\n    content.column++;\n    content.offset++;\n  }\n  node = {\n    type: 'root',\n    children: self.tokenizeBlock(value, content),\n    position: {\n      start: start,\n      end: self.eof || xtend(start)\n    }\n  };\n  if (!self.options.position) {\n    removePosition(node, true);\n  }\n  return node;\n}","'use strict';\n\nvar xtend = require('xtend');\nvar toggle = require('state-toggle');\nvar vfileLocation = require('vfile-location');\nvar unescape = require('./unescape');\nvar decode = require('./decode');\nvar tokenizer = require('./tokenizer');\nmodule.exports = Parser;\nfunction Parser(doc, file) {\n  this.file = file;\n  this.offset = {};\n  this.options = xtend(this.options);\n  this.setOptions({});\n  this.inList = false;\n  this.inBlock = false;\n  this.inLink = false;\n  this.atStart = true;\n  this.toOffset = vfileLocation(file).toOffset;\n  this.unescape = unescape(this, 'escape');\n  this.decode = decode(this);\n}\nvar proto = Parser.prototype;\n\n/* Expose core. */\nproto.setOptions = require('./set-options');\nproto.parse = require('./parse');\n\n/* Expose `defaults`. */\nproto.options = require('./defaults');\n\n/* Enter and exit helpers. */\nproto.exitStart = toggle('atStart', true);\nproto.enterList = toggle('inList', false);\nproto.enterLink = toggle('inLink', false);\nproto.enterBlock = toggle('inBlock', false);\n\n/* Nodes that can interupt a paragraph:\n *\n * ```markdown\n * A paragraph, followed by a thematic break.\n * ___\n * ```\n *\n * In the above example, the thematic break “interupts”\n * the paragraph. */\nproto.interruptParagraph = [['thematicBreak'], ['atxHeading'], ['fencedCode'], ['blockquote'], ['html'], ['setextHeading', {\n  commonmark: false\n}], ['definition', {\n  commonmark: false\n}], ['footnote', {\n  commonmark: false\n}]];\n\n/* Nodes that can interupt a list:\n *\n * ```markdown\n * - One\n * ___\n * ```\n *\n * In the above example, the thematic break “interupts”\n * the list. */\nproto.interruptList = [['atxHeading', {\n  pedantic: false\n}], ['fencedCode', {\n  pedantic: false\n}], ['thematicBreak', {\n  pedantic: false\n}], ['definition', {\n  commonmark: false\n}], ['footnote', {\n  commonmark: false\n}]];\n\n/* Nodes that can interupt a blockquote:\n *\n * ```markdown\n * > A paragraph.\n * ___\n * ```\n *\n * In the above example, the thematic break “interupts”\n * the blockquote. */\nproto.interruptBlockquote = [['indentedCode', {\n  commonmark: true\n}], ['fencedCode', {\n  commonmark: true\n}], ['atxHeading', {\n  commonmark: true\n}], ['setextHeading', {\n  commonmark: true\n}], ['thematicBreak', {\n  commonmark: true\n}], ['html', {\n  commonmark: true\n}], ['list', {\n  commonmark: true\n}], ['definition', {\n  commonmark: false\n}], ['footnote', {\n  commonmark: false\n}]];\n\n/* Handlers. */\nproto.blockTokenizers = {\n  newline: require('./tokenize/newline'),\n  indentedCode: require('./tokenize/code-indented'),\n  fencedCode: require('./tokenize/code-fenced'),\n  blockquote: require('./tokenize/blockquote'),\n  atxHeading: require('./tokenize/heading-atx'),\n  thematicBreak: require('./tokenize/thematic-break'),\n  list: require('./tokenize/list'),\n  setextHeading: require('./tokenize/heading-setext'),\n  html: require('./tokenize/html-block'),\n  footnote: require('./tokenize/footnote-definition'),\n  definition: require('./tokenize/definition'),\n  table: require('./tokenize/table'),\n  paragraph: require('./tokenize/paragraph')\n};\nproto.inlineTokenizers = {\n  escape: require('./tokenize/escape'),\n  autoLink: require('./tokenize/auto-link'),\n  url: require('./tokenize/url'),\n  html: require('./tokenize/html-inline'),\n  link: require('./tokenize/link'),\n  reference: require('./tokenize/reference'),\n  strong: require('./tokenize/strong'),\n  emphasis: require('./tokenize/emphasis'),\n  deletion: require('./tokenize/delete'),\n  code: require('./tokenize/code-inline'),\n  break: require('./tokenize/break'),\n  text: require('./tokenize/text')\n};\n\n/* Expose precedence. */\nproto.blockMethods = keys(proto.blockTokenizers);\nproto.inlineMethods = keys(proto.inlineTokenizers);\n\n/* Tokenizers. */\nproto.tokenizeBlock = tokenizer('block');\nproto.tokenizeInline = tokenizer('inline');\nproto.tokenizeFactory = tokenizer;\n\n/* Get all keys in `value`. */\nfunction keys(value) {\n  var result = [];\n  var key;\n  for (key in value) {\n    result.push(key);\n  }\n  return result;\n}","'use strict';\n\nvar xtend = require('xtend');\nvar escapes = require('markdown-escapes');\nvar defaults = require('./defaults');\nmodule.exports = setOptions;\nfunction setOptions(options) {\n  var self = this;\n  var current = self.options;\n  var key;\n  var value;\n  if (options == null) {\n    options = {};\n  } else if (typeof options === 'object') {\n    options = xtend(options);\n  } else {\n    throw new Error('Invalid value `' + options + '` ' + 'for setting `options`');\n  }\n  for (key in defaults) {\n    value = options[key];\n    if (value == null) {\n      value = current[key];\n    }\n    if (key !== 'blocks' && typeof value !== 'boolean' || key === 'blocks' && typeof value !== 'object') {\n      throw new Error('Invalid value `' + value + '` for setting `options.' + key + '`');\n    }\n    options[key] = value;\n  }\n  self.options = options;\n  self.escape = escapes(options);\n  return self;\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar decode = require('parse-entities');\nvar locate = require('../locate/tag');\nmodule.exports = autoLink;\nautoLink.locator = locate;\nautoLink.notInLink = true;\nvar C_LT = '<';\nvar C_GT = '>';\nvar C_AT_SIGN = '@';\nvar C_SLASH = '/';\nvar MAILTO = 'mailto:';\nvar MAILTO_LENGTH = MAILTO.length;\n\n/* Tokenise a link. */\nfunction autoLink(eat, value, silent) {\n  var self;\n  var subvalue;\n  var length;\n  var index;\n  var queue;\n  var character;\n  var hasAtCharacter;\n  var link;\n  var now;\n  var content;\n  var tokenizers;\n  var exit;\n  if (value.charAt(0) !== C_LT) {\n    return;\n  }\n  self = this;\n  subvalue = '';\n  length = value.length;\n  index = 0;\n  queue = '';\n  hasAtCharacter = false;\n  link = '';\n  index++;\n  subvalue = C_LT;\n  while (index < length) {\n    character = value.charAt(index);\n    if (whitespace(character) || character === C_GT || character === C_AT_SIGN || character === ':' && value.charAt(index + 1) === C_SLASH) {\n      break;\n    }\n    queue += character;\n    index++;\n  }\n  if (!queue) {\n    return;\n  }\n  link += queue;\n  queue = '';\n  character = value.charAt(index);\n  link += character;\n  index++;\n  if (character === C_AT_SIGN) {\n    hasAtCharacter = true;\n  } else {\n    if (character !== ':' || value.charAt(index + 1) !== C_SLASH) {\n      return;\n    }\n    link += C_SLASH;\n    index++;\n  }\n  while (index < length) {\n    character = value.charAt(index);\n    if (whitespace(character) || character === C_GT) {\n      break;\n    }\n    queue += character;\n    index++;\n  }\n  character = value.charAt(index);\n  if (!queue || character !== C_GT) {\n    return;\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n  link += queue;\n  content = link;\n  subvalue += link + character;\n  now = eat.now();\n  now.column++;\n  now.offset++;\n  if (hasAtCharacter) {\n    if (link.slice(0, MAILTO_LENGTH).toLowerCase() === MAILTO) {\n      content = content.substr(MAILTO_LENGTH);\n      now.column += MAILTO_LENGTH;\n      now.offset += MAILTO_LENGTH;\n    } else {\n      link = MAILTO + link;\n    }\n  }\n\n  /* Temporarily remove all tokenizers except text in autolinks. */\n  tokenizers = self.inlineTokenizers;\n  self.inlineTokenizers = {\n    text: tokenizers.text\n  };\n  exit = self.enterLink();\n  content = self.tokenizeInline(content, now);\n  self.inlineTokenizers = tokenizers;\n  exit();\n  return eat(subvalue)({\n    type: 'link',\n    title: null,\n    url: decode(link, {\n      nonTerminated: false\n    }),\n    children: content\n  });\n}","'use strict';\n\nvar trim = require('trim');\nvar interrupt = require('../util/interrupt');\nmodule.exports = blockquote;\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_GT = '>';\n\n/* Tokenise a blockquote. */\nfunction blockquote(eat, value, silent) {\n  var self = this;\n  var offsets = self.offset;\n  var tokenizers = self.blockTokenizers;\n  var interruptors = self.interruptBlockquote;\n  var now = eat.now();\n  var currentLine = now.line;\n  var length = value.length;\n  var values = [];\n  var contents = [];\n  var indents = [];\n  var add;\n  var index = 0;\n  var character;\n  var rest;\n  var nextIndex;\n  var content;\n  var line;\n  var startIndex;\n  var prefixed;\n  var exit;\n  while (index < length) {\n    character = value.charAt(index);\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n    index++;\n  }\n  if (value.charAt(index) !== C_GT) {\n    return;\n  }\n  if (silent) {\n    return true;\n  }\n  index = 0;\n  while (index < length) {\n    nextIndex = value.indexOf(C_NEWLINE, index);\n    startIndex = index;\n    prefixed = false;\n    if (nextIndex === -1) {\n      nextIndex = length;\n    }\n    while (index < length) {\n      character = value.charAt(index);\n      if (character !== C_SPACE && character !== C_TAB) {\n        break;\n      }\n      index++;\n    }\n    if (value.charAt(index) === C_GT) {\n      index++;\n      prefixed = true;\n      if (value.charAt(index) === C_SPACE) {\n        index++;\n      }\n    } else {\n      index = startIndex;\n    }\n    content = value.slice(index, nextIndex);\n    if (!prefixed && !trim(content)) {\n      index = startIndex;\n      break;\n    }\n    if (!prefixed) {\n      rest = value.slice(index);\n\n      /* Check if the following code contains a possible\n       * block. */\n      if (interrupt(interruptors, tokenizers, self, [eat, rest, true])) {\n        break;\n      }\n    }\n    line = startIndex === index ? content : value.slice(startIndex, nextIndex);\n    indents.push(index - startIndex);\n    values.push(line);\n    contents.push(content);\n    index = nextIndex + 1;\n  }\n  index = -1;\n  length = indents.length;\n  add = eat(values.join(C_NEWLINE));\n  while (++index < length) {\n    offsets[currentLine] = (offsets[currentLine] || 0) + indents[index];\n    currentLine++;\n  }\n  exit = self.enterBlock();\n  contents = self.tokenizeBlock(contents.join(C_NEWLINE), now);\n  exit();\n  return add({\n    type: 'blockquote',\n    children: contents\n  });\n}","'use strict';\n\nvar locate = require('../locate/break');\nmodule.exports = hardBreak;\nhardBreak.locator = locate;\nvar MIN_BREAK_LENGTH = 2;\nfunction hardBreak(eat, value, silent) {\n  var length = value.length;\n  var index = -1;\n  var queue = '';\n  var character;\n  while (++index < length) {\n    character = value.charAt(index);\n    if (character === '\\n') {\n      if (index < MIN_BREAK_LENGTH) {\n        return;\n      }\n\n      /* istanbul ignore if - never used (yet) */\n      if (silent) {\n        return true;\n      }\n      queue += character;\n      return eat(queue)({\n        type: 'break'\n      });\n    }\n    if (character !== ' ') {\n      return;\n    }\n    queue += character;\n  }\n}","'use strict';\n\nvar trim = require('trim-trailing-lines');\nmodule.exports = fencedCode;\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_TILDE = '~';\nvar C_TICK = '`';\nvar MIN_FENCE_COUNT = 3;\nvar CODE_INDENT_COUNT = 4;\nfunction fencedCode(eat, value, silent) {\n  var self = this;\n  var settings = self.options;\n  var length = value.length + 1;\n  var index = 0;\n  var subvalue = '';\n  var fenceCount;\n  var marker;\n  var character;\n  var flag;\n  var queue;\n  var content;\n  var exdentedContent;\n  var closing;\n  var exdentedClosing;\n  var indent;\n  var now;\n  if (!settings.gfm) {\n    return;\n  }\n\n  /* Eat initial spacing. */\n  while (index < length) {\n    character = value.charAt(index);\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n    subvalue += character;\n    index++;\n  }\n  indent = index;\n\n  /* Eat the fence. */\n  character = value.charAt(index);\n  if (character !== C_TILDE && character !== C_TICK) {\n    return;\n  }\n  index++;\n  marker = character;\n  fenceCount = 1;\n  subvalue += character;\n  while (index < length) {\n    character = value.charAt(index);\n    if (character !== marker) {\n      break;\n    }\n    subvalue += character;\n    fenceCount++;\n    index++;\n  }\n  if (fenceCount < MIN_FENCE_COUNT) {\n    return;\n  }\n\n  /* Eat spacing before flag. */\n  while (index < length) {\n    character = value.charAt(index);\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n    subvalue += character;\n    index++;\n  }\n\n  /* Eat flag. */\n  flag = '';\n  queue = '';\n  while (index < length) {\n    character = value.charAt(index);\n    if (character === C_NEWLINE || character === C_TILDE || character === C_TICK) {\n      break;\n    }\n    if (character === C_SPACE || character === C_TAB) {\n      queue += character;\n    } else {\n      flag += queue + character;\n      queue = '';\n    }\n    index++;\n  }\n  character = value.charAt(index);\n  if (character && character !== C_NEWLINE) {\n    return;\n  }\n  if (silent) {\n    return true;\n  }\n  now = eat.now();\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n  subvalue += flag;\n  flag = self.decode.raw(self.unescape(flag), now);\n  if (queue) {\n    subvalue += queue;\n  }\n  queue = '';\n  closing = '';\n  exdentedClosing = '';\n  content = '';\n  exdentedContent = '';\n\n  /* Eat content. */\n  while (index < length) {\n    character = value.charAt(index);\n    content += closing;\n    exdentedContent += exdentedClosing;\n    closing = '';\n    exdentedClosing = '';\n    if (character !== C_NEWLINE) {\n      content += character;\n      exdentedClosing += character;\n      index++;\n      continue;\n    }\n\n    /* Add the newline to `subvalue` if its the first\n     * character.  Otherwise, add it to the `closing`\n     * queue. */\n    if (content) {\n      closing += character;\n      exdentedClosing += character;\n    } else {\n      subvalue += character;\n    }\n    queue = '';\n    index++;\n    while (index < length) {\n      character = value.charAt(index);\n      if (character !== C_SPACE) {\n        break;\n      }\n      queue += character;\n      index++;\n    }\n    closing += queue;\n    exdentedClosing += queue.slice(indent);\n    if (queue.length >= CODE_INDENT_COUNT) {\n      continue;\n    }\n    queue = '';\n    while (index < length) {\n      character = value.charAt(index);\n      if (character !== marker) {\n        break;\n      }\n      queue += character;\n      index++;\n    }\n    closing += queue;\n    exdentedClosing += queue;\n    if (queue.length < fenceCount) {\n      continue;\n    }\n    queue = '';\n    while (index < length) {\n      character = value.charAt(index);\n      if (character !== C_SPACE && character !== C_TAB) {\n        break;\n      }\n      closing += character;\n      exdentedClosing += character;\n      index++;\n    }\n    if (!character || character === C_NEWLINE) {\n      break;\n    }\n  }\n  subvalue += content + closing;\n  return eat(subvalue)({\n    type: 'code',\n    lang: flag || null,\n    value: trim(exdentedContent)\n  });\n}","'use strict';\n\nvar repeat = require('repeat-string');\nvar trim = require('trim-trailing-lines');\nmodule.exports = indentedCode;\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar CODE_INDENT_COUNT = 4;\nvar CODE_INDENT = repeat(C_SPACE, CODE_INDENT_COUNT);\n\n/* Tokenise indented code. */\nfunction indentedCode(eat, value, silent) {\n  var index = -1;\n  var length = value.length;\n  var subvalue = '';\n  var content = '';\n  var subvalueQueue = '';\n  var contentQueue = '';\n  var character;\n  var blankQueue;\n  var indent;\n  while (++index < length) {\n    character = value.charAt(index);\n    if (indent) {\n      indent = false;\n      subvalue += subvalueQueue;\n      content += contentQueue;\n      subvalueQueue = '';\n      contentQueue = '';\n      if (character === C_NEWLINE) {\n        subvalueQueue = character;\n        contentQueue = character;\n      } else {\n        subvalue += character;\n        content += character;\n        while (++index < length) {\n          character = value.charAt(index);\n          if (!character || character === C_NEWLINE) {\n            contentQueue = character;\n            subvalueQueue = character;\n            break;\n          }\n          subvalue += character;\n          content += character;\n        }\n      }\n    } else if (character === C_SPACE && value.charAt(index + 1) === character && value.charAt(index + 2) === character && value.charAt(index + 3) === character) {\n      subvalueQueue += CODE_INDENT;\n      index += 3;\n      indent = true;\n    } else if (character === C_TAB) {\n      subvalueQueue += character;\n      indent = true;\n    } else {\n      blankQueue = '';\n      while (character === C_TAB || character === C_SPACE) {\n        blankQueue += character;\n        character = value.charAt(++index);\n      }\n      if (character !== C_NEWLINE) {\n        break;\n      }\n      subvalueQueue += blankQueue + character;\n      contentQueue += character;\n    }\n  }\n  if (content) {\n    if (silent) {\n      return true;\n    }\n    return eat(subvalue)({\n      type: 'code',\n      lang: null,\n      value: trim(content)\n    });\n  }\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/code-inline');\nmodule.exports = inlineCode;\ninlineCode.locator = locate;\nvar C_TICK = '`';\n\n/* Tokenise inline code. */\nfunction inlineCode(eat, value, silent) {\n  var length = value.length;\n  var index = 0;\n  var queue = '';\n  var tickQueue = '';\n  var contentQueue;\n  var subqueue;\n  var count;\n  var openingCount;\n  var subvalue;\n  var character;\n  var found;\n  var next;\n  while (index < length) {\n    if (value.charAt(index) !== C_TICK) {\n      break;\n    }\n    queue += C_TICK;\n    index++;\n  }\n  if (!queue) {\n    return;\n  }\n  subvalue = queue;\n  openingCount = index;\n  queue = '';\n  next = value.charAt(index);\n  count = 0;\n  while (index < length) {\n    character = next;\n    next = value.charAt(index + 1);\n    if (character === C_TICK) {\n      count++;\n      tickQueue += character;\n    } else {\n      count = 0;\n      queue += character;\n    }\n    if (count && next !== C_TICK) {\n      if (count === openingCount) {\n        subvalue += queue + tickQueue;\n        found = true;\n        break;\n      }\n      queue += tickQueue;\n      tickQueue = '';\n    }\n    index++;\n  }\n  if (!found) {\n    if (openingCount % 2 !== 0) {\n      return;\n    }\n    queue = '';\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n  contentQueue = '';\n  subqueue = '';\n  length = queue.length;\n  index = -1;\n  while (++index < length) {\n    character = queue.charAt(index);\n    if (whitespace(character)) {\n      subqueue += character;\n      continue;\n    }\n    if (subqueue) {\n      if (contentQueue) {\n        contentQueue += subqueue;\n      }\n      subqueue = '';\n    }\n    contentQueue += character;\n  }\n  return eat(subvalue)({\n    type: 'inlineCode',\n    value: contentQueue\n  });\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar normalize = require('../util/normalize');\nmodule.exports = definition;\ndefinition.notInList = true;\ndefinition.notInBlock = true;\nvar C_DOUBLE_QUOTE = '\"';\nvar C_SINGLE_QUOTE = '\\'';\nvar C_BACKSLASH = '\\\\';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\nvar C_PAREN_OPEN = '(';\nvar C_PAREN_CLOSE = ')';\nvar C_COLON = ':';\nvar C_LT = '<';\nvar C_GT = '>';\nfunction definition(eat, value, silent) {\n  var self = this;\n  var commonmark = self.options.commonmark;\n  var index = 0;\n  var length = value.length;\n  var subvalue = '';\n  var beforeURL;\n  var beforeTitle;\n  var queue;\n  var character;\n  var test;\n  var identifier;\n  var url;\n  var title;\n  while (index < length) {\n    character = value.charAt(index);\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n    subvalue += character;\n    index++;\n  }\n  character = value.charAt(index);\n  if (character !== C_BRACKET_OPEN) {\n    return;\n  }\n  index++;\n  subvalue += character;\n  queue = '';\n  while (index < length) {\n    character = value.charAt(index);\n    if (character === C_BRACKET_CLOSE) {\n      break;\n    } else if (character === C_BACKSLASH) {\n      queue += character;\n      index++;\n      character = value.charAt(index);\n    }\n    queue += character;\n    index++;\n  }\n  if (!queue || value.charAt(index) !== C_BRACKET_CLOSE || value.charAt(index + 1) !== C_COLON) {\n    return;\n  }\n  identifier = queue;\n  subvalue += queue + C_BRACKET_CLOSE + C_COLON;\n  index = subvalue.length;\n  queue = '';\n  while (index < length) {\n    character = value.charAt(index);\n    if (character !== C_TAB && character !== C_SPACE && character !== C_NEWLINE) {\n      break;\n    }\n    subvalue += character;\n    index++;\n  }\n  character = value.charAt(index);\n  queue = '';\n  beforeURL = subvalue;\n  if (character === C_LT) {\n    index++;\n    while (index < length) {\n      character = value.charAt(index);\n      if (!isEnclosedURLCharacter(character)) {\n        break;\n      }\n      queue += character;\n      index++;\n    }\n    character = value.charAt(index);\n    if (character === isEnclosedURLCharacter.delimiter) {\n      subvalue += C_LT + queue + character;\n      index++;\n    } else {\n      if (commonmark) {\n        return;\n      }\n      index -= queue.length + 1;\n      queue = '';\n    }\n  }\n  if (!queue) {\n    while (index < length) {\n      character = value.charAt(index);\n      if (!isUnclosedURLCharacter(character)) {\n        break;\n      }\n      queue += character;\n      index++;\n    }\n    subvalue += queue;\n  }\n  if (!queue) {\n    return;\n  }\n  url = queue;\n  queue = '';\n  while (index < length) {\n    character = value.charAt(index);\n    if (character !== C_TAB && character !== C_SPACE && character !== C_NEWLINE) {\n      break;\n    }\n    queue += character;\n    index++;\n  }\n  character = value.charAt(index);\n  test = null;\n  if (character === C_DOUBLE_QUOTE) {\n    test = C_DOUBLE_QUOTE;\n  } else if (character === C_SINGLE_QUOTE) {\n    test = C_SINGLE_QUOTE;\n  } else if (character === C_PAREN_OPEN) {\n    test = C_PAREN_CLOSE;\n  }\n  if (!test) {\n    queue = '';\n    index = subvalue.length;\n  } else if (queue) {\n    subvalue += queue + character;\n    index = subvalue.length;\n    queue = '';\n    while (index < length) {\n      character = value.charAt(index);\n      if (character === test) {\n        break;\n      }\n      if (character === C_NEWLINE) {\n        index++;\n        character = value.charAt(index);\n        if (character === C_NEWLINE || character === test) {\n          return;\n        }\n        queue += C_NEWLINE;\n      }\n      queue += character;\n      index++;\n    }\n    character = value.charAt(index);\n    if (character !== test) {\n      return;\n    }\n    beforeTitle = subvalue;\n    subvalue += queue + character;\n    index++;\n    title = queue;\n    queue = '';\n  } else {\n    return;\n  }\n  while (index < length) {\n    character = value.charAt(index);\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n    subvalue += character;\n    index++;\n  }\n  character = value.charAt(index);\n  if (!character || character === C_NEWLINE) {\n    if (silent) {\n      return true;\n    }\n    beforeURL = eat(beforeURL).test().end;\n    url = self.decode.raw(self.unescape(url), beforeURL, {\n      nonTerminated: false\n    });\n    if (title) {\n      beforeTitle = eat(beforeTitle).test().end;\n      title = self.decode.raw(self.unescape(title), beforeTitle);\n    }\n    return eat(subvalue)({\n      type: 'definition',\n      identifier: normalize(identifier),\n      title: title || null,\n      url: url\n    });\n  }\n}\n\n/* Check if `character` can be inside an enclosed URI. */\nfunction isEnclosedURLCharacter(character) {\n  return character !== C_GT && character !== C_BRACKET_OPEN && character !== C_BRACKET_CLOSE;\n}\nisEnclosedURLCharacter.delimiter = C_GT;\n\n/* Check if `character` can be inside an unclosed URI. */\nfunction isUnclosedURLCharacter(character) {\n  return character !== C_BRACKET_OPEN && character !== C_BRACKET_CLOSE && !whitespace(character);\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/delete');\nmodule.exports = strikethrough;\nstrikethrough.locator = locate;\nvar C_TILDE = '~';\nvar DOUBLE = '~~';\nfunction strikethrough(eat, value, silent) {\n  var self = this;\n  var character = '';\n  var previous = '';\n  var preceding = '';\n  var subvalue = '';\n  var index;\n  var length;\n  var now;\n  if (!self.options.gfm || value.charAt(0) !== C_TILDE || value.charAt(1) !== C_TILDE || whitespace(value.charAt(2))) {\n    return;\n  }\n  index = 1;\n  length = value.length;\n  now = eat.now();\n  now.column += 2;\n  now.offset += 2;\n  while (++index < length) {\n    character = value.charAt(index);\n    if (character === C_TILDE && previous === C_TILDE && (!preceding || !whitespace(preceding))) {\n      /* istanbul ignore if - never used (yet) */\n      if (silent) {\n        return true;\n      }\n      return eat(DOUBLE + subvalue + DOUBLE)({\n        type: 'delete',\n        children: self.tokenizeInline(subvalue, now)\n      });\n    }\n    subvalue += previous;\n    preceding = previous;\n    previous = character;\n  }\n}","'use strict';\n\nvar trim = require('trim');\nvar word = require('is-word-character');\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/emphasis');\nmodule.exports = emphasis;\nemphasis.locator = locate;\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\nfunction emphasis(eat, value, silent) {\n  var self = this;\n  var index = 0;\n  var character = value.charAt(index);\n  var now;\n  var pedantic;\n  var marker;\n  var queue;\n  var subvalue;\n  var length;\n  var prev;\n  if (character !== C_ASTERISK && character !== C_UNDERSCORE) {\n    return;\n  }\n  pedantic = self.options.pedantic;\n  subvalue = character;\n  marker = character;\n  length = value.length;\n  index++;\n  queue = '';\n  character = '';\n  if (pedantic && whitespace(value.charAt(index))) {\n    return;\n  }\n  while (index < length) {\n    prev = character;\n    character = value.charAt(index);\n    if (character === marker && (!pedantic || !whitespace(prev))) {\n      character = value.charAt(++index);\n      if (character !== marker) {\n        if (!trim(queue) || prev === marker) {\n          return;\n        }\n        if (!pedantic && marker === C_UNDERSCORE && word(character)) {\n          queue += marker;\n          continue;\n        }\n\n        /* istanbul ignore if - never used (yet) */\n        if (silent) {\n          return true;\n        }\n        now = eat.now();\n        now.column++;\n        now.offset++;\n        return eat(subvalue + queue + marker)({\n          type: 'emphasis',\n          children: self.tokenizeInline(queue, now)\n        });\n      }\n      queue += marker;\n    }\n    if (!pedantic && character === '\\\\') {\n      queue += character;\n      character = value.charAt(++index);\n    }\n    queue += character;\n    index++;\n  }\n}","'use strict';\n\nvar locate = require('../locate/escape');\nmodule.exports = escape;\nescape.locator = locate;\nfunction escape(eat, value, silent) {\n  var self = this;\n  var character;\n  var node;\n  if (value.charAt(0) === '\\\\') {\n    character = value.charAt(1);\n    if (self.escape.indexOf(character) !== -1) {\n      /* istanbul ignore if - never used (yet) */\n      if (silent) {\n        return true;\n      }\n      if (character === '\\n') {\n        node = {\n          type: 'break'\n        };\n      } else {\n        node = {\n          type: 'text',\n          value: character\n        };\n      }\n      return eat('\\\\' + character)(node);\n    }\n  }\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar normalize = require('../util/normalize');\nmodule.exports = footnoteDefinition;\nfootnoteDefinition.notInList = true;\nfootnoteDefinition.notInBlock = true;\nvar C_BACKSLASH = '\\\\';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\nvar C_CARET = '^';\nvar C_COLON = ':';\nvar EXPRESSION_INITIAL_TAB = /^( {4}|\\t)?/gm;\nfunction footnoteDefinition(eat, value, silent) {\n  var self = this;\n  var offsets = self.offset;\n  var index;\n  var length;\n  var subvalue;\n  var now;\n  var currentLine;\n  var content;\n  var queue;\n  var subqueue;\n  var character;\n  var identifier;\n  var add;\n  var exit;\n  if (!self.options.footnotes) {\n    return;\n  }\n  index = 0;\n  length = value.length;\n  subvalue = '';\n  now = eat.now();\n  currentLine = now.line;\n  while (index < length) {\n    character = value.charAt(index);\n    if (!whitespace(character)) {\n      break;\n    }\n    subvalue += character;\n    index++;\n  }\n  if (value.charAt(index) !== C_BRACKET_OPEN || value.charAt(index + 1) !== C_CARET) {\n    return;\n  }\n  subvalue += C_BRACKET_OPEN + C_CARET;\n  index = subvalue.length;\n  queue = '';\n  while (index < length) {\n    character = value.charAt(index);\n    if (character === C_BRACKET_CLOSE) {\n      break;\n    } else if (character === C_BACKSLASH) {\n      queue += character;\n      index++;\n      character = value.charAt(index);\n    }\n    queue += character;\n    index++;\n  }\n  if (!queue || value.charAt(index) !== C_BRACKET_CLOSE || value.charAt(index + 1) !== C_COLON) {\n    return;\n  }\n  if (silent) {\n    return true;\n  }\n  identifier = normalize(queue);\n  subvalue += queue + C_BRACKET_CLOSE + C_COLON;\n  index = subvalue.length;\n  while (index < length) {\n    character = value.charAt(index);\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n    subvalue += character;\n    index++;\n  }\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n  queue = '';\n  content = '';\n  subqueue = '';\n  while (index < length) {\n    character = value.charAt(index);\n    if (character === C_NEWLINE) {\n      subqueue = character;\n      index++;\n      while (index < length) {\n        character = value.charAt(index);\n        if (character !== C_NEWLINE) {\n          break;\n        }\n        subqueue += character;\n        index++;\n      }\n      queue += subqueue;\n      subqueue = '';\n      while (index < length) {\n        character = value.charAt(index);\n        if (character !== C_SPACE) {\n          break;\n        }\n        subqueue += character;\n        index++;\n      }\n      if (subqueue.length === 0) {\n        break;\n      }\n      queue += subqueue;\n    }\n    if (queue) {\n      content += queue;\n      queue = '';\n    }\n    content += character;\n    index++;\n  }\n  subvalue += content;\n  content = content.replace(EXPRESSION_INITIAL_TAB, function (line) {\n    offsets[currentLine] = (offsets[currentLine] || 0) + line.length;\n    currentLine++;\n    return '';\n  });\n  add = eat(subvalue);\n  exit = self.enterBlock();\n  content = self.tokenizeBlock(content, now);\n  exit();\n  return add({\n    type: 'footnoteDefinition',\n    identifier: identifier,\n    children: content\n  });\n}","'use strict';\n\nmodule.exports = atxHeading;\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_HASH = '#';\nvar MAX_ATX_COUNT = 6;\nfunction atxHeading(eat, value, silent) {\n  var self = this;\n  var settings = self.options;\n  var length = value.length + 1;\n  var index = -1;\n  var now = eat.now();\n  var subvalue = '';\n  var content = '';\n  var character;\n  var queue;\n  var depth;\n\n  /* Eat initial spacing. */\n  while (++index < length) {\n    character = value.charAt(index);\n    if (character !== C_SPACE && character !== C_TAB) {\n      index--;\n      break;\n    }\n    subvalue += character;\n  }\n\n  /* Eat hashes. */\n  depth = 0;\n  while (++index <= length) {\n    character = value.charAt(index);\n    if (character !== C_HASH) {\n      index--;\n      break;\n    }\n    subvalue += character;\n    depth++;\n  }\n  if (depth > MAX_ATX_COUNT) {\n    return;\n  }\n  if (!depth || !settings.pedantic && value.charAt(index + 1) === C_HASH) {\n    return;\n  }\n  length = value.length + 1;\n\n  /* Eat intermediate white-space. */\n  queue = '';\n  while (++index < length) {\n    character = value.charAt(index);\n    if (character !== C_SPACE && character !== C_TAB) {\n      index--;\n      break;\n    }\n    queue += character;\n  }\n\n  /* Exit when not in pedantic mode without spacing. */\n  if (!settings.pedantic && queue.length === 0 && character && character !== C_NEWLINE) {\n    return;\n  }\n  if (silent) {\n    return true;\n  }\n\n  /* Eat content. */\n  subvalue += queue;\n  queue = '';\n  content = '';\n  while (++index < length) {\n    character = value.charAt(index);\n    if (!character || character === C_NEWLINE) {\n      break;\n    }\n    if (character !== C_SPACE && character !== C_TAB && character !== C_HASH) {\n      content += queue + character;\n      queue = '';\n      continue;\n    }\n    while (character === C_SPACE || character === C_TAB) {\n      queue += character;\n      character = value.charAt(++index);\n    }\n    while (character === C_HASH) {\n      queue += character;\n      character = value.charAt(++index);\n    }\n    while (character === C_SPACE || character === C_TAB) {\n      queue += character;\n      character = value.charAt(++index);\n    }\n    index--;\n  }\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n  subvalue += content + queue;\n  return eat(subvalue)({\n    type: 'heading',\n    depth: depth,\n    children: self.tokenizeInline(content, now)\n  });\n}","'use strict';\n\nmodule.exports = setextHeading;\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_EQUALS = '=';\nvar C_DASH = '-';\nvar MAX_HEADING_INDENT = 3;\n\n/* Map of characters which can be used to mark setext\n * headers, mapping to their corresponding depth. */\nvar SETEXT_MARKERS = {};\nSETEXT_MARKERS[C_EQUALS] = 1;\nSETEXT_MARKERS[C_DASH] = 2;\nfunction setextHeading(eat, value, silent) {\n  var self = this;\n  var now = eat.now();\n  var length = value.length;\n  var index = -1;\n  var subvalue = '';\n  var content;\n  var queue;\n  var character;\n  var marker;\n  var depth;\n\n  /* Eat initial indentation. */\n  while (++index < length) {\n    character = value.charAt(index);\n    if (character !== C_SPACE || index >= MAX_HEADING_INDENT) {\n      index--;\n      break;\n    }\n    subvalue += character;\n  }\n\n  /* Eat content. */\n  content = '';\n  queue = '';\n  while (++index < length) {\n    character = value.charAt(index);\n    if (character === C_NEWLINE) {\n      index--;\n      break;\n    }\n    if (character === C_SPACE || character === C_TAB) {\n      queue += character;\n    } else {\n      content += queue + character;\n      queue = '';\n    }\n  }\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n  subvalue += content + queue;\n\n  /* Ensure the content is followed by a newline and a\n   * valid marker. */\n  character = value.charAt(++index);\n  marker = value.charAt(++index);\n  if (character !== C_NEWLINE || !SETEXT_MARKERS[marker]) {\n    return;\n  }\n  subvalue += character;\n\n  /* Eat Setext-line. */\n  queue = marker;\n  depth = SETEXT_MARKERS[marker];\n  while (++index < length) {\n    character = value.charAt(index);\n    if (character !== marker) {\n      if (character !== C_NEWLINE) {\n        return;\n      }\n      index--;\n      break;\n    }\n    queue += character;\n  }\n  if (silent) {\n    return true;\n  }\n  return eat(subvalue + queue)({\n    type: 'heading',\n    depth: depth,\n    children: self.tokenizeInline(content, now)\n  });\n}","'use strict';\n\nvar openCloseTag = require('../util/html').openCloseTag;\nmodule.exports = blockHTML;\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_NEWLINE = '\\n';\nvar C_LT = '<';\nfunction blockHTML(eat, value, silent) {\n  var self = this;\n  var blocks = self.options.blocks;\n  var length = value.length;\n  var index = 0;\n  var next;\n  var line;\n  var offset;\n  var character;\n  var count;\n  var sequence;\n  var subvalue;\n  var sequences = [[/^<(script|pre|style)(?=(\\s|>|$))/i, /<\\/(script|pre|style)>/i, true], [/^<!--/, /-->/, true], [/^<\\?/, /\\?>/, true], [/^<![A-Za-z]/, />/, true], [/^<!\\[CDATA\\[/, /\\]\\]>/, true], [new RegExp('^</?(' + blocks.join('|') + ')(?=(\\\\s|/?>|$))', 'i'), /^$/, true], [new RegExp(openCloseTag.source + '\\\\s*$'), /^$/, false]];\n\n  /* Eat initial spacing. */\n  while (index < length) {\n    character = value.charAt(index);\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n    index++;\n  }\n  if (value.charAt(index) !== C_LT) {\n    return;\n  }\n  next = value.indexOf(C_NEWLINE, index + 1);\n  next = next === -1 ? length : next;\n  line = value.slice(index, next);\n  offset = -1;\n  count = sequences.length;\n  while (++offset < count) {\n    if (sequences[offset][0].test(line)) {\n      sequence = sequences[offset];\n      break;\n    }\n  }\n  if (!sequence) {\n    return;\n  }\n  if (silent) {\n    return sequence[2];\n  }\n  index = next;\n  if (!sequence[1].test(line)) {\n    while (index < length) {\n      next = value.indexOf(C_NEWLINE, index + 1);\n      next = next === -1 ? length : next;\n      line = value.slice(index + 1, next);\n      if (sequence[1].test(line)) {\n        if (line) {\n          index = next;\n        }\n        break;\n      }\n      index = next;\n    }\n  }\n  subvalue = value.slice(0, index);\n  return eat(subvalue)({\n    type: 'html',\n    value: subvalue\n  });\n}","'use strict';\n\nvar alphabetical = require('is-alphabetical');\nvar locate = require('../locate/tag');\nvar tag = require('../util/html').tag;\nmodule.exports = inlineHTML;\ninlineHTML.locator = locate;\nvar EXPRESSION_HTML_LINK_OPEN = /^<a /i;\nvar EXPRESSION_HTML_LINK_CLOSE = /^<\\/a>/i;\nfunction inlineHTML(eat, value, silent) {\n  var self = this;\n  var length = value.length;\n  var character;\n  var subvalue;\n  if (value.charAt(0) !== '<' || length < 3) {\n    return;\n  }\n  character = value.charAt(1);\n  if (!alphabetical(character) && character !== '?' && character !== '!' && character !== '/') {\n    return;\n  }\n  subvalue = value.match(tag);\n  if (!subvalue) {\n    return;\n  }\n\n  /* istanbul ignore if - not used yet. */\n  if (silent) {\n    return true;\n  }\n  subvalue = subvalue[0];\n  if (!self.inLink && EXPRESSION_HTML_LINK_OPEN.test(subvalue)) {\n    self.inLink = true;\n  } else if (self.inLink && EXPRESSION_HTML_LINK_CLOSE.test(subvalue)) {\n    self.inLink = false;\n  }\n  return eat(subvalue)({\n    type: 'html',\n    value: subvalue\n  });\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/link');\nmodule.exports = link;\nlink.locator = locate;\nvar own = {}.hasOwnProperty;\nvar C_BACKSLASH = '\\\\';\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\nvar C_PAREN_OPEN = '(';\nvar C_PAREN_CLOSE = ')';\nvar C_LT = '<';\nvar C_GT = '>';\nvar C_TICK = '`';\nvar C_DOUBLE_QUOTE = '\"';\nvar C_SINGLE_QUOTE = '\\'';\n\n/* Map of characters, which can be used to mark link\n * and image titles. */\nvar LINK_MARKERS = {};\nLINK_MARKERS[C_DOUBLE_QUOTE] = C_DOUBLE_QUOTE;\nLINK_MARKERS[C_SINGLE_QUOTE] = C_SINGLE_QUOTE;\n\n/* Map of characters, which can be used to mark link\n * and image titles in commonmark-mode. */\nvar COMMONMARK_LINK_MARKERS = {};\nCOMMONMARK_LINK_MARKERS[C_DOUBLE_QUOTE] = C_DOUBLE_QUOTE;\nCOMMONMARK_LINK_MARKERS[C_SINGLE_QUOTE] = C_SINGLE_QUOTE;\nCOMMONMARK_LINK_MARKERS[C_PAREN_OPEN] = C_PAREN_CLOSE;\nfunction link(eat, value, silent) {\n  var self = this;\n  var subvalue = '';\n  var index = 0;\n  var character = value.charAt(0);\n  var pedantic = self.options.pedantic;\n  var commonmark = self.options.commonmark;\n  var gfm = self.options.gfm;\n  var closed;\n  var count;\n  var opening;\n  var beforeURL;\n  var beforeTitle;\n  var subqueue;\n  var hasMarker;\n  var markers;\n  var isImage;\n  var content;\n  var marker;\n  var length;\n  var title;\n  var depth;\n  var queue;\n  var url;\n  var now;\n  var exit;\n  var node;\n\n  /* Detect whether this is an image. */\n  if (character === '!') {\n    isImage = true;\n    subvalue = character;\n    character = value.charAt(++index);\n  }\n\n  /* Eat the opening. */\n  if (character !== C_BRACKET_OPEN) {\n    return;\n  }\n\n  /* Exit when this is a link and we’re already inside\n   * a link. */\n  if (!isImage && self.inLink) {\n    return;\n  }\n  subvalue += character;\n  queue = '';\n  index++;\n\n  /* Eat the content. */\n  length = value.length;\n  now = eat.now();\n  depth = 0;\n  now.column += index;\n  now.offset += index;\n  while (index < length) {\n    character = value.charAt(index);\n    subqueue = character;\n    if (character === C_TICK) {\n      /* Inline-code in link content. */\n      count = 1;\n      while (value.charAt(index + 1) === C_TICK) {\n        subqueue += character;\n        index++;\n        count++;\n      }\n      if (!opening) {\n        opening = count;\n      } else if (count >= opening) {\n        opening = 0;\n      }\n    } else if (character === C_BACKSLASH) {\n      /* Allow brackets to be escaped. */\n      index++;\n      subqueue += value.charAt(index);\n      /* In GFM mode, brackets in code still count.\n       * In all other modes, they don’t.  This empty\n       * block prevents the next statements are\n       * entered. */\n    } else if ((!opening || gfm) && character === C_BRACKET_OPEN) {\n      depth++;\n    } else if ((!opening || gfm) && character === C_BRACKET_CLOSE) {\n      if (depth) {\n        depth--;\n      } else {\n        /* Allow white-space between content and\n         * url in GFM mode. */\n        if (!pedantic) {\n          while (index < length) {\n            character = value.charAt(index + 1);\n            if (!whitespace(character)) {\n              break;\n            }\n            subqueue += character;\n            index++;\n          }\n        }\n        if (value.charAt(index + 1) !== C_PAREN_OPEN) {\n          return;\n        }\n        subqueue += C_PAREN_OPEN;\n        closed = true;\n        index++;\n        break;\n      }\n    }\n    queue += subqueue;\n    subqueue = '';\n    index++;\n  }\n\n  /* Eat the content closing. */\n  if (!closed) {\n    return;\n  }\n  content = queue;\n  subvalue += queue + subqueue;\n  index++;\n\n  /* Eat white-space. */\n  while (index < length) {\n    character = value.charAt(index);\n    if (!whitespace(character)) {\n      break;\n    }\n    subvalue += character;\n    index++;\n  }\n\n  /* Eat the URL. */\n  character = value.charAt(index);\n  markers = commonmark ? COMMONMARK_LINK_MARKERS : LINK_MARKERS;\n  queue = '';\n  beforeURL = subvalue;\n  if (character === C_LT) {\n    index++;\n    beforeURL += C_LT;\n    while (index < length) {\n      character = value.charAt(index);\n      if (character === C_GT) {\n        break;\n      }\n      if (commonmark && character === '\\n') {\n        return;\n      }\n      queue += character;\n      index++;\n    }\n    if (value.charAt(index) !== C_GT) {\n      return;\n    }\n    subvalue += C_LT + queue + C_GT;\n    url = queue;\n    index++;\n  } else {\n    character = null;\n    subqueue = '';\n    while (index < length) {\n      character = value.charAt(index);\n      if (subqueue && own.call(markers, character)) {\n        break;\n      }\n      if (whitespace(character)) {\n        if (!pedantic) {\n          break;\n        }\n        subqueue += character;\n      } else {\n        if (character === C_PAREN_OPEN) {\n          depth++;\n        } else if (character === C_PAREN_CLOSE) {\n          if (depth === 0) {\n            break;\n          }\n          depth--;\n        }\n        queue += subqueue;\n        subqueue = '';\n        if (character === C_BACKSLASH) {\n          queue += C_BACKSLASH;\n          character = value.charAt(++index);\n        }\n        queue += character;\n      }\n      index++;\n    }\n    subvalue += queue;\n    url = queue;\n    index = subvalue.length;\n  }\n\n  /* Eat white-space. */\n  queue = '';\n  while (index < length) {\n    character = value.charAt(index);\n    if (!whitespace(character)) {\n      break;\n    }\n    queue += character;\n    index++;\n  }\n  character = value.charAt(index);\n  subvalue += queue;\n\n  /* Eat the title. */\n  if (queue && own.call(markers, character)) {\n    index++;\n    subvalue += character;\n    queue = '';\n    marker = markers[character];\n    beforeTitle = subvalue;\n\n    /* In commonmark-mode, things are pretty easy: the\n     * marker cannot occur inside the title.\n     *\n     * Non-commonmark does, however, support nested\n     * delimiters. */\n    if (commonmark) {\n      while (index < length) {\n        character = value.charAt(index);\n        if (character === marker) {\n          break;\n        }\n        if (character === C_BACKSLASH) {\n          queue += C_BACKSLASH;\n          character = value.charAt(++index);\n        }\n        index++;\n        queue += character;\n      }\n      character = value.charAt(index);\n      if (character !== marker) {\n        return;\n      }\n      title = queue;\n      subvalue += queue + character;\n      index++;\n      while (index < length) {\n        character = value.charAt(index);\n        if (!whitespace(character)) {\n          break;\n        }\n        subvalue += character;\n        index++;\n      }\n    } else {\n      subqueue = '';\n      while (index < length) {\n        character = value.charAt(index);\n        if (character === marker) {\n          if (hasMarker) {\n            queue += marker + subqueue;\n            subqueue = '';\n          }\n          hasMarker = true;\n        } else if (!hasMarker) {\n          queue += character;\n        } else if (character === C_PAREN_CLOSE) {\n          subvalue += queue + marker + subqueue;\n          title = queue;\n          break;\n        } else if (whitespace(character)) {\n          subqueue += character;\n        } else {\n          queue += marker + subqueue + character;\n          subqueue = '';\n          hasMarker = false;\n        }\n        index++;\n      }\n    }\n  }\n  if (value.charAt(index) !== C_PAREN_CLOSE) {\n    return;\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n  subvalue += C_PAREN_CLOSE;\n  url = self.decode.raw(self.unescape(url), eat(beforeURL).test().end, {\n    nonTerminated: false\n  });\n  if (title) {\n    beforeTitle = eat(beforeTitle).test().end;\n    title = self.decode.raw(self.unescape(title), beforeTitle);\n  }\n  node = {\n    type: isImage ? 'image' : 'link',\n    title: title || null,\n    url: url\n  };\n  if (isImage) {\n    node.alt = self.decode.raw(self.unescape(content), now) || null;\n  } else {\n    exit = self.enterLink();\n    node.children = self.tokenizeInline(content, now);\n    exit();\n  }\n  return eat(subvalue)(node);\n}","'use strict';\n\n/* eslint-disable max-params */\nvar trim = require('trim');\nvar repeat = require('repeat-string');\nvar decimal = require('is-decimal');\nvar getIndent = require('../util/get-indentation');\nvar removeIndent = require('../util/remove-indentation');\nvar interrupt = require('../util/interrupt');\nmodule.exports = list;\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\nvar C_PLUS = '+';\nvar C_DASH = '-';\nvar C_DOT = '.';\nvar C_SPACE = ' ';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_PAREN_CLOSE = ')';\nvar C_X_LOWER = 'x';\nvar TAB_SIZE = 4;\nvar EXPRESSION_LOOSE_LIST_ITEM = /\\n\\n(?!\\s*$)/;\nvar EXPRESSION_TASK_ITEM = /^\\[([ \\t]|x|X)][ \\t]/;\nvar EXPRESSION_BULLET = /^([ \\t]*)([*+-]|\\d+[.)])( {1,4}(?! )| |\\t|$|(?=\\n))([^\\n]*)/;\nvar EXPRESSION_PEDANTIC_BULLET = /^([ \\t]*)([*+-]|\\d+[.)])([ \\t]+)/;\nvar EXPRESSION_INITIAL_INDENT = /^( {1,4}|\\t)?/gm;\n\n/* Map of characters which can be used to mark\n * list-items. */\nvar LIST_UNORDERED_MARKERS = {};\nLIST_UNORDERED_MARKERS[C_ASTERISK] = true;\nLIST_UNORDERED_MARKERS[C_PLUS] = true;\nLIST_UNORDERED_MARKERS[C_DASH] = true;\n\n/* Map of characters which can be used to mark\n * list-items after a digit. */\nvar LIST_ORDERED_MARKERS = {};\nLIST_ORDERED_MARKERS[C_DOT] = true;\n\n/* Map of characters which can be used to mark\n * list-items after a digit. */\nvar LIST_ORDERED_COMMONMARK_MARKERS = {};\nLIST_ORDERED_COMMONMARK_MARKERS[C_DOT] = true;\nLIST_ORDERED_COMMONMARK_MARKERS[C_PAREN_CLOSE] = true;\nfunction list(eat, value, silent) {\n  var self = this;\n  var commonmark = self.options.commonmark;\n  var pedantic = self.options.pedantic;\n  var tokenizers = self.blockTokenizers;\n  var interuptors = self.interruptList;\n  var markers;\n  var index = 0;\n  var length = value.length;\n  var start = null;\n  var size = 0;\n  var queue;\n  var ordered;\n  var character;\n  var marker;\n  var nextIndex;\n  var startIndex;\n  var prefixed;\n  var currentMarker;\n  var content;\n  var line;\n  var prevEmpty;\n  var empty;\n  var items;\n  var allLines;\n  var emptyLines;\n  var item;\n  var enterTop;\n  var exitBlockquote;\n  var isLoose;\n  var node;\n  var now;\n  var end;\n  var indented;\n  while (index < length) {\n    character = value.charAt(index);\n    if (character === C_TAB) {\n      size += TAB_SIZE - size % TAB_SIZE;\n    } else if (character === C_SPACE) {\n      size++;\n    } else {\n      break;\n    }\n    index++;\n  }\n  if (size >= TAB_SIZE) {\n    return;\n  }\n  character = value.charAt(index);\n  markers = commonmark ? LIST_ORDERED_COMMONMARK_MARKERS : LIST_ORDERED_MARKERS;\n  if (LIST_UNORDERED_MARKERS[character] === true) {\n    marker = character;\n    ordered = false;\n  } else {\n    ordered = true;\n    queue = '';\n    while (index < length) {\n      character = value.charAt(index);\n      if (!decimal(character)) {\n        break;\n      }\n      queue += character;\n      index++;\n    }\n    character = value.charAt(index);\n    if (!queue || markers[character] !== true) {\n      return;\n    }\n    start = parseInt(queue, 10);\n    marker = character;\n  }\n  character = value.charAt(++index);\n  if (character !== C_SPACE && character !== C_TAB) {\n    return;\n  }\n  if (silent) {\n    return true;\n  }\n  index = 0;\n  items = [];\n  allLines = [];\n  emptyLines = [];\n  while (index < length) {\n    nextIndex = value.indexOf(C_NEWLINE, index);\n    startIndex = index;\n    prefixed = false;\n    indented = false;\n    if (nextIndex === -1) {\n      nextIndex = length;\n    }\n    end = index + TAB_SIZE;\n    size = 0;\n    while (index < length) {\n      character = value.charAt(index);\n      if (character === C_TAB) {\n        size += TAB_SIZE - size % TAB_SIZE;\n      } else if (character === C_SPACE) {\n        size++;\n      } else {\n        break;\n      }\n      index++;\n    }\n    if (size >= TAB_SIZE) {\n      indented = true;\n    }\n    if (item && size >= item.indent) {\n      indented = true;\n    }\n    character = value.charAt(index);\n    currentMarker = null;\n    if (!indented) {\n      if (LIST_UNORDERED_MARKERS[character] === true) {\n        currentMarker = character;\n        index++;\n        size++;\n      } else {\n        queue = '';\n        while (index < length) {\n          character = value.charAt(index);\n          if (!decimal(character)) {\n            break;\n          }\n          queue += character;\n          index++;\n        }\n        character = value.charAt(index);\n        index++;\n        if (queue && markers[character] === true) {\n          currentMarker = character;\n          size += queue.length + 1;\n        }\n      }\n      if (currentMarker) {\n        character = value.charAt(index);\n        if (character === C_TAB) {\n          size += TAB_SIZE - size % TAB_SIZE;\n          index++;\n        } else if (character === C_SPACE) {\n          end = index + TAB_SIZE;\n          while (index < end) {\n            if (value.charAt(index) !== C_SPACE) {\n              break;\n            }\n            index++;\n            size++;\n          }\n          if (index === end && value.charAt(index) === C_SPACE) {\n            index -= TAB_SIZE - 1;\n            size -= TAB_SIZE - 1;\n          }\n        } else if (character !== C_NEWLINE && character !== '') {\n          currentMarker = null;\n        }\n      }\n    }\n    if (currentMarker) {\n      if (!pedantic && marker !== currentMarker) {\n        break;\n      }\n      prefixed = true;\n    } else {\n      if (!commonmark && !indented && value.charAt(startIndex) === C_SPACE) {\n        indented = true;\n      } else if (commonmark && item) {\n        indented = size >= item.indent || size > TAB_SIZE;\n      }\n      prefixed = false;\n      index = startIndex;\n    }\n    line = value.slice(startIndex, nextIndex);\n    content = startIndex === index ? line : value.slice(index, nextIndex);\n    if (currentMarker === C_ASTERISK || currentMarker === C_UNDERSCORE || currentMarker === C_DASH) {\n      if (tokenizers.thematicBreak.call(self, eat, line, true)) {\n        break;\n      }\n    }\n    prevEmpty = empty;\n    empty = !trim(content).length;\n    if (indented && item) {\n      item.value = item.value.concat(emptyLines, line);\n      allLines = allLines.concat(emptyLines, line);\n      emptyLines = [];\n    } else if (prefixed) {\n      if (emptyLines.length !== 0) {\n        item.value.push('');\n        item.trail = emptyLines.concat();\n      }\n      item = {\n        value: [line],\n        indent: size,\n        trail: []\n      };\n      items.push(item);\n      allLines = allLines.concat(emptyLines, line);\n      emptyLines = [];\n    } else if (empty) {\n      if (prevEmpty) {\n        break;\n      }\n      emptyLines.push(line);\n    } else {\n      if (prevEmpty) {\n        break;\n      }\n      if (interrupt(interuptors, tokenizers, self, [eat, line, true])) {\n        break;\n      }\n      item.value = item.value.concat(emptyLines, line);\n      allLines = allLines.concat(emptyLines, line);\n      emptyLines = [];\n    }\n    index = nextIndex + 1;\n  }\n  node = eat(allLines.join(C_NEWLINE)).reset({\n    type: 'list',\n    ordered: ordered,\n    start: start,\n    loose: null,\n    children: []\n  });\n  enterTop = self.enterList();\n  exitBlockquote = self.enterBlock();\n  isLoose = false;\n  index = -1;\n  length = items.length;\n  while (++index < length) {\n    item = items[index].value.join(C_NEWLINE);\n    now = eat.now();\n    item = eat(item)(listItem(self, item, now), node);\n    if (item.loose) {\n      isLoose = true;\n    }\n    item = items[index].trail.join(C_NEWLINE);\n    if (index !== length - 1) {\n      item += C_NEWLINE;\n    }\n    eat(item);\n  }\n  enterTop();\n  exitBlockquote();\n  node.loose = isLoose;\n  return node;\n}\nfunction listItem(ctx, value, position) {\n  var offsets = ctx.offset;\n  var fn = ctx.options.pedantic ? pedanticListItem : normalListItem;\n  var checked = null;\n  var task;\n  var indent;\n  value = fn.apply(null, arguments);\n  if (ctx.options.gfm) {\n    task = value.match(EXPRESSION_TASK_ITEM);\n    if (task) {\n      indent = task[0].length;\n      checked = task[1].toLowerCase() === C_X_LOWER;\n      offsets[position.line] += indent;\n      value = value.slice(indent);\n    }\n  }\n  return {\n    type: 'listItem',\n    loose: EXPRESSION_LOOSE_LIST_ITEM.test(value) || value.charAt(value.length - 1) === C_NEWLINE,\n    checked: checked,\n    children: ctx.tokenizeBlock(value, position)\n  };\n}\n\n/* Create a list-item using overly simple mechanics. */\nfunction pedanticListItem(ctx, value, position) {\n  var offsets = ctx.offset;\n  var line = position.line;\n\n  /* Remove the list-item’s bullet. */\n  value = value.replace(EXPRESSION_PEDANTIC_BULLET, replacer);\n\n  /* The initial line was also matched by the below, so\n   * we reset the `line`. */\n  line = position.line;\n  return value.replace(EXPRESSION_INITIAL_INDENT, replacer);\n\n  /* A simple replacer which removed all matches,\n   * and adds their length to `offset`. */\n  function replacer($0) {\n    offsets[line] = (offsets[line] || 0) + $0.length;\n    line++;\n    return '';\n  }\n}\n\n/* Create a list-item using sane mechanics. */\nfunction normalListItem(ctx, value, position) {\n  var offsets = ctx.offset;\n  var line = position.line;\n  var max;\n  var bullet;\n  var rest;\n  var lines;\n  var trimmedLines;\n  var index;\n  var length;\n\n  /* Remove the list-item’s bullet. */\n  value = value.replace(EXPRESSION_BULLET, replacer);\n  lines = value.split(C_NEWLINE);\n  trimmedLines = removeIndent(value, getIndent(max).indent).split(C_NEWLINE);\n\n  /* We replaced the initial bullet with something\n   * else above, which was used to trick\n   * `removeIndentation` into removing some more\n   * characters when possible.  However, that could\n   * result in the initial line to be stripped more\n   * than it should be. */\n  trimmedLines[0] = rest;\n  offsets[line] = (offsets[line] || 0) + bullet.length;\n  line++;\n  index = 0;\n  length = lines.length;\n  while (++index < length) {\n    offsets[line] = (offsets[line] || 0) + lines[index].length - trimmedLines[index].length;\n    line++;\n  }\n  return trimmedLines.join(C_NEWLINE);\n  function replacer($0, $1, $2, $3, $4) {\n    bullet = $1 + $2 + $3;\n    rest = $4;\n\n    /* Make sure that the first nine numbered list items\n     * can indent with an extra space.  That is, when\n     * the bullet did not receive an extra final space. */\n    if (Number($2) < 10 && bullet.length % 2 === 1) {\n      $2 = C_SPACE + $2;\n    }\n    max = $1 + repeat(C_SPACE, $2.length) + $3;\n    return max + rest;\n  }\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nmodule.exports = newline;\n\n/* Tokenise newline. */\nfunction newline(eat, value, silent) {\n  var character = value.charAt(0);\n  var length;\n  var subvalue;\n  var queue;\n  var index;\n  if (character !== '\\n') {\n    return;\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n  index = 1;\n  length = value.length;\n  subvalue = character;\n  queue = '';\n  while (index < length) {\n    character = value.charAt(index);\n    if (!whitespace(character)) {\n      break;\n    }\n    queue += character;\n    if (character === '\\n') {\n      subvalue += queue;\n      queue = '';\n    }\n    index++;\n  }\n  eat(subvalue);\n}","'use strict';\n\nvar trim = require('trim');\nvar decimal = require('is-decimal');\nvar trimTrailingLines = require('trim-trailing-lines');\nvar interrupt = require('../util/interrupt');\nmodule.exports = paragraph;\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar TAB_SIZE = 4;\n\n/* Tokenise paragraph. */\nfunction paragraph(eat, value, silent) {\n  var self = this;\n  var settings = self.options;\n  var commonmark = settings.commonmark;\n  var gfm = settings.gfm;\n  var tokenizers = self.blockTokenizers;\n  var interruptors = self.interruptParagraph;\n  var index = value.indexOf(C_NEWLINE);\n  var length = value.length;\n  var position;\n  var subvalue;\n  var character;\n  var size;\n  var now;\n  while (index < length) {\n    /* Eat everything if there’s no following newline. */\n    if (index === -1) {\n      index = length;\n      break;\n    }\n\n    /* Stop if the next character is NEWLINE. */\n    if (value.charAt(index + 1) === C_NEWLINE) {\n      break;\n    }\n\n    /* In commonmark-mode, following indented lines\n     * are part of the paragraph. */\n    if (commonmark) {\n      size = 0;\n      position = index + 1;\n      while (position < length) {\n        character = value.charAt(position);\n        if (character === C_TAB) {\n          size = TAB_SIZE;\n          break;\n        } else if (character === C_SPACE) {\n          size++;\n        } else {\n          break;\n        }\n        position++;\n      }\n      if (size >= TAB_SIZE) {\n        index = value.indexOf(C_NEWLINE, index + 1);\n        continue;\n      }\n    }\n    subvalue = value.slice(index + 1);\n\n    /* Check if the following code contains a possible\n     * block. */\n    if (interrupt(interruptors, tokenizers, self, [eat, subvalue, true])) {\n      break;\n    }\n\n    /* Break if the following line starts a list, when\n     * already in a list, or when in commonmark, or when\n     * in gfm mode and the bullet is *not* numeric. */\n    if (tokenizers.list.call(self, eat, subvalue, true) && (self.inList || commonmark || gfm && !decimal(trim.left(subvalue).charAt(0)))) {\n      break;\n    }\n    position = index;\n    index = value.indexOf(C_NEWLINE, index + 1);\n    if (index !== -1 && trim(value.slice(position, index)) === '') {\n      index = position;\n      break;\n    }\n  }\n  subvalue = value.slice(0, index);\n  if (trim(subvalue) === '') {\n    eat(subvalue);\n    return null;\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n  now = eat.now();\n  subvalue = trimTrailingLines(subvalue);\n  return eat(subvalue)({\n    type: 'paragraph',\n    children: self.tokenizeInline(subvalue, now)\n  });\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/link');\nvar normalize = require('../util/normalize');\nmodule.exports = reference;\nreference.locator = locate;\nvar T_LINK = 'link';\nvar T_IMAGE = 'image';\nvar T_FOOTNOTE = 'footnote';\nvar REFERENCE_TYPE_SHORTCUT = 'shortcut';\nvar REFERENCE_TYPE_COLLAPSED = 'collapsed';\nvar REFERENCE_TYPE_FULL = 'full';\nvar C_CARET = '^';\nvar C_BACKSLASH = '\\\\';\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\nfunction reference(eat, value, silent) {\n  var self = this;\n  var character = value.charAt(0);\n  var index = 0;\n  var length = value.length;\n  var subvalue = '';\n  var intro = '';\n  var type = T_LINK;\n  var referenceType = REFERENCE_TYPE_SHORTCUT;\n  var content;\n  var identifier;\n  var now;\n  var node;\n  var exit;\n  var queue;\n  var bracketed;\n  var depth;\n\n  /* Check whether we’re eating an image. */\n  if (character === '!') {\n    type = T_IMAGE;\n    intro = character;\n    character = value.charAt(++index);\n  }\n  if (character !== C_BRACKET_OPEN) {\n    return;\n  }\n  index++;\n  intro += character;\n  queue = '';\n\n  /* Check whether we’re eating a footnote. */\n  if (self.options.footnotes && value.charAt(index) === C_CARET) {\n    /* Exit if `![^` is found, so the `!` will be seen as text after this,\n     * and we’ll enter this function again when `[^` is found. */\n    if (type === T_IMAGE) {\n      return;\n    }\n    intro += C_CARET;\n    index++;\n    type = T_FOOTNOTE;\n  }\n\n  /* Eat the text. */\n  depth = 0;\n  while (index < length) {\n    character = value.charAt(index);\n    if (character === C_BRACKET_OPEN) {\n      bracketed = true;\n      depth++;\n    } else if (character === C_BRACKET_CLOSE) {\n      if (!depth) {\n        break;\n      }\n      depth--;\n    }\n    if (character === C_BACKSLASH) {\n      queue += C_BACKSLASH;\n      character = value.charAt(++index);\n    }\n    queue += character;\n    index++;\n  }\n  subvalue = queue;\n  content = queue;\n  character = value.charAt(index);\n  if (character !== C_BRACKET_CLOSE) {\n    return;\n  }\n  index++;\n  subvalue += character;\n  queue = '';\n  while (index < length) {\n    character = value.charAt(index);\n    if (!whitespace(character)) {\n      break;\n    }\n    queue += character;\n    index++;\n  }\n  character = value.charAt(index);\n\n  /* Inline footnotes cannot have an identifier. */\n  if (type !== T_FOOTNOTE && character === C_BRACKET_OPEN) {\n    identifier = '';\n    queue += character;\n    index++;\n    while (index < length) {\n      character = value.charAt(index);\n      if (character === C_BRACKET_OPEN || character === C_BRACKET_CLOSE) {\n        break;\n      }\n      if (character === C_BACKSLASH) {\n        identifier += C_BACKSLASH;\n        character = value.charAt(++index);\n      }\n      identifier += character;\n      index++;\n    }\n    character = value.charAt(index);\n    if (character === C_BRACKET_CLOSE) {\n      referenceType = identifier ? REFERENCE_TYPE_FULL : REFERENCE_TYPE_COLLAPSED;\n      queue += identifier + character;\n      index++;\n    } else {\n      identifier = '';\n    }\n    subvalue += queue;\n    queue = '';\n  } else {\n    if (!content) {\n      return;\n    }\n    identifier = content;\n  }\n\n  /* Brackets cannot be inside the identifier. */\n  if (referenceType !== REFERENCE_TYPE_FULL && bracketed) {\n    return;\n  }\n  subvalue = intro + subvalue;\n  if (type === T_LINK && self.inLink) {\n    return null;\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n  if (type === T_FOOTNOTE && content.indexOf(' ') !== -1) {\n    return eat(subvalue)({\n      type: 'footnote',\n      children: this.tokenizeInline(content, eat.now())\n    });\n  }\n  now = eat.now();\n  now.column += intro.length;\n  now.offset += intro.length;\n  identifier = referenceType === REFERENCE_TYPE_FULL ? identifier : content;\n  node = {\n    type: type + 'Reference',\n    identifier: normalize(identifier)\n  };\n  if (type === T_LINK || type === T_IMAGE) {\n    node.referenceType = referenceType;\n  }\n  if (type === T_LINK) {\n    exit = self.enterLink();\n    node.children = self.tokenizeInline(content, now);\n    exit();\n  } else if (type === T_IMAGE) {\n    node.alt = self.decode.raw(self.unescape(content), now) || null;\n  }\n  return eat(subvalue)(node);\n}","'use strict';\n\nvar trim = require('trim');\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/strong');\nmodule.exports = strong;\nstrong.locator = locate;\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\nfunction strong(eat, value, silent) {\n  var self = this;\n  var index = 0;\n  var character = value.charAt(index);\n  var now;\n  var pedantic;\n  var marker;\n  var queue;\n  var subvalue;\n  var length;\n  var prev;\n  if (character !== C_ASTERISK && character !== C_UNDERSCORE || value.charAt(++index) !== character) {\n    return;\n  }\n  pedantic = self.options.pedantic;\n  marker = character;\n  subvalue = marker + marker;\n  length = value.length;\n  index++;\n  queue = '';\n  character = '';\n  if (pedantic && whitespace(value.charAt(index))) {\n    return;\n  }\n  while (index < length) {\n    prev = character;\n    character = value.charAt(index);\n    if (character === marker && value.charAt(index + 1) === marker && (!pedantic || !whitespace(prev))) {\n      character = value.charAt(index + 2);\n      if (character !== marker) {\n        if (!trim(queue)) {\n          return;\n        }\n\n        /* istanbul ignore if - never used (yet) */\n        if (silent) {\n          return true;\n        }\n        now = eat.now();\n        now.column += 2;\n        now.offset += 2;\n        return eat(subvalue + queue + subvalue)({\n          type: 'strong',\n          children: self.tokenizeInline(queue, now)\n        });\n      }\n    }\n    if (!pedantic && character === '\\\\') {\n      queue += character;\n      character = value.charAt(++index);\n    }\n    queue += character;\n    index++;\n  }\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nmodule.exports = table;\nvar C_BACKSLASH = '\\\\';\nvar C_TICK = '`';\nvar C_DASH = '-';\nvar C_PIPE = '|';\nvar C_COLON = ':';\nvar C_SPACE = ' ';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar MIN_TABLE_COLUMNS = 1;\nvar MIN_TABLE_ROWS = 2;\nvar TABLE_ALIGN_LEFT = 'left';\nvar TABLE_ALIGN_CENTER = 'center';\nvar TABLE_ALIGN_RIGHT = 'right';\nvar TABLE_ALIGN_NONE = null;\nfunction table(eat, value, silent) {\n  var self = this;\n  var index;\n  var alignments;\n  var alignment;\n  var subvalue;\n  var row;\n  var length;\n  var lines;\n  var queue;\n  var character;\n  var hasDash;\n  var align;\n  var cell;\n  var preamble;\n  var count;\n  var opening;\n  var now;\n  var position;\n  var lineCount;\n  var line;\n  var rows;\n  var table;\n  var lineIndex;\n  var pipeIndex;\n  var first;\n\n  /* Exit when not in gfm-mode. */\n  if (!self.options.gfm) {\n    return;\n  }\n\n  /* Get the rows.\n   * Detecting tables soon is hard, so there are some\n   * checks for performance here, such as the minimum\n   * number of rows, and allowed characters in the\n   * alignment row. */\n  index = 0;\n  lineCount = 0;\n  length = value.length + 1;\n  lines = [];\n  while (index < length) {\n    lineIndex = value.indexOf(C_NEWLINE, index);\n    pipeIndex = value.indexOf(C_PIPE, index + 1);\n    if (lineIndex === -1) {\n      lineIndex = value.length;\n    }\n    if (pipeIndex === -1 || pipeIndex > lineIndex) {\n      if (lineCount < MIN_TABLE_ROWS) {\n        return;\n      }\n      break;\n    }\n    lines.push(value.slice(index, lineIndex));\n    lineCount++;\n    index = lineIndex + 1;\n  }\n\n  /* Parse the alignment row. */\n  subvalue = lines.join(C_NEWLINE);\n  alignments = lines.splice(1, 1)[0] || [];\n  index = 0;\n  length = alignments.length;\n  lineCount--;\n  alignment = false;\n  align = [];\n  while (index < length) {\n    character = alignments.charAt(index);\n    if (character === C_PIPE) {\n      hasDash = null;\n      if (alignment === false) {\n        if (first === false) {\n          return;\n        }\n      } else {\n        align.push(alignment);\n        alignment = false;\n      }\n      first = false;\n    } else if (character === C_DASH) {\n      hasDash = true;\n      alignment = alignment || TABLE_ALIGN_NONE;\n    } else if (character === C_COLON) {\n      if (alignment === TABLE_ALIGN_LEFT) {\n        alignment = TABLE_ALIGN_CENTER;\n      } else if (hasDash && alignment === TABLE_ALIGN_NONE) {\n        alignment = TABLE_ALIGN_RIGHT;\n      } else {\n        alignment = TABLE_ALIGN_LEFT;\n      }\n    } else if (!whitespace(character)) {\n      return;\n    }\n    index++;\n  }\n  if (alignment !== false) {\n    align.push(alignment);\n  }\n\n  /* Exit when without enough columns. */\n  if (align.length < MIN_TABLE_COLUMNS) {\n    return;\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n\n  /* Parse the rows. */\n  position = -1;\n  rows = [];\n  table = eat(subvalue).reset({\n    type: 'table',\n    align: align,\n    children: rows\n  });\n  while (++position < lineCount) {\n    line = lines[position];\n    row = {\n      type: 'tableRow',\n      children: []\n    };\n\n    /* Eat a newline character when this is not the\n     * first row. */\n    if (position) {\n      eat(C_NEWLINE);\n    }\n\n    /* Eat the row. */\n    eat(line).reset(row, table);\n    length = line.length + 1;\n    index = 0;\n    queue = '';\n    cell = '';\n    preamble = true;\n    count = null;\n    opening = null;\n    while (index < length) {\n      character = line.charAt(index);\n      if (character === C_TAB || character === C_SPACE) {\n        if (cell) {\n          queue += character;\n        } else {\n          eat(character);\n        }\n        index++;\n        continue;\n      }\n      if (character === '' || character === C_PIPE) {\n        if (preamble) {\n          eat(character);\n        } else {\n          if (character && opening) {\n            queue += character;\n            index++;\n            continue;\n          }\n          if ((cell || character) && !preamble) {\n            subvalue = cell;\n            if (queue.length > 1) {\n              if (character) {\n                subvalue += queue.slice(0, queue.length - 1);\n                queue = queue.charAt(queue.length - 1);\n              } else {\n                subvalue += queue;\n                queue = '';\n              }\n            }\n            now = eat.now();\n            eat(subvalue)({\n              type: 'tableCell',\n              children: self.tokenizeInline(cell, now)\n            }, row);\n          }\n          eat(queue + character);\n          queue = '';\n          cell = '';\n        }\n      } else {\n        if (queue) {\n          cell += queue;\n          queue = '';\n        }\n        cell += character;\n        if (character === C_BACKSLASH && index !== length - 2) {\n          cell += line.charAt(index + 1);\n          index++;\n        }\n        if (character === C_TICK) {\n          count = 1;\n          while (line.charAt(index + 1) === character) {\n            cell += character;\n            index++;\n            count++;\n          }\n          if (!opening) {\n            opening = count;\n          } else if (count >= opening) {\n            opening = 0;\n          }\n        }\n      }\n      preamble = false;\n      index++;\n    }\n\n    /* Eat the alignment row. */\n    if (!position) {\n      eat(C_NEWLINE + alignments);\n    }\n  }\n  return table;\n}","'use strict';\n\nmodule.exports = text;\nfunction text(eat, value, silent) {\n  var self = this;\n  var methods;\n  var tokenizers;\n  var index;\n  var length;\n  var subvalue;\n  var position;\n  var tokenizer;\n  var name;\n  var min;\n  var now;\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n  methods = self.inlineMethods;\n  length = methods.length;\n  tokenizers = self.inlineTokenizers;\n  index = -1;\n  min = value.length;\n  while (++index < length) {\n    name = methods[index];\n    if (name === 'text' || !tokenizers[name]) {\n      continue;\n    }\n    tokenizer = tokenizers[name].locator;\n    if (!tokenizer) {\n      eat.file.fail('Missing locator: `' + name + '`');\n    }\n    position = tokenizer.call(self, value, 1);\n    if (position !== -1 && position < min) {\n      min = position;\n    }\n  }\n  subvalue = value.slice(0, min);\n  now = eat.now();\n  self.decode(subvalue, now, function (content, position, source) {\n    eat(source || content)({\n      type: 'text',\n      value: content\n    });\n  });\n}","'use strict';\n\nmodule.exports = thematicBreak;\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\nvar C_DASH = '-';\nvar THEMATIC_BREAK_MARKER_COUNT = 3;\nfunction thematicBreak(eat, value, silent) {\n  var index = -1;\n  var length = value.length + 1;\n  var subvalue = '';\n  var character;\n  var marker;\n  var markerCount;\n  var queue;\n  while (++index < length) {\n    character = value.charAt(index);\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n    subvalue += character;\n  }\n  if (character !== C_ASTERISK && character !== C_DASH && character !== C_UNDERSCORE) {\n    return;\n  }\n  marker = character;\n  subvalue += character;\n  markerCount = 1;\n  queue = '';\n  while (++index < length) {\n    character = value.charAt(index);\n    if (character === marker) {\n      markerCount++;\n      subvalue += queue + marker;\n      queue = '';\n    } else if (character === C_SPACE) {\n      queue += character;\n    } else if (markerCount >= THEMATIC_BREAK_MARKER_COUNT && (!character || character === C_NEWLINE)) {\n      subvalue += queue;\n      if (silent) {\n        return true;\n      }\n      return eat(subvalue)({\n        type: 'thematicBreak'\n      });\n    } else {\n      return;\n    }\n  }\n}","'use strict';\n\nvar decode = require('parse-entities');\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/url');\nmodule.exports = url;\nurl.locator = locate;\nurl.notInLink = true;\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\nvar C_PAREN_OPEN = '(';\nvar C_PAREN_CLOSE = ')';\nvar C_LT = '<';\nvar C_AT_SIGN = '@';\nvar HTTP_PROTOCOL = 'http://';\nvar HTTPS_PROTOCOL = 'https://';\nvar MAILTO_PROTOCOL = 'mailto:';\nvar PROTOCOLS = [HTTP_PROTOCOL, HTTPS_PROTOCOL, MAILTO_PROTOCOL];\nvar PROTOCOLS_LENGTH = PROTOCOLS.length;\nfunction url(eat, value, silent) {\n  var self = this;\n  var subvalue;\n  var content;\n  var character;\n  var index;\n  var position;\n  var protocol;\n  var match;\n  var length;\n  var queue;\n  var parenCount;\n  var nextCharacter;\n  var exit;\n  if (!self.options.gfm) {\n    return;\n  }\n  subvalue = '';\n  index = -1;\n  length = PROTOCOLS_LENGTH;\n  while (++index < length) {\n    protocol = PROTOCOLS[index];\n    match = value.slice(0, protocol.length);\n    if (match.toLowerCase() === protocol) {\n      subvalue = match;\n      break;\n    }\n  }\n  if (!subvalue) {\n    return;\n  }\n  index = subvalue.length;\n  length = value.length;\n  queue = '';\n  parenCount = 0;\n  while (index < length) {\n    character = value.charAt(index);\n    if (whitespace(character) || character === C_LT) {\n      break;\n    }\n    if (character === '.' || character === ',' || character === ':' || character === ';' || character === '\"' || character === '\\'' || character === ')' || character === ']') {\n      nextCharacter = value.charAt(index + 1);\n      if (!nextCharacter || whitespace(nextCharacter)) {\n        break;\n      }\n    }\n    if (character === C_PAREN_OPEN || character === C_BRACKET_OPEN) {\n      parenCount++;\n    }\n    if (character === C_PAREN_CLOSE || character === C_BRACKET_CLOSE) {\n      parenCount--;\n      if (parenCount < 0) {\n        break;\n      }\n    }\n    queue += character;\n    index++;\n  }\n  if (!queue) {\n    return;\n  }\n  subvalue += queue;\n  content = subvalue;\n  if (protocol === MAILTO_PROTOCOL) {\n    position = queue.indexOf(C_AT_SIGN);\n    if (position === -1 || position === length - 1) {\n      return;\n    }\n    content = content.substr(MAILTO_PROTOCOL.length);\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n  exit = self.enterLink();\n  content = self.tokenizeInline(content, eat.now());\n  exit();\n  return eat(subvalue)({\n    type: 'link',\n    title: null,\n    url: decode(subvalue, {\n      nonTerminated: false\n    }),\n    children: content\n  });\n}","'use strict';\n\nmodule.exports = factory;\nvar MERGEABLE_NODES = {\n  text: mergeText,\n  blockquote: mergeBlockquote\n};\n\n/* Check whether a node is mergeable with adjacent nodes. */\nfunction mergeable(node) {\n  var start;\n  var end;\n  if (node.type !== 'text' || !node.position) {\n    return true;\n  }\n  start = node.position.start;\n  end = node.position.end;\n\n  /* Only merge nodes which occupy the same size as their\n   * `value`. */\n  return start.line !== end.line || end.column - start.column === node.value.length;\n}\n\n/* Merge two text nodes: `node` into `prev`. */\nfunction mergeText(prev, node) {\n  prev.value += node.value;\n  return prev;\n}\n\n/* Merge two blockquotes: `node` into `prev`, unless in\n * CommonMark mode. */\nfunction mergeBlockquote(prev, node) {\n  if (this.options.commonmark) {\n    return node;\n  }\n  prev.children = prev.children.concat(node.children);\n  return prev;\n}\n\n/* Construct a tokenizer.  This creates both\n * `tokenizeInline` and `tokenizeBlock`. */\nfunction factory(type) {\n  return tokenize;\n\n  /* Tokenizer for a bound `type`. */\n  function tokenize(value, location) {\n    var self = this;\n    var offset = self.offset;\n    var tokens = [];\n    var methods = self[type + 'Methods'];\n    var tokenizers = self[type + 'Tokenizers'];\n    var line = location.line;\n    var column = location.column;\n    var index;\n    var length;\n    var method;\n    var name;\n    var matched;\n    var valueLength;\n\n    /* Trim white space only lines. */\n    if (!value) {\n      return tokens;\n    }\n\n    /* Expose on `eat`. */\n    eat.now = now;\n    eat.file = self.file;\n\n    /* Sync initial offset. */\n    updatePosition('');\n\n    /* Iterate over `value`, and iterate over all\n     * tokenizers.  When one eats something, re-iterate\n     * with the remaining value.  If no tokenizer eats,\n     * something failed (should not happen) and an\n     * exception is thrown. */\n    while (value) {\n      index = -1;\n      length = methods.length;\n      matched = false;\n      while (++index < length) {\n        name = methods[index];\n        method = tokenizers[name];\n        if (method && ( /* istanbul ignore next */!method.onlyAtStart || self.atStart) && (!method.notInList || !self.inList) && (!method.notInBlock || !self.inBlock) && (!method.notInLink || !self.inLink)) {\n          valueLength = value.length;\n          method.apply(self, [eat, value]);\n          matched = valueLength !== value.length;\n          if (matched) {\n            break;\n          }\n        }\n      }\n\n      /* istanbul ignore if */\n      if (!matched) {\n        self.file.fail(new Error('Infinite loop'), eat.now());\n      }\n    }\n    self.eof = now();\n    return tokens;\n\n    /* Update line, column, and offset based on\n     * `value`. */\n    function updatePosition(subvalue) {\n      var lastIndex = -1;\n      var index = subvalue.indexOf('\\n');\n      while (index !== -1) {\n        line++;\n        lastIndex = index;\n        index = subvalue.indexOf('\\n', index + 1);\n      }\n      if (lastIndex === -1) {\n        column += subvalue.length;\n      } else {\n        column = subvalue.length - lastIndex;\n      }\n      if (line in offset) {\n        if (lastIndex !== -1) {\n          column += offset[line];\n        } else if (column <= offset[line]) {\n          column = offset[line] + 1;\n        }\n      }\n    }\n\n    /* Get offset.  Called before the first character is\n     * eaten to retrieve the range's offsets. */\n    function getOffset() {\n      var indentation = [];\n      var pos = line + 1;\n\n      /* Done.  Called when the last character is\n       * eaten to retrieve the range’s offsets. */\n      return function () {\n        var last = line + 1;\n        while (pos < last) {\n          indentation.push((offset[pos] || 0) + 1);\n          pos++;\n        }\n        return indentation;\n      };\n    }\n\n    /* Get the current position. */\n    function now() {\n      var pos = {\n        line: line,\n        column: column\n      };\n      pos.offset = self.toOffset(pos);\n      return pos;\n    }\n\n    /* Store position information for a node. */\n    function Position(start) {\n      this.start = start;\n      this.end = now();\n    }\n\n    /* Throw when a value is incorrectly eaten.\n     * This shouldn’t happen but will throw on new,\n     * incorrect rules. */\n    function validateEat(subvalue) {\n      /* istanbul ignore if */\n      if (value.substring(0, subvalue.length) !== subvalue) {\n        /* Capture stack-trace. */\n        self.file.fail(new Error('Incorrectly eaten value: please report this ' + 'warning on http://git.io/vg5Ft'), now());\n      }\n    }\n\n    /* Mark position and patch `node.position`. */\n    function position() {\n      var before = now();\n      return update;\n\n      /* Add the position to a node. */\n      function update(node, indent) {\n        var prev = node.position;\n        var start = prev ? prev.start : before;\n        var combined = [];\n        var n = prev && prev.end.line;\n        var l = before.line;\n        node.position = new Position(start);\n\n        /* If there was already a `position`, this\n         * node was merged.  Fixing `start` wasn’t\n         * hard, but the indent is different.\n         * Especially because some information, the\n         * indent between `n` and `l` wasn’t\n         * tracked.  Luckily, that space is\n         * (should be?) empty, so we can safely\n         * check for it now. */\n        if (prev && indent && prev.indent) {\n          combined = prev.indent;\n          if (n < l) {\n            while (++n < l) {\n              combined.push((offset[n] || 0) + 1);\n            }\n            combined.push(before.column);\n          }\n          indent = combined.concat(indent);\n        }\n        node.position.indent = indent || [];\n        return node;\n      }\n    }\n\n    /* Add `node` to `parent`s children or to `tokens`.\n     * Performs merges where possible. */\n    function add(node, parent) {\n      var children = parent ? parent.children : tokens;\n      var prev = children[children.length - 1];\n      if (prev && node.type === prev.type && node.type in MERGEABLE_NODES && mergeable(prev) && mergeable(node)) {\n        node = MERGEABLE_NODES[node.type].call(self, prev, node);\n      }\n      if (node !== prev) {\n        children.push(node);\n      }\n      if (self.atStart && tokens.length !== 0) {\n        self.exitStart();\n      }\n      return node;\n    }\n\n    /* Remove `subvalue` from `value`.\n     * `subvalue` must be at the start of `value`. */\n    function eat(subvalue) {\n      var indent = getOffset();\n      var pos = position();\n      var current = now();\n      validateEat(subvalue);\n      apply.reset = reset;\n      reset.test = test;\n      apply.test = test;\n      value = value.substring(subvalue.length);\n      updatePosition(subvalue);\n      indent = indent();\n      return apply;\n\n      /* Add the given arguments, add `position` to\n       * the returned node, and return the node. */\n      function apply(node, parent) {\n        return pos(add(pos(node), parent), indent);\n      }\n\n      /* Functions just like apply, but resets the\n       * content:  the line and column are reversed,\n       * and the eaten value is re-added.\n       * This is useful for nodes with a single\n       * type of content, such as lists and tables.\n       * See `apply` above for what parameters are\n       * expected. */\n      function reset() {\n        var node = apply.apply(null, arguments);\n        line = current.line;\n        column = current.column;\n        value = subvalue + value;\n        return node;\n      }\n\n      /* Test the position, after eating, and reverse\n       * to a not-eaten state. */\n      function test() {\n        var result = pos({});\n        line = current.line;\n        column = current.column;\n        value = subvalue + value;\n        return result.position;\n      }\n    }\n  }\n}","'use strict';\n\nmodule.exports = factory;\n\n/* Factory to de-escape a value, based on a list at `key`\n * in `ctx`. */\nfunction factory(ctx, key) {\n  return unescape;\n\n  /* De-escape a string using the expression at `key`\n   * in `ctx`. */\n  function unescape(value) {\n    var prev = 0;\n    var index = value.indexOf('\\\\');\n    var escape = ctx[key];\n    var queue = [];\n    var character;\n    while (index !== -1) {\n      queue.push(value.slice(prev, index));\n      prev = index + 1;\n      character = value.charAt(prev);\n\n      /* If the following character is not a valid escape,\n       * add the slash. */\n      if (!character || escape.indexOf(character) === -1) {\n        queue.push('\\\\');\n      }\n      index = value.indexOf('\\\\', prev);\n    }\n    queue.push(value.slice(prev));\n    return queue.join('');\n  }\n}","'use strict';\n\nmodule.exports = indentation;\n\n/* Map of characters, and their column length,\n * which can be used as indentation. */\nvar characters = {\n  ' ': 1,\n  '\\t': 4\n};\n\n/* Gets indentation information for a line. */\nfunction indentation(value) {\n  var index = 0;\n  var indent = 0;\n  var character = value.charAt(index);\n  var stops = {};\n  var size;\n  while (character in characters) {\n    size = characters[character];\n    indent += size;\n    if (size > 1) {\n      indent = Math.floor(indent / size) * size;\n    }\n    stops[indent] = index;\n    character = value.charAt(++index);\n  }\n  return {\n    indent: indent,\n    stops: stops\n  };\n}","'use strict';\n\nvar attributeName = '[a-zA-Z_:][a-zA-Z0-9:._-]*';\nvar unquoted = '[^\"\\'=<>`\\\\u0000-\\\\u0020]+';\nvar singleQuoted = '\\'[^\\']*\\'';\nvar doubleQuoted = '\"[^\"]*\"';\nvar attributeValue = '(?:' + unquoted + '|' + singleQuoted + '|' + doubleQuoted + ')';\nvar attribute = '(?:\\\\s+' + attributeName + '(?:\\\\s*=\\\\s*' + attributeValue + ')?)';\nvar openTag = '<[A-Za-z][A-Za-z0-9\\\\-]*' + attribute + '*\\\\s*\\\\/?>';\nvar closeTag = '<\\\\/[A-Za-z][A-Za-z0-9\\\\-]*\\\\s*>';\nvar comment = '<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->';\nvar processing = '<[?].*?[?]>';\nvar declaration = '<![A-Za-z]+\\\\s+[^>]*>';\nvar cdata = '<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]>';\nexports.openCloseTag = new RegExp('^(?:' + openTag + '|' + closeTag + ')');\nexports.tag = new RegExp('^(?:' + openTag + '|' + closeTag + '|' + comment + '|' + processing + '|' + declaration + '|' + cdata + ')');","'use strict';\n\nmodule.exports = interrupt;\nfunction interrupt(interruptors, tokenizers, ctx, params) {\n  var bools = ['pedantic', 'commonmark'];\n  var count = bools.length;\n  var length = interruptors.length;\n  var index = -1;\n  var interruptor;\n  var config;\n  var fn;\n  var offset;\n  var bool;\n  var ignore;\n  while (++index < length) {\n    interruptor = interruptors[index];\n    config = interruptor[1] || {};\n    fn = interruptor[0];\n    offset = -1;\n    ignore = false;\n    while (++offset < count) {\n      bool = bools[offset];\n      if (config[bool] !== undefined && config[bool] !== ctx.options[bool]) {\n        ignore = true;\n        break;\n      }\n    }\n    if (ignore) {\n      continue;\n    }\n    if (tokenizers[fn].apply(ctx, params)) {\n      return true;\n    }\n  }\n  return false;\n}","'use strict';\n\nvar collapseWhiteSpace = require('collapse-white-space');\nmodule.exports = normalize;\n\n/* Normalize an identifier.  Collapses multiple white space\n * characters into a single space, and removes casing. */\nfunction normalize(value) {\n  return collapseWhiteSpace(value).toLowerCase();\n}","'use strict';\n\nvar trim = require('trim');\nvar repeat = require('repeat-string');\nvar getIndent = require('./get-indentation');\nmodule.exports = indentation;\nvar C_SPACE = ' ';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\n\n/* Remove the minimum indent from every line in `value`.\n * Supports both tab, spaced, and mixed indentation (as\n * well as possible). */\nfunction indentation(value, maximum) {\n  var values = value.split(C_NEWLINE);\n  var position = values.length + 1;\n  var minIndent = Infinity;\n  var matrix = [];\n  var index;\n  var indentation;\n  var stops;\n  var padding;\n  values.unshift(repeat(C_SPACE, maximum) + '!');\n  while (position--) {\n    indentation = getIndent(values[position]);\n    matrix[position] = indentation.stops;\n    if (trim(values[position]).length === 0) {\n      continue;\n    }\n    if (indentation.indent) {\n      if (indentation.indent > 0 && indentation.indent < minIndent) {\n        minIndent = indentation.indent;\n      }\n    } else {\n      minIndent = Infinity;\n      break;\n    }\n  }\n  if (minIndent !== Infinity) {\n    position = values.length;\n    while (position--) {\n      stops = matrix[position];\n      index = minIndent;\n      while (index && !(index in stops)) {\n        index--;\n      }\n      if (trim(values[position]).length !== 0 && minIndent && index !== minIndent) {\n        padding = C_TAB;\n      } else {\n        padding = '';\n      }\n      values[position] = padding + values[position].slice(index in stops ? stops[index] + 1 : 0);\n    }\n  }\n  values.shift();\n  return values.join(C_NEWLINE);\n}","'use strict';\n\n/* Dependencies. */\nvar extend = require('extend');\nvar bail = require('bail');\nvar vfile = require('vfile');\nvar trough = require('trough');\nvar string = require('x-is-string');\nvar plain = require('is-plain-obj');\n\n/* Expose a frozen processor. */\nmodule.exports = unified().freeze();\nvar slice = [].slice;\nvar own = {}.hasOwnProperty;\n\n/* Process pipeline. */\nvar pipeline = trough().use(pipelineParse).use(pipelineRun).use(pipelineStringify);\nfunction pipelineParse(p, ctx) {\n  ctx.tree = p.parse(ctx.file);\n}\nfunction pipelineRun(p, ctx, next) {\n  p.run(ctx.tree, ctx.file, done);\n  function done(err, tree, file) {\n    if (err) {\n      next(err);\n    } else {\n      ctx.tree = tree;\n      ctx.file = file;\n      next();\n    }\n  }\n}\nfunction pipelineStringify(p, ctx) {\n  ctx.file.contents = p.stringify(ctx.tree, ctx.file);\n}\n\n/* Function to create the first processor. */\nfunction unified() {\n  var attachers = [];\n  var transformers = trough();\n  var namespace = {};\n  var frozen = false;\n  var freezeIndex = -1;\n\n  /* Data management. */\n  processor.data = data;\n\n  /* Lock. */\n  processor.freeze = freeze;\n\n  /* Plug-ins. */\n  processor.attachers = attachers;\n  processor.use = use;\n\n  /* API. */\n  processor.parse = parse;\n  processor.stringify = stringify;\n  processor.run = run;\n  processor.runSync = runSync;\n  processor.process = process;\n  processor.processSync = processSync;\n\n  /* Expose. */\n  return processor;\n\n  /* Create a new processor based on the processor\n   * in the current scope. */\n  function processor() {\n    var destination = unified();\n    var length = attachers.length;\n    var index = -1;\n    while (++index < length) {\n      destination.use.apply(null, attachers[index]);\n    }\n    destination.data(extend(true, {}, namespace));\n    return destination;\n  }\n\n  /* Freeze: used to signal a processor that has finished\n   * configuration.\n   *\n   * For example, take unified itself.  It’s frozen.\n   * Plug-ins should not be added to it.  Rather, it should\n   * be extended, by invoking it, before modifying it.\n   *\n   * In essence, always invoke this when exporting a\n   * processor. */\n  function freeze() {\n    var values;\n    var plugin;\n    var options;\n    var transformer;\n    if (frozen) {\n      return processor;\n    }\n    while (++freezeIndex < attachers.length) {\n      values = attachers[freezeIndex];\n      plugin = values[0];\n      options = values[1];\n      transformer = null;\n      if (options === false) {\n        continue;\n      }\n      if (options === true) {\n        values[1] = undefined;\n      }\n      transformer = plugin.apply(processor, values.slice(1));\n      if (typeof transformer === 'function') {\n        transformers.use(transformer);\n      }\n    }\n    frozen = true;\n    freezeIndex = Infinity;\n    return processor;\n  }\n\n  /* Data management.\n   * Getter / setter for processor-specific informtion. */\n  function data(key, value) {\n    if (string(key)) {\n      /* Set `key`. */\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen);\n        namespace[key] = value;\n        return processor;\n      }\n\n      /* Get `key`. */\n      return own.call(namespace, key) && namespace[key] || null;\n    }\n\n    /* Set space. */\n    if (key) {\n      assertUnfrozen('data', frozen);\n      namespace = key;\n      return processor;\n    }\n\n    /* Get space. */\n    return namespace;\n  }\n\n  /* Plug-in management.\n   *\n   * Pass it:\n   * *   an attacher and options,\n   * *   a preset,\n   * *   a list of presets, attachers, and arguments (list\n   *     of attachers and options). */\n  function use(value) {\n    var settings;\n    assertUnfrozen('use', frozen);\n    if (value === null || value === undefined) {\n      /* Empty */\n    } else if (typeof value === 'function') {\n      addPlugin.apply(null, arguments);\n    } else if (typeof value === 'object') {\n      if ('length' in value) {\n        addList(value);\n      } else {\n        addPreset(value);\n      }\n    } else {\n      throw new Error('Expected usable value, not `' + value + '`');\n    }\n    if (settings) {\n      namespace.settings = extend(namespace.settings || {}, settings);\n    }\n    return processor;\n    function addPreset(result) {\n      addList(result.plugins);\n      if (result.settings) {\n        settings = extend(settings || {}, result.settings);\n      }\n    }\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value);\n      } else if (typeof value === 'object') {\n        if ('length' in value) {\n          addPlugin.apply(null, value);\n        } else {\n          addPreset(value);\n        }\n      } else {\n        throw new Error('Expected usable value, not `' + value + '`');\n      }\n    }\n    function addList(plugins) {\n      var length;\n      var index;\n      if (plugins === null || plugins === undefined) {\n        /* Empty */\n      } else if (typeof plugins === 'object' && 'length' in plugins) {\n        length = plugins.length;\n        index = -1;\n        while (++index < length) {\n          add(plugins[index]);\n        }\n      } else {\n        throw new Error('Expected a list of plugins, not `' + plugins + '`');\n      }\n    }\n    function addPlugin(plugin, value) {\n      var entry = find(plugin);\n      if (entry) {\n        if (plain(entry[1]) && plain(value)) {\n          value = extend(entry[1], value);\n        }\n        entry[1] = value;\n      } else {\n        attachers.push(slice.call(arguments));\n      }\n    }\n  }\n  function find(plugin) {\n    var length = attachers.length;\n    var index = -1;\n    var entry;\n    while (++index < length) {\n      entry = attachers[index];\n      if (entry[0] === plugin) {\n        return entry;\n      }\n    }\n  }\n\n  /* Parse a file (in string or VFile representation)\n   * into a Unist node using the `Parser` on the\n   * processor. */\n  function parse(doc) {\n    var file = vfile(doc);\n    var Parser;\n    freeze();\n    Parser = processor.Parser;\n    assertParser('parse', Parser);\n    if (newable(Parser)) {\n      return new Parser(String(file), file).parse();\n    }\n    return Parser(String(file), file); // eslint-disable-line new-cap\n  }\n\n  /* Run transforms on a Unist node representation of a file\n   * (in string or VFile representation), async. */\n  function run(node, file, cb) {\n    assertNode(node);\n    freeze();\n    if (!cb && typeof file === 'function') {\n      cb = file;\n      file = null;\n    }\n    if (!cb) {\n      return new Promise(executor);\n    }\n    executor(null, cb);\n    function executor(resolve, reject) {\n      transformers.run(node, vfile(file), done);\n      function done(err, tree, file) {\n        tree = tree || node;\n        if (err) {\n          reject(err);\n        } else if (resolve) {\n          resolve(tree);\n        } else {\n          cb(null, tree, file);\n        }\n      }\n    }\n  }\n\n  /* Run transforms on a Unist node representation of a file\n   * (in string or VFile representation), sync. */\n  function runSync(node, file) {\n    var complete = false;\n    var result;\n    run(node, file, done);\n    assertDone('runSync', 'run', complete);\n    return result;\n    function done(err, tree) {\n      complete = true;\n      bail(err);\n      result = tree;\n    }\n  }\n\n  /* Stringify a Unist node representation of a file\n   * (in string or VFile representation) into a string\n   * using the `Compiler` on the processor. */\n  function stringify(node, doc) {\n    var file = vfile(doc);\n    var Compiler;\n    freeze();\n    Compiler = processor.Compiler;\n    assertCompiler('stringify', Compiler);\n    assertNode(node);\n    if (newable(Compiler)) {\n      return new Compiler(node, file).compile();\n    }\n    return Compiler(node, file); // eslint-disable-line new-cap\n  }\n\n  /* Parse a file (in string or VFile representation)\n   * into a Unist node using the `Parser` on the processor,\n   * then run transforms on that node, and compile the\n   * resulting node using the `Compiler` on the processor,\n   * and store that result on the VFile. */\n  function process(doc, cb) {\n    freeze();\n    assertParser('process', processor.Parser);\n    assertCompiler('process', processor.Compiler);\n    if (!cb) {\n      return new Promise(executor);\n    }\n    executor(null, cb);\n    function executor(resolve, reject) {\n      var file = vfile(doc);\n      pipeline.run(processor, {\n        file: file\n      }, done);\n      function done(err) {\n        if (err) {\n          reject(err);\n        } else if (resolve) {\n          resolve(file);\n        } else {\n          cb(null, file);\n        }\n      }\n    }\n  }\n\n  /* Process the given document (in string or VFile\n   * representation), sync. */\n  function processSync(doc) {\n    var complete = false;\n    var file;\n    freeze();\n    assertParser('processSync', processor.Parser);\n    assertCompiler('processSync', processor.Compiler);\n    file = vfile(doc);\n    process(file, done);\n    assertDone('processSync', 'process', complete);\n    return file;\n    function done(err) {\n      complete = true;\n      bail(err);\n    }\n  }\n}\n\n/* Check if `func` is a constructor. */\nfunction newable(value) {\n  return typeof value === 'function' && keys(value.prototype);\n}\n\n/* Check if `value` is an object with keys. */\nfunction keys(value) {\n  var key;\n  for (key in value) {\n    return true;\n  }\n  return false;\n}\n\n/* Assert a parser is available. */\nfunction assertParser(name, Parser) {\n  if (typeof Parser !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Parser`');\n  }\n}\n\n/* Assert a compiler is available. */\nfunction assertCompiler(name, Compiler) {\n  if (typeof Compiler !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Compiler`');\n  }\n}\n\n/* Assert the processor is not frozen. */\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error(['Cannot invoke `' + name + '` on a frozen processor.\\nCreate a new ', 'processor first, by invoking it: use `processor()` instead of ', '`processor`.'].join(''));\n  }\n}\n\n/* Assert `node` is a Unist node. */\nfunction assertNode(node) {\n  if (!node || !string(node.type)) {\n    throw new Error('Expected node, got `' + node + '`');\n  }\n}\n\n/* Assert that `complete` is `true`. */\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error('`' + name + '` finished async. Use `' + asyncName + '` instead');\n  }\n}","'use strict';\n\nmodule.exports = convert;\nfunction convert(test) {\n  if (typeof test === 'string') {\n    return typeFactory(test);\n  }\n  if (test === null || test === undefined) {\n    return ok;\n  }\n  if (typeof test === 'object') {\n    return ('length' in test ? anyFactory : matchesFactory)(test);\n  }\n  if (typeof test === 'function') {\n    return test;\n  }\n  throw new Error('Expected function, string, or object as test');\n}\nfunction convertAll(tests) {\n  var results = [];\n  var length = tests.length;\n  var index = -1;\n  while (++index < length) {\n    results[index] = convert(tests[index]);\n  }\n  return results;\n}\n\n// Utility assert each property in `test` is represented in `node`, and each\n// values are strictly equal.\nfunction matchesFactory(test) {\n  return matches;\n  function matches(node) {\n    var key;\n    for (key in test) {\n      if (node[key] !== test[key]) {\n        return false;\n      }\n    }\n    return true;\n  }\n}\nfunction anyFactory(tests) {\n  var checks = convertAll(tests);\n  var length = checks.length;\n  return matches;\n  function matches() {\n    var index = -1;\n    while (++index < length) {\n      if (checks[index].apply(this, arguments)) {\n        return true;\n      }\n    }\n    return false;\n  }\n}\n\n// Utility to convert a string into a function which checks a given node’s type\n// for said string.\nfunction typeFactory(test) {\n  return type;\n  function type(node) {\n    return Boolean(node && node.type === test);\n  }\n}\n\n// Utility to return true.\nfunction ok() {\n  return true;\n}","'use strict';\n\nvar visit = require('unist-util-visit');\nmodule.exports = removePosition;\nfunction removePosition(node, force) {\n  visit(node, force ? hard : soft);\n  return node;\n}\nfunction hard(node) {\n  delete node.position;\n}\nfunction soft(node) {\n  node.position = undefined;\n}","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = stringify;\nfunction stringify(value) {\n  /* Nothing. */\n  if (!value || typeof value !== 'object') {\n    return null;\n  }\n\n  /* Node. */\n  if (own.call(value, 'position') || own.call(value, 'type')) {\n    return position(value.position);\n  }\n\n  /* Position. */\n  if (own.call(value, 'start') || own.call(value, 'end')) {\n    return position(value);\n  }\n\n  /* Point. */\n  if (own.call(value, 'line') || own.call(value, 'column')) {\n    return point(value);\n  }\n\n  /* ? */\n  return null;\n}\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {};\n  }\n  return index(point.line) + ':' + index(point.column);\n}\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {};\n  }\n  return point(pos.start) + '-' + point(pos.end);\n}\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1;\n}","'use strict';\n\nmodule.exports = visitParents;\nvar convert = require('unist-util-is/convert');\nvar CONTINUE = true;\nvar SKIP = 'skip';\nvar EXIT = false;\nvisitParents.CONTINUE = CONTINUE;\nvisitParents.SKIP = SKIP;\nvisitParents.EXIT = EXIT;\nfunction visitParents(tree, test, visitor, reverse) {\n  var is;\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n  is = convert(test);\n  one(tree, null, []);\n\n  // Visit a single node.\n  function one(node, index, parents) {\n    var result = [];\n    var subresult;\n    if (!test || is(node, index, parents[parents.length - 1] || null)) {\n      result = toResult(visitor(node, parents));\n      if (result[0] === EXIT) {\n        return result;\n      }\n    }\n    if (node.children && result[0] !== SKIP) {\n      subresult = toResult(all(node.children, parents.concat(node)));\n      return subresult[0] === EXIT ? subresult : result;\n    }\n    return result;\n  }\n\n  // Visit children in `parent`.\n  function all(children, parents) {\n    var min = -1;\n    var step = reverse ? -1 : 1;\n    var index = (reverse ? children.length : min) + step;\n    var result;\n    while (index > min && index < children.length) {\n      result = one(children[index], index, parents);\n      if (result[0] === EXIT) {\n        return result;\n      }\n      index = typeof result[1] === 'number' ? result[1] : index + step;\n    }\n  }\n}\nfunction toResult(value) {\n  if (value !== null && typeof value === 'object' && 'length' in value) {\n    return value;\n  }\n  if (typeof value === 'number') {\n    return [CONTINUE, value];\n  }\n  return [value];\n}","'use strict';\n\nmodule.exports = visit;\nvar visitParents = require('unist-util-visit-parents');\nvar CONTINUE = visitParents.CONTINUE;\nvar SKIP = visitParents.SKIP;\nvar EXIT = visitParents.EXIT;\nvisit.CONTINUE = CONTINUE;\nvisit.SKIP = SKIP;\nvisit.EXIT = EXIT;\nfunction visit(tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n  visitParents(tree, test, overload, reverse);\n  function overload(node, parents) {\n    var parent = parents[parents.length - 1];\n    var index = parent ? parent.children.indexOf(node) : null;\n    return visitor(node, index, parent);\n  }\n}","'use strict';\n\nvar stringify = require('unist-util-stringify-position');\nmodule.exports = VMessage;\n\n// Inherit from `Error#`.\nfunction VMessagePrototype() {}\nVMessagePrototype.prototype = Error.prototype;\nVMessage.prototype = new VMessagePrototype();\n\n// Message properties.\nvar proto = VMessage.prototype;\nproto.file = '';\nproto.name = '';\nproto.reason = '';\nproto.message = '';\nproto.stack = '';\nproto.fatal = null;\nproto.column = null;\nproto.line = null;\n\n// Construct a new VMessage.\n//\n// Note: We cannot invoke `Error` on the created context, as that adds readonly\n// `line` and `column` attributes on Safari 9, thus throwing and failing the\n// data.\nfunction VMessage(reason, position, origin) {\n  var parts;\n  var range;\n  var location;\n  if (typeof position === 'string') {\n    origin = position;\n    position = null;\n  }\n  parts = parseOrigin(origin);\n  range = stringify(position) || '1:1';\n  location = {\n    start: {\n      line: null,\n      column: null\n    },\n    end: {\n      line: null,\n      column: null\n    }\n  };\n\n  // Node.\n  if (position && position.position) {\n    position = position.position;\n  }\n  if (position) {\n    // Position.\n    if (position.start) {\n      location = position;\n      position = position.start;\n    } else {\n      // Point.\n      location.start = position;\n    }\n  }\n  if (reason.stack) {\n    this.stack = reason.stack;\n    reason = reason.message;\n  }\n  this.message = reason;\n  this.name = range;\n  this.reason = reason;\n  this.line = position ? position.line : null;\n  this.column = position ? position.column : null;\n  this.location = location;\n  this.source = parts[0];\n  this.ruleId = parts[1];\n}\nfunction parseOrigin(origin) {\n  var result = [null, null];\n  var index;\n  if (typeof origin === 'string') {\n    index = origin.indexOf(':');\n    if (index === -1) {\n      result[1] = origin;\n    } else {\n      result[0] = origin.slice(0, index);\n      result[1] = origin.slice(index + 1);\n    }\n  }\n  return result;\n}","'use strict';\n\nvar path = require('path');\nvar replace = require('replace-ext');\nvar buffer = require('is-buffer');\nmodule.exports = VFile;\nvar own = {}.hasOwnProperty;\nvar proto = VFile.prototype;\nproto.toString = toString;\n\n/* Order of setting (least specific to most), we need this because\n * otherwise `{stem: 'a', path: '~/b.js'}` would throw, as a path\n * is needed before a stem can be set. */\nvar order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];\n\n/* Construct a new file. */\nfunction VFile(options) {\n  var prop;\n  var index;\n  var length;\n  if (!options) {\n    options = {};\n  } else if (typeof options === 'string' || buffer(options)) {\n    options = {\n      contents: options\n    };\n  } else if ('message' in options && 'messages' in options) {\n    return options;\n  }\n  if (!(this instanceof VFile)) {\n    return new VFile(options);\n  }\n  this.data = {};\n  this.messages = [];\n  this.history = [];\n  this.cwd = process.cwd();\n\n  /* Set path related properties in the correct order. */\n  index = -1;\n  length = order.length;\n  while (++index < length) {\n    prop = order[index];\n    if (own.call(options, prop)) {\n      this[prop] = options[prop];\n    }\n  }\n\n  /* Set non-path related properties. */\n  for (prop in options) {\n    if (order.indexOf(prop) === -1) {\n      this[prop] = options[prop];\n    }\n  }\n}\n\n/* Access full path (`~/index.min.js`). */\nObject.defineProperty(proto, 'path', {\n  get: function () {\n    return this.history[this.history.length - 1];\n  },\n  set: function (path) {\n    assertNonEmpty(path, 'path');\n    if (path !== this.path) {\n      this.history.push(path);\n    }\n  }\n});\n\n/* Access parent path (`~`). */\nObject.defineProperty(proto, 'dirname', {\n  get: function () {\n    return typeof this.path === 'string' ? path.dirname(this.path) : undefined;\n  },\n  set: function (dirname) {\n    assertPath(this.path, 'dirname');\n    this.path = path.join(dirname || '', this.basename);\n  }\n});\n\n/* Access basename (`index.min.js`). */\nObject.defineProperty(proto, 'basename', {\n  get: function () {\n    return typeof this.path === 'string' ? path.basename(this.path) : undefined;\n  },\n  set: function (basename) {\n    assertNonEmpty(basename, 'basename');\n    assertPart(basename, 'basename');\n    this.path = path.join(this.dirname || '', basename);\n  }\n});\n\n/* Access extname (`.js`). */\nObject.defineProperty(proto, 'extname', {\n  get: function () {\n    return typeof this.path === 'string' ? path.extname(this.path) : undefined;\n  },\n  set: function (extname) {\n    var ext = extname || '';\n    assertPart(ext, 'extname');\n    assertPath(this.path, 'extname');\n    if (ext) {\n      if (ext.charAt(0) !== '.') {\n        throw new Error('`extname` must start with `.`');\n      }\n      if (ext.indexOf('.', 1) !== -1) {\n        throw new Error('`extname` cannot contain multiple dots');\n      }\n    }\n    this.path = replace(this.path, ext);\n  }\n});\n\n/* Access stem (`index.min`). */\nObject.defineProperty(proto, 'stem', {\n  get: function () {\n    return typeof this.path === 'string' ? path.basename(this.path, this.extname) : undefined;\n  },\n  set: function (stem) {\n    assertNonEmpty(stem, 'stem');\n    assertPart(stem, 'stem');\n    this.path = path.join(this.dirname || '', stem + (this.extname || ''));\n  }\n});\n\n/* Get the value of the file. */\nfunction toString(encoding) {\n  var value = this.contents || '';\n  return buffer(value) ? value.toString(encoding) : String(value);\n}\n\n/* Assert that `part` is not a path (i.e., does\n * not contain `path.sep`). */\nfunction assertPart(part, name) {\n  if (part.indexOf(path.sep) !== -1) {\n    throw new Error('`' + name + '` cannot be a path: did not expect `' + path.sep + '`');\n  }\n}\n\n/* Assert that `part` is not empty. */\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty');\n  }\n}\n\n/* Assert `path` exists. */\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too');\n  }\n}","'use strict';\n\nvar VMessage = require('vfile-message');\nvar VFile = require('./core.js');\nmodule.exports = VFile;\nvar proto = VFile.prototype;\nproto.message = message;\nproto.info = info;\nproto.fail = fail;\n\n/* Slight backwards compatibility.  Remove in the future. */\nproto.warn = message;\n\n/* Create a message with `reason` at `position`.\n * When an error is passed in as `reason`, copies the stack. */\nfunction message(reason, position, origin) {\n  var filePath = this.path;\n  var message = new VMessage(reason, position, origin);\n  if (filePath) {\n    message.name = filePath + ':' + message.name;\n    message.file = filePath;\n  }\n  message.fatal = false;\n  this.messages.push(message);\n  return message;\n}\n\n/* Fail. Creates a vmessage, associates it with the file,\n * and throws it. */\nfunction fail() {\n  var message = this.message.apply(this, arguments);\n  message.fatal = true;\n  throw message;\n}\n\n/* Info. Creates a vmessage, associates it with the file,\n * and marks the fatality as null. */\nfunction info() {\n  var message = this.message.apply(this, arguments);\n  message.fatal = null;\n  return message;\n}","/*!\n * repeat-string <https://github.com/jonschlinkert/repeat-string>\n *\n * Copyright (c) 2014-2015, Jon Schlinkert.\n * Licensed under the MIT License.\n */\n\n'use strict';\n\n/**\n * Results cache\n */\nvar res = '';\nvar cache;\n\n/**\n * Expose `repeat`\n */\n\nmodule.exports = repeat;\n\n/**\n * Repeat the given `string` the specified `number`\n * of times.\n *\n * **Example:**\n *\n * ```js\n * var repeat = require('repeat-string');\n * repeat('A', 5);\n * //=> AAAAA\n * ```\n *\n * @param {String} `string` The string to repeat\n * @param {Number} `number` The number of times to repeat the string\n * @return {String} Repeated string\n * @api public\n */\n\nfunction repeat(str, num) {\n  if (typeof str !== 'string') {\n    throw new TypeError('expected a string');\n  }\n\n  // cover common, quick use cases\n  if (num === 1) return str;\n  if (num === 2) return str + str;\n  var max = str.length * num;\n  if (cache !== str || typeof cache === 'undefined') {\n    cache = str;\n    res = '';\n  } else if (res.length >= max) {\n    return res.substr(0, max);\n  }\n  while (max > res.length && num > 1) {\n    if (num & 1) {\n      res += str;\n    }\n    num >>= 1;\n    str += str;\n  }\n  res += str;\n  res = res.substr(0, max);\n  return res;\n}","'use strict';\n\nvar path = require('path');\nfunction replaceExt(npath, ext) {\n  if (typeof npath !== 'string') {\n    return npath;\n  }\n  if (npath.length === 0) {\n    return npath;\n  }\n  var nFileName = path.basename(npath, path.extname(npath)) + ext;\n  return path.join(path.dirname(npath), nFileName);\n}\nmodule.exports = replaceExt;","'use strict';\n\nmodule.exports = factory;\n\n// Construct a state `toggler`: a function which inverses `property` in context\n// based on its current value.\n// The by `toggler` returned function restores that value.\nfunction factory(key, state, ctx) {\n  return enter;\n  function enter() {\n    var context = ctx || this;\n    var current = context[key];\n    context[key] = !state;\n    return exit;\n    function exit() {\n      context[key] = current;\n    }\n  }\n}","'use strict';\n\nmodule.exports = trimTrailingLines;\n\n// Remove final newline characters from `value`.\nfunction trimTrailingLines(value) {\n  return String(value).replace(/\\n+$/, '');\n}","exports = module.exports = trim;\nfunction trim(str) {\n  return str.replace(/^\\s*|\\s*$/g, '');\n}\nexports.left = function (str) {\n  return str.replace(/^\\s*/, '');\n};\nexports.right = function (str) {\n  return str.replace(/\\s*$/, '');\n};","'use strict';\n\nvar wrap = require('./wrap.js');\nmodule.exports = trough;\ntrough.wrap = wrap;\nvar slice = [].slice;\n\n// Create new middleware.\nfunction trough() {\n  var fns = [];\n  var middleware = {};\n  middleware.run = run;\n  middleware.use = use;\n  return middleware;\n\n  // Run `fns`.  Last argument must be a completion handler.\n  function run() {\n    var index = -1;\n    var input = slice.call(arguments, 0, -1);\n    var done = arguments[arguments.length - 1];\n    if (typeof done !== 'function') {\n      throw new Error('Expected function as last argument, not ' + done);\n    }\n    next.apply(null, [null].concat(input));\n\n    // Run the next `fn`, if any.\n    function next(err) {\n      var fn = fns[++index];\n      var params = slice.call(arguments, 0);\n      var values = params.slice(1);\n      var length = input.length;\n      var pos = -1;\n      if (err) {\n        done(err);\n        return;\n      }\n\n      // Copy non-nully input into values.\n      while (++pos < length) {\n        if (values[pos] === null || values[pos] === undefined) {\n          values[pos] = input[pos];\n        }\n      }\n      input = values;\n\n      // Next or done.\n      if (fn) {\n        wrap(fn, next).apply(null, input);\n      } else {\n        done.apply(null, [null].concat(input));\n      }\n    }\n  }\n\n  // Add `fn` to the list.\n  function use(fn) {\n    if (typeof fn !== 'function') {\n      throw new Error('Expected `fn` to be a function, not ' + fn);\n    }\n    fns.push(fn);\n    return middleware;\n  }\n}","'use strict';\n\nvar slice = [].slice;\nmodule.exports = wrap;\n\n// Wrap `fn`.\n// Can be sync or async; return a promise, receive a completion handler, return\n// new values and errors.\nfunction wrap(fn, callback) {\n  var invoked;\n  return wrapped;\n  function wrapped() {\n    var params = slice.call(arguments, 0);\n    var callback = fn.length > params.length;\n    var result;\n    if (callback) {\n      params.push(done);\n    }\n    try {\n      result = fn.apply(null, params);\n    } catch (error) {\n      // Well, this is quite the pickle.\n      // `fn` received a callback and invoked it (thus continuing the pipeline),\n      // but later also threw an error.\n      // We’re not about to restart the pipeline again, so the only thing left\n      // to do is to throw the thing instead.\n      if (callback && invoked) {\n        throw error;\n      }\n      return done(error);\n    }\n    if (!callback) {\n      if (result && typeof result.then === 'function') {\n        result.then(then, done);\n      } else if (result instanceof Error) {\n        done(result);\n      } else {\n        then(result);\n      }\n    }\n  }\n\n  // Invoke `next`, only once.\n  function done() {\n    if (!invoked) {\n      invoked = true;\n      callback.apply(null, arguments);\n    }\n  }\n\n  // Invoke `done` with one value.\n  // Tracks if an error is passed, too.\n  function then(value) {\n    done(null, value);\n  }\n}","'use strict';\n\nvar xtend = require('xtend');\nvar inherits = require('inherits');\nmodule.exports = unherit;\n\n// Create a custom constructor which can be modified without affecting the\n// original class.\nfunction unherit(Super) {\n  var result;\n  var key;\n  var value;\n  inherits(Of, Super);\n  inherits(From, Of);\n\n  // Clone values.\n  result = Of.prototype;\n  for (key in result) {\n    value = result[key];\n    if (value && typeof value === 'object') {\n      result[key] = 'concat' in value ? value.concat() : xtend(value);\n    }\n  }\n  return Of;\n\n  // Constructor accepting a single argument, which itself is an `arguments`\n  // object.\n  function From(parameters) {\n    return Super.apply(this, parameters);\n  }\n\n  // Constructor accepting variadic arguments.\n  function Of() {\n    if (!(this instanceof Of)) {\n      return new From(arguments);\n    }\n    return Super.apply(this, arguments);\n  }\n}","'use strict';\n\n/* Expose. */\nmodule.exports = visitParents;\n\n/* Visit. */\nfunction visitParents(tree, type, visitor) {\n  var stack = [];\n  if (typeof type === 'function') {\n    visitor = type;\n    type = null;\n  }\n  one(tree);\n\n  /* Visit a single node. */\n  function one(node) {\n    var result;\n    if (!type || node.type === type) {\n      result = visitor(node, stack.concat());\n    }\n    if (node.children && result !== false) {\n      return all(node.children, node);\n    }\n    return result;\n  }\n\n  /* Visit children in `parent`. */\n  function all(children, parent) {\n    var length = children.length;\n    var index = -1;\n    var child;\n    stack.push(parent);\n    while (++index < length) {\n      child = children[index];\n      if (child && one(child) === false) {\n        return false;\n      }\n    }\n    stack.pop();\n    return true;\n  }\n}","'use strict';\n\nmodule.exports = factory;\nfunction factory(file) {\n  var contents = indices(String(file));\n  return {\n    toPosition: offsetToPositionFactory(contents),\n    toOffset: positionToOffsetFactory(contents)\n  };\n}\n\n// Factory to get the line and column-based `position` for `offset` in the bound\n// indices.\nfunction offsetToPositionFactory(indices) {\n  return offsetToPosition;\n\n  // Get the line and column-based `position` for `offset` in the bound indices.\n  function offsetToPosition(offset) {\n    var index = -1;\n    var length = indices.length;\n    if (offset < 0) {\n      return {};\n    }\n    while (++index < length) {\n      if (indices[index] > offset) {\n        return {\n          line: index + 1,\n          column: offset - (indices[index - 1] || 0) + 1,\n          offset: offset\n        };\n      }\n    }\n    return {};\n  }\n}\n\n// Factory to get the `offset` for a line and column-based `position` in the\n// bound indices.\nfunction positionToOffsetFactory(indices) {\n  return positionToOffset;\n\n  // Get the `offset` for a line and column-based `position` in the bound\n  // indices.\n  function positionToOffset(position) {\n    var line = position && position.line;\n    var column = position && position.column;\n    if (!isNaN(line) && !isNaN(column) && line - 1 in indices) {\n      return (indices[line - 2] || 0) + column - 1 || 0;\n    }\n    return -1;\n  }\n}\n\n// Get indices of line-breaks in `value`.\nfunction indices(value) {\n  var result = [];\n  var index = value.indexOf('\\n');\n  while (index !== -1) {\n    result.push(index + 1);\n    index = value.indexOf('\\n', index + 1);\n  }\n  result.push(value.length + 1);\n  return result;\n}","var toString = Object.prototype.toString;\nmodule.exports = isString;\nfunction isString(obj) {\n  return toString.call(obj) === \"[object String]\";\n}","module.exports = extend;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction extend() {\n  var target = {};\n  for (var i = 0; i < arguments.length; i++) {\n    var source = arguments[i];\n    for (var key in source) {\n      if (hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n  return target;\n}"],"names":["module","exports","err","value","String","replace","hasOwn","Object","prototype","hasOwnProperty","toStr","toString","defineProperty","gOPD","getOwnPropertyDescriptor","isArray","arr","Array","call","isPlainObject","obj","key","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","options","name","enumerable","configurable","newValue","writable","getProperty","extend","src","copy","copyIsArray","clone","arguments","i","length","deep","create","ctor","superCtor","super_","TempCtor","character","re","test","fromCode","charAt","fromCharCode","escapes","defaults","gfm","concat","commonmark","settings","default","visitWithParents","ast","listNode","parents","n","depth","type","children","child","index","ordered","assertPath","path","TypeError","JSON","stringify","normalizeStringPosix","allowAboveRoot","code","res","lastSegmentLength","lastSlash","dots","charCodeAt","lastSlashIndex","lastIndexOf","slice","posix","resolve","cwd","resolvedPath","resolvedAbsolute","undefined","process","normalize","isAbsolute","trailingSeparator","join","joined","arg","relative","from","to","fromStart","fromEnd","fromLen","toStart","toLen","lastCommonSep","out","_makeLong","dirname","hasRoot","end","matchedSlash","basename","ext","start","extIdx","firstNonSlashEnd","extname","startDot","startPart","preDotState","format","pathObject","sep","dir","root","base","_format","parse","ret","delimiter","win32","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","Error","defaultClearTimeout","runTimeout","fun","setTimeout","e","this","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","len","run","marker","runClearTimeout","Item","array","noop","nextTick","args","push","apply","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","chdir","umask","b","Symbol","for","c","d","f","g","h","k","l","m","p","q","r","t","v","w","x","y","z","a","u","$$typeof","A","AsyncMode","ConcurrentMode","ContextConsumer","ContextProvider","Element","ForwardRef","Fragment","Lazy","Memo","Portal","Profiler","StrictMode","Suspense","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isFragment","isLazy","isMemo","isPortal","isProfiler","isStrictMode","isSuspense","isValidElementType","typeOf","React","xtend","ReactIs","defaultNodePosition","line","column","offset","astToReact","node","parent","renderer","renderers","position","pos","nodeProps","opts","props","isTagRenderer","sourcePos","map","flattenPosition","rawSourcePos","sourcePosition","includeNodeIndex","indexOf","parentChildCount","ref","identifier","definitions","assignDefined","className","nodeKey","level","tight","loose","checked","reduce","unwrapParagraphs","getListItemChildren","childNode","url","language","lang","split","inline","linkTarget","href","transformLinkUri","alt","transformImageUri","columnAlignment","align","isHeader","tag","isBlock","escapeHtml","skipHtml","parsedChildren","element","el","createElement","Children","toArray","cloneElement","mergeNodeChildren","getNodeProps","attrs","getDefinitions","defs","visit","untangle","mode","splice","ofType","types","forEach","disallow","ifNotMatch","allowNode","selfClosingRe","simpleTagRe","tree","open","currentParent","selfClosing","match","getSelfClosing","current","opening","getSimpleTag","matching","matchingTag","findAndPull","fromNode","toNode","fromIndex","toIndex","extracted","indent","virtual","_toConsumableArray","arr2","_arrayWithoutHoles","iter","iterator","_iterableToArray","_nonIterableSpread","unified","PropTypes","addListMetadata","naiveHtml","disallowNode","wrapTableRows","uriTransformer","defaultRenderers","symbols","allTypes","keys","ReactMarkdown","source","parserOptions","allowedTypes","disallowedTypes","parser","plugins","applyParserPlugin","rawAst","renderProps","astPlugins","filter","removalMethod","unwrapDisallowed","renderHtml","hasHtmlParser","some","item","identity","HtmlParser","determineAstPlugins","transformedAst","runSync","plugin","use","defaultProps","propTypes","string","bool","func","arrayOf","oneOf","oneOfType","object","supportsStringRender","parseInt","SimpleRenderer","getCoreProps","break","paragraph","emphasis","strong","thematicBreak","blockquote","delete","link","image","linkReference","imageReference","table","bind","tableHead","tableBody","tableRow","tableCell","style","textAlign","coreProps","useFragment","text","list","listItem","checkbox","readOnly","definition","heading","inlineCode","html","comp","dangerouslySetInnerHTML","__html","virtualHtml","parsedHtml","protocols","uri","trim","first","colon","protocol","toLowerCase","wrap","alphabetical","decimal","isBuffer","readFloatLE","isSlowBuffer","_isBuffer","getPrototypeOf","characters","char","entity","document","innerHTML","textContent","legacy","invalid","hexadecimal","alphanumerical","decodeEntity","option","entityCharacters","namedEntity","terminated","reference","following","warning","reason","output","begin","prev","next","diff","additional","nonTerminated","handleText","handleReference","handleWarning","textContext","referenceContext","warningContext","lines","result","now","parseError","lineFeed","ampersand","tab","formFeed","space","lessThan","numberSign","uppercaseX","lowercaseX","hexa","deci","tests","own","semicolon","namedUnknown","namedNotTerminated","namedEmpty","attribute","equalsTo","numericNotTerminated","prohibited","bases","numericProhibited","replacementCharacter","numericDisallowed","disallowed","numericEmpty","flush","messages","Function","unherit","Parser","Local","data","entities","ctx","decoder","raw","offsets","file","message","handler","footnotes","pedantic","blocks","asterisk","underscore","PROTOCOLS","min","removePosition","self","content","EXPRESSION_LINE_BREAKS","C_NEWLINE","tokenizeBlock","eof","toggle","vfileLocation","unescape","decode","tokenizer","doc","setOptions","inList","inBlock","inLink","atStart","toOffset","proto","exitStart","enterList","enterLink","enterBlock","interruptParagraph","interruptList","interruptBlockquote","blockTokenizers","newline","indentedCode","fencedCode","atxHeading","setextHeading","footnote","inlineTokenizers","escape","autoLink","deletion","blockMethods","inlineMethods","tokenizeInline","tokenizeFactory","whitespace","locate","locator","notInLink","C_LT","C_GT","C_AT_SIGN","C_SLASH","MAILTO","MAILTO_LENGTH","eat","silent","subvalue","hasAtCharacter","tokenizers","exit","substr","interrupt","add","rest","nextIndex","startIndex","prefixed","interruptors","currentLine","values","contents","indents","C_SPACE","C_TAB","hardBreak","MIN_BREAK_LENGTH","fenceCount","flag","exdentedContent","closing","exdentedClosing","C_TILDE","C_TICK","MIN_FENCE_COUNT","CODE_INDENT_COUNT","repeat","blankQueue","subvalueQueue","contentQueue","CODE_INDENT","subqueue","count","openingCount","found","tickQueue","notInList","notInBlock","C_DOUBLE_QUOTE","C_SINGLE_QUOTE","C_BACKSLASH","C_BRACKET_OPEN","C_BRACKET_CLOSE","C_PAREN_OPEN","C_PAREN_CLOSE","C_COLON","beforeURL","beforeTitle","isEnclosedURLCharacter","isUnclosedURLCharacter","strikethrough","DOUBLE","previous","preceding","word","C_ASTERISK","C_UNDERSCORE","footnoteDefinition","C_CARET","EXPRESSION_INITIAL_TAB","C_HASH","MAX_ATX_COUNT","MAX_HEADING_INDENT","SETEXT_MARKERS","openCloseTag","sequence","sequences","RegExp","inlineHTML","EXPRESSION_HTML_LINK_OPEN","EXPRESSION_HTML_LINK_CLOSE","LINK_MARKERS","COMMONMARK_LINK_MARKERS","closed","hasMarker","markers","isImage","getIndent","removeIndent","currentMarker","prevEmpty","empty","items","allLines","emptyLines","enterTop","exitBlockquote","isLoose","indented","interuptors","size","TAB_SIZE","LIST_ORDERED_COMMONMARK_MARKERS","LIST_ORDERED_MARKERS","LIST_UNORDERED_MARKERS","C_DASH","trail","reset","C_X_LOWER","EXPRESSION_LOOSE_LIST_ITEM","EXPRESSION_TASK_ITEM","EXPRESSION_BULLET","EXPRESSION_PEDANTIC_BULLET","EXPRESSION_INITIAL_INDENT","task","pedanticListItem","normalListItem","replacer","$0","max","bullet","trimmedLines","$1","$2","$3","$4","Number","trimTrailingLines","left","T_LINK","T_IMAGE","T_FOOTNOTE","REFERENCE_TYPE_SHORTCUT","REFERENCE_TYPE_COLLAPSED","REFERENCE_TYPE_FULL","bracketed","intro","referenceType","alignments","alignment","row","hasDash","cell","preamble","lineCount","rows","lineIndex","pipeIndex","C_PIPE","MIN_TABLE_ROWS","TABLE_ALIGN_NONE","TABLE_ALIGN_LEFT","TABLE_ALIGN_CENTER","TABLE_ALIGN_RIGHT","MIN_TABLE_COLUMNS","methods","fail","markerCount","THEMATIC_BREAK_MARKER_COUNT","MAILTO_PROTOCOL","PROTOCOLS_LENGTH","parenCount","nextCharacter","location","method","matched","valueLength","tokens","updatePosition","onlyAtStart","lastIndex","getOffset","indentation","last","Position","validateEat","substring","before","update","combined","MERGEABLE_NODES","mergeable","stops","Math","floor","openTag","closeTag","params","interruptor","config","fn","ignore","bools","collapseWhiteSpace","maximum","padding","minIndent","Infinity","matrix","unshift","shift","bail","vfile","trough","plain","attachers","transformers","namespace","frozen","freezeIndex","processor","assertUnfrozen","freeze","addPlugin","addList","addPreset","entry","find","assertParser","newable","Compiler","assertCompiler","assertNode","compile","complete","done","assertDone","processSync","destination","transformer","cb","Promise","executor","reject","pipeline","asyncName","convert","Boolean","typeFactory","ok","anyFactory","matchesFactory","checks","results","convertAll","hard","soft","force","point","visitParents","CONTINUE","SKIP","EXIT","visitor","reverse","is","one","subresult","toResult","step","all","VMessagePrototype","VMessage","origin","parts","range","parseOrigin","stack","ruleId","fatal","buffer","VFile","encoding","order","prop","history","assertPart","part","assertNonEmpty","get","set","stem","filePath","info","warn","cache","str","num","npath","nFileName","state","context","right","fns","middleware","input","callback","invoked","error","then","inherits","Super","Of","From","parameters","pop","offsetToPositionFactory","indices","positionToOffsetFactory","isNaN","toPosition"],"sourceRoot":""}