{"version":3,"file":"npm-remark-parse-85995bb9ddc9c256535f.js","mappings":"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","sources":["webpack:///../node_modules/remark-parse/index.js","webpack:///../node_modules/remark-parse/lib/decode.js","webpack:///../node_modules/remark-parse/lib/defaults.js","webpack:///../node_modules/remark-parse/lib/locate/break.js","webpack:///../node_modules/remark-parse/lib/locate/code-inline.js","webpack:///../node_modules/remark-parse/lib/locate/delete.js","webpack:///../node_modules/remark-parse/lib/locate/emphasis.js","webpack:///../node_modules/remark-parse/lib/locate/escape.js","webpack:///../node_modules/remark-parse/lib/locate/link.js","webpack:///../node_modules/remark-parse/lib/locate/strong.js","webpack:///../node_modules/remark-parse/lib/locate/tag.js","webpack:///../node_modules/remark-parse/lib/locate/url.js","webpack:///../node_modules/remark-parse/lib/parse.js","webpack:///../node_modules/remark-parse/lib/parser.js","webpack:///../node_modules/remark-parse/lib/set-options.js","webpack:///../node_modules/remark-parse/lib/tokenize/auto-link.js","webpack:///../node_modules/remark-parse/lib/tokenize/blockquote.js","webpack:///../node_modules/remark-parse/lib/tokenize/break.js","webpack:///../node_modules/remark-parse/lib/tokenize/code-fenced.js","webpack:///../node_modules/remark-parse/lib/tokenize/code-indented.js","webpack:///../node_modules/remark-parse/lib/tokenize/code-inline.js","webpack:///../node_modules/remark-parse/lib/tokenize/definition.js","webpack:///../node_modules/remark-parse/lib/tokenize/delete.js","webpack:///../node_modules/remark-parse/lib/tokenize/emphasis.js","webpack:///../node_modules/remark-parse/lib/tokenize/escape.js","webpack:///../node_modules/remark-parse/lib/tokenize/footnote-definition.js","webpack:///../node_modules/remark-parse/lib/tokenize/heading-atx.js","webpack:///../node_modules/remark-parse/lib/tokenize/heading-setext.js","webpack:///../node_modules/remark-parse/lib/tokenize/html-block.js","webpack:///../node_modules/remark-parse/lib/tokenize/html-inline.js","webpack:///../node_modules/remark-parse/lib/tokenize/link.js","webpack:///../node_modules/remark-parse/lib/tokenize/list.js","webpack:///../node_modules/remark-parse/lib/tokenize/newline.js","webpack:///../node_modules/remark-parse/lib/tokenize/paragraph.js","webpack:///../node_modules/remark-parse/lib/tokenize/reference.js","webpack:///../node_modules/remark-parse/lib/tokenize/strong.js","webpack:///../node_modules/remark-parse/lib/tokenize/table.js","webpack:///../node_modules/remark-parse/lib/tokenize/text.js","webpack:///../node_modules/remark-parse/lib/tokenize/thematic-break.js","webpack:///../node_modules/remark-parse/lib/tokenize/url.js","webpack:///../node_modules/remark-parse/lib/tokenizer.js","webpack:///../node_modules/remark-parse/lib/unescape.js","webpack:///../node_modules/remark-parse/lib/util/get-indentation.js","webpack:///../node_modules/remark-parse/lib/util/html.js","webpack:///../node_modules/remark-parse/lib/util/interrupt.js","webpack:///../node_modules/remark-parse/lib/util/normalize.js","webpack:///../node_modules/remark-parse/lib/util/remove-indentation.js"],"sourcesContent":["'use strict';\n\nvar unherit = require('unherit');\nvar xtend = require('xtend');\nvar Parser = require('./lib/parser.js');\n\nmodule.exports = parse;\nparse.Parser = Parser;\n\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}\n","'use strict';\n\nvar xtend = require('xtend');\nvar entities = require('parse-entities');\n\nmodule.exports = factory;\n\n/* Factory to create an entity decoder. */\nfunction factory(ctx) {\n  decoder.raw = decodeRaw;\n\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\n    while (++line) {\n      if (!(line in offsets)) {\n        break;\n      }\n\n      result.push((offsets[line] || 0) + 1);\n    }\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\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}\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};\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  var index = value.indexOf('\\n', fromIndex);\n\n  while (index > fromIndex) {\n    if (value.charAt(index - 1) !== ' ') {\n      break;\n    }\n\n    index--;\n  }\n\n  return index;\n}\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  return value.indexOf('`', fromIndex);\n}\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  return value.indexOf('~~', fromIndex);\n}\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  var asterisk = value.indexOf('*', fromIndex);\n  var underscore = value.indexOf('_', fromIndex);\n\n  if (underscore === -1) {\n    return asterisk;\n  }\n\n  if (asterisk === -1) {\n    return underscore;\n  }\n\n  return underscore < asterisk ? underscore : asterisk;\n}\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  return value.indexOf('\\\\', fromIndex);\n}\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  var link = value.indexOf('[', fromIndex);\n  var image = value.indexOf('![', fromIndex);\n\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}\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  var asterisk = value.indexOf('**', fromIndex);\n  var underscore = value.indexOf('__', fromIndex);\n\n  if (underscore === -1) {\n    return asterisk;\n  }\n\n  if (asterisk === -1) {\n    return underscore;\n  }\n\n  return underscore < asterisk ? underscore : asterisk;\n}\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  return value.indexOf('<', fromIndex);\n}\n","'use strict';\n\nmodule.exports = locate;\n\nvar PROTOCOLS = ['https://', 'http://', 'mailto:'];\n\nfunction locate(value, fromIndex) {\n  var length = PROTOCOLS.length;\n  var index = -1;\n  var min = -1;\n  var position;\n\n  if (!this.options.gfm) {\n    return -1;\n  }\n\n  while (++index < length) {\n    position = value.indexOf(PROTOCOLS[index], fromIndex);\n\n    if (position !== -1 && (position < min || min === -1)) {\n      min = position;\n    }\n  }\n\n  return min;\n}\n","'use strict';\n\nvar xtend = require('xtend');\nvar removePosition = require('unist-util-remove-position');\n\nmodule.exports = parse;\n\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 = {line: 1, column: 1, offset: 0};\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\n  if (value.charCodeAt(0) === 0xFEFF) {\n    value = value.slice(1);\n\n    content.column++;\n    content.offset++;\n  }\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\n  if (!self.options.position) {\n    removePosition(node, true);\n  }\n\n  return node;\n}\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');\n\nmodule.exports = Parser;\n\nfunction Parser(doc, file) {\n  this.file = file;\n  this.offset = {};\n  this.options = xtend(this.options);\n  this.setOptions({});\n\n  this.inList = false;\n  this.inBlock = false;\n  this.inLink = false;\n  this.atStart = true;\n\n  this.toOffset = vfileLocation(file).toOffset;\n  this.unescape = unescape(this, 'escape');\n  this.decode = decode(this);\n}\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 = [\n  ['thematicBreak'],\n  ['atxHeading'],\n  ['fencedCode'],\n  ['blockquote'],\n  ['html'],\n  ['setextHeading', {commonmark: false}],\n  ['definition', {commonmark: false}],\n  ['footnote', {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 = [\n  ['atxHeading', {pedantic: false}],\n  ['fencedCode', {pedantic: false}],\n  ['thematicBreak', {pedantic: false}],\n  ['definition', {commonmark: false}],\n  ['footnote', {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 = [\n  ['indentedCode', {commonmark: true}],\n  ['fencedCode', {commonmark: true}],\n  ['atxHeading', {commonmark: true}],\n  ['setextHeading', {commonmark: true}],\n  ['thematicBreak', {commonmark: true}],\n  ['html', {commonmark: true}],\n  ['list', {commonmark: true}],\n  ['definition', {commonmark: false}],\n  ['footnote', {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};\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\n  for (key in value) {\n    result.push(key);\n  }\n\n  return result;\n}\n","'use strict';\n\nvar xtend = require('xtend');\nvar escapes = require('markdown-escapes');\nvar defaults = require('./defaults');\n\nmodule.exports = setOptions;\n\nfunction setOptions(options) {\n  var self = this;\n  var current = self.options;\n  var key;\n  var value;\n\n  if (options == null) {\n    options = {};\n  } else if (typeof options === 'object') {\n    options = xtend(options);\n  } else {\n    throw new Error(\n      'Invalid value `' + options + '` ' +\n      'for setting `options`'\n    );\n  }\n\n  for (key in defaults) {\n    value = options[key];\n\n    if (value == null) {\n      value = current[key];\n    }\n\n    if (\n      (key !== 'blocks' && typeof value !== 'boolean') ||\n      (key === 'blocks' && typeof value !== 'object')\n    ) {\n      throw new Error('Invalid value `' + value + '` for setting `options.' + key + '`');\n    }\n\n    options[key] = value;\n  }\n\n  self.options = options;\n  self.escape = escapes(options);\n\n  return self;\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar decode = require('parse-entities');\nvar locate = require('../locate/tag');\n\nmodule.exports = autoLink;\nautoLink.locator = locate;\nautoLink.notInLink = true;\n\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\n  if (value.charAt(0) !== C_LT) {\n    return;\n  }\n\n  self = this;\n  subvalue = '';\n  length = value.length;\n  index = 0;\n  queue = '';\n  hasAtCharacter = false;\n  link = '';\n\n  index++;\n  subvalue = C_LT;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (\n      whitespace(character) ||\n      character === C_GT ||\n      character === C_AT_SIGN ||\n      (character === ':' && value.charAt(index + 1) === C_SLASH)\n    ) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\n\n  if (!queue) {\n    return;\n  }\n\n  link += queue;\n  queue = '';\n\n  character = value.charAt(index);\n  link += character;\n  index++;\n\n  if (character === C_AT_SIGN) {\n    hasAtCharacter = true;\n  } else {\n    if (\n      character !== ':' ||\n      value.charAt(index + 1) !== C_SLASH\n    ) {\n      return;\n    }\n\n    link += C_SLASH;\n    index++;\n  }\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (whitespace(character) || character === C_GT) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n\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\n  link += queue;\n  content = link;\n  subvalue += link + character;\n  now = eat.now();\n  now.column++;\n  now.offset++;\n\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 = {text: tokenizers.text};\n\n  exit = self.enterLink();\n\n  content = self.tokenizeInline(content, now);\n\n  self.inlineTokenizers = tokenizers;\n  exit();\n\n  return eat(subvalue)({\n    type: 'link',\n    title: null,\n    url: decode(link, {nonTerminated: false}),\n    children: content\n  });\n}\n","'use strict';\n\nvar trim = require('trim');\nvar interrupt = require('../util/interrupt');\n\nmodule.exports = blockquote;\n\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\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n\n    index++;\n  }\n\n  if (value.charAt(index) !== C_GT) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  index = 0;\n\n  while (index < length) {\n    nextIndex = value.indexOf(C_NEWLINE, index);\n    startIndex = index;\n    prefixed = false;\n\n    if (nextIndex === -1) {\n      nextIndex = length;\n    }\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character !== C_SPACE && character !== C_TAB) {\n        break;\n      }\n\n      index++;\n    }\n\n    if (value.charAt(index) === C_GT) {\n      index++;\n      prefixed = true;\n\n      if (value.charAt(index) === C_SPACE) {\n        index++;\n      }\n    } else {\n      index = startIndex;\n    }\n\n    content = value.slice(index, nextIndex);\n\n    if (!prefixed && !trim(content)) {\n      index = startIndex;\n      break;\n    }\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\n    line = startIndex === index ? content : value.slice(startIndex, nextIndex);\n\n    indents.push(index - startIndex);\n    values.push(line);\n    contents.push(content);\n\n    index = nextIndex + 1;\n  }\n\n  index = -1;\n  length = indents.length;\n  add = eat(values.join(C_NEWLINE));\n\n  while (++index < length) {\n    offsets[currentLine] = (offsets[currentLine] || 0) + indents[index];\n    currentLine++;\n  }\n\n  exit = self.enterBlock();\n  contents = self.tokenizeBlock(contents.join(C_NEWLINE), now);\n  exit();\n\n  return add({\n    type: 'blockquote',\n    children: contents\n  });\n}\n","'use strict';\n\nvar locate = require('../locate/break');\n\nmodule.exports = hardBreak;\nhardBreak.locator = locate;\n\nvar MIN_BREAK_LENGTH = 2;\n\nfunction hardBreak(eat, value, silent) {\n  var length = value.length;\n  var index = -1;\n  var queue = '';\n  var character;\n\n  while (++index < length) {\n    character = value.charAt(index);\n\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\n      queue += character;\n\n      return eat(queue)({type: 'break'});\n    }\n\n    if (character !== ' ') {\n      return;\n    }\n\n    queue += character;\n  }\n}\n","'use strict';\n\nvar trim = require('trim-trailing-lines');\n\nmodule.exports = fencedCode;\n\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_TILDE = '~';\nvar C_TICK = '`';\n\nvar MIN_FENCE_COUNT = 3;\nvar CODE_INDENT_COUNT = 4;\n\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\n  if (!settings.gfm) {\n    return;\n  }\n\n  /* Eat initial spacing. */\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  indent = index;\n\n  /* Eat the fence. */\n  character = value.charAt(index);\n\n  if (character !== C_TILDE && character !== C_TICK) {\n    return;\n  }\n\n  index++;\n  marker = character;\n  fenceCount = 1;\n  subvalue += character;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== marker) {\n      break;\n    }\n\n    subvalue += character;\n    fenceCount++;\n    index++;\n  }\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\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  /* Eat flag. */\n  flag = '';\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (\n      character === C_NEWLINE ||\n      character === C_TILDE ||\n      character === C_TICK\n    ) {\n      break;\n    }\n\n    if (character === C_SPACE || character === C_TAB) {\n      queue += character;\n    } else {\n      flag += queue + character;\n      queue = '';\n    }\n\n    index++;\n  }\n\n  character = value.charAt(index);\n\n  if (character && character !== C_NEWLINE) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  now = eat.now();\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n\n  subvalue += flag;\n  flag = self.decode.raw(self.unescape(flag), now);\n\n  if (queue) {\n    subvalue += queue;\n  }\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\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\n    queue = '';\n    index++;\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character !== C_SPACE) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    closing += queue;\n    exdentedClosing += queue.slice(indent);\n\n    if (queue.length >= CODE_INDENT_COUNT) {\n      continue;\n    }\n\n    queue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character !== marker) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    closing += queue;\n    exdentedClosing += queue;\n\n    if (queue.length < fenceCount) {\n      continue;\n    }\n\n    queue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character !== C_SPACE && character !== C_TAB) {\n        break;\n      }\n\n      closing += character;\n      exdentedClosing += character;\n      index++;\n    }\n\n    if (!character || character === C_NEWLINE) {\n      break;\n    }\n  }\n\n  subvalue += content + closing;\n\n  return eat(subvalue)({\n    type: 'code',\n    lang: flag || null,\n    value: trim(exdentedContent)\n  });\n}\n","'use strict';\n\nvar repeat = require('repeat-string');\nvar trim = require('trim-trailing-lines');\n\nmodule.exports = indentedCode;\n\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\n\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\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (indent) {\n      indent = false;\n\n      subvalue += subvalueQueue;\n      content += contentQueue;\n      subvalueQueue = '';\n      contentQueue = '';\n\n      if (character === C_NEWLINE) {\n        subvalueQueue = character;\n        contentQueue = character;\n      } else {\n        subvalue += character;\n        content += character;\n\n        while (++index < length) {\n          character = value.charAt(index);\n\n          if (!character || character === C_NEWLINE) {\n            contentQueue = character;\n            subvalueQueue = character;\n            break;\n          }\n\n          subvalue += character;\n          content += character;\n        }\n      }\n    } else if (\n      character === C_SPACE &&\n      value.charAt(index + 1) === character &&\n      value.charAt(index + 2) === character &&\n      value.charAt(index + 3) === character\n    ) {\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\n      while (character === C_TAB || character === C_SPACE) {\n        blankQueue += character;\n        character = value.charAt(++index);\n      }\n\n      if (character !== C_NEWLINE) {\n        break;\n      }\n\n      subvalueQueue += blankQueue + character;\n      contentQueue += character;\n    }\n  }\n\n  if (content) {\n    if (silent) {\n      return true;\n    }\n\n    return eat(subvalue)({\n      type: 'code',\n      lang: null,\n      value: trim(content)\n    });\n  }\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/code-inline');\n\nmodule.exports = inlineCode;\ninlineCode.locator = locate;\n\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\n  while (index < length) {\n    if (value.charAt(index) !== C_TICK) {\n      break;\n    }\n\n    queue += C_TICK;\n    index++;\n  }\n\n  if (!queue) {\n    return;\n  }\n\n  subvalue = queue;\n  openingCount = index;\n  queue = '';\n  next = value.charAt(index);\n  count = 0;\n\n  while (index < length) {\n    character = next;\n    next = value.charAt(index + 1);\n\n    if (character === C_TICK) {\n      count++;\n      tickQueue += character;\n    } else {\n      count = 0;\n      queue += character;\n    }\n\n    if (count && next !== C_TICK) {\n      if (count === openingCount) {\n        subvalue += queue + tickQueue;\n        found = true;\n        break;\n      }\n\n      queue += tickQueue;\n      tickQueue = '';\n    }\n\n    index++;\n  }\n\n  if (!found) {\n    if (openingCount % 2 !== 0) {\n      return;\n    }\n\n    queue = '';\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n\n  contentQueue = '';\n  subqueue = '';\n  length = queue.length;\n  index = -1;\n\n  while (++index < length) {\n    character = queue.charAt(index);\n\n    if (whitespace(character)) {\n      subqueue += character;\n      continue;\n    }\n\n    if (subqueue) {\n      if (contentQueue) {\n        contentQueue += subqueue;\n      }\n\n      subqueue = '';\n    }\n\n    contentQueue += character;\n  }\n\n  return eat(subvalue)({\n    type: 'inlineCode',\n    value: contentQueue\n  });\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar normalize = require('../util/normalize');\n\nmodule.exports = definition;\ndefinition.notInList = true;\ndefinition.notInBlock = true;\n\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 = '>';\n\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\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n\n  if (character !== C_BRACKET_OPEN) {\n    return;\n  }\n\n  index++;\n  subvalue += character;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\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\n    queue += character;\n    index++;\n  }\n\n  if (\n    !queue ||\n    value.charAt(index) !== C_BRACKET_CLOSE ||\n    value.charAt(index + 1) !== C_COLON\n  ) {\n    return;\n  }\n\n  identifier = queue;\n  subvalue += queue + C_BRACKET_CLOSE + C_COLON;\n  index = subvalue.length;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (\n      character !== C_TAB &&\n      character !== C_SPACE &&\n      character !== C_NEWLINE\n    ) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n  queue = '';\n  beforeURL = subvalue;\n\n  if (character === C_LT) {\n    index++;\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (!isEnclosedURLCharacter(character)) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    character = value.charAt(index);\n\n    if (character === isEnclosedURLCharacter.delimiter) {\n      subvalue += C_LT + queue + character;\n      index++;\n    } else {\n      if (commonmark) {\n        return;\n      }\n\n      index -= queue.length + 1;\n      queue = '';\n    }\n  }\n\n  if (!queue) {\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (!isUnclosedURLCharacter(character)) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    subvalue += queue;\n  }\n\n  if (!queue) {\n    return;\n  }\n\n  url = queue;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (\n      character !== C_TAB &&\n      character !== C_SPACE &&\n      character !== C_NEWLINE\n    ) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n  test = null;\n\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\n  if (!test) {\n    queue = '';\n    index = subvalue.length;\n  } else if (queue) {\n    subvalue += queue + character;\n    index = subvalue.length;\n    queue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character === test) {\n        break;\n      }\n\n      if (character === C_NEWLINE) {\n        index++;\n        character = value.charAt(index);\n\n        if (character === C_NEWLINE || character === test) {\n          return;\n        }\n\n        queue += C_NEWLINE;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    character = value.charAt(index);\n\n    if (character !== test) {\n      return;\n    }\n\n    beforeTitle = subvalue;\n    subvalue += queue + character;\n    index++;\n    title = queue;\n    queue = '';\n  } else {\n    return;\n  }\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n\n  if (!character || character === C_NEWLINE) {\n    if (silent) {\n      return true;\n    }\n\n    beforeURL = eat(beforeURL).test().end;\n    url = self.decode.raw(self.unescape(url), beforeURL, {nonTerminated: false});\n\n    if (title) {\n      beforeTitle = eat(beforeTitle).test().end;\n      title = self.decode.raw(self.unescape(title), beforeTitle);\n    }\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 &&\n    character !== C_BRACKET_OPEN &&\n    character !== C_BRACKET_CLOSE;\n}\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 &&\n    character !== C_BRACKET_CLOSE &&\n    !whitespace(character);\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/delete');\n\nmodule.exports = strikethrough;\nstrikethrough.locator = locate;\n\nvar C_TILDE = '~';\nvar DOUBLE = '~~';\n\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\n  if (\n    !self.options.gfm ||\n    value.charAt(0) !== C_TILDE ||\n    value.charAt(1) !== C_TILDE ||\n    whitespace(value.charAt(2))\n  ) {\n    return;\n  }\n\n  index = 1;\n  length = value.length;\n  now = eat.now();\n  now.column += 2;\n  now.offset += 2;\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (\n      character === C_TILDE &&\n      previous === C_TILDE &&\n      (!preceding || !whitespace(preceding))\n    ) {\n      /* istanbul ignore if - never used (yet) */\n      if (silent) {\n        return true;\n      }\n\n      return eat(DOUBLE + subvalue + DOUBLE)({\n        type: 'delete',\n        children: self.tokenizeInline(subvalue, now)\n      });\n    }\n\n    subvalue += previous;\n    preceding = previous;\n    previous = character;\n  }\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');\n\nmodule.exports = emphasis;\nemphasis.locator = locate;\n\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\n\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\n  if (character !== C_ASTERISK && character !== C_UNDERSCORE) {\n    return;\n  }\n\n  pedantic = self.options.pedantic;\n  subvalue = character;\n  marker = character;\n  length = value.length;\n  index++;\n  queue = '';\n  character = '';\n\n  if (pedantic && whitespace(value.charAt(index))) {\n    return;\n  }\n\n  while (index < length) {\n    prev = character;\n    character = value.charAt(index);\n\n    if (character === marker && (!pedantic || !whitespace(prev))) {\n      character = value.charAt(++index);\n\n      if (character !== marker) {\n        if (!trim(queue) || prev === marker) {\n          return;\n        }\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\n        now = eat.now();\n        now.column++;\n        now.offset++;\n\n        return eat(subvalue + queue + marker)({\n          type: 'emphasis',\n          children: self.tokenizeInline(queue, now)\n        });\n      }\n\n      queue += marker;\n    }\n\n    if (!pedantic && character === '\\\\') {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    queue += character;\n    index++;\n  }\n}\n","'use strict';\n\nvar locate = require('../locate/escape');\n\nmodule.exports = escape;\nescape.locator = locate;\n\nfunction escape(eat, value, silent) {\n  var self = this;\n  var character;\n  var node;\n\n  if (value.charAt(0) === '\\\\') {\n    character = value.charAt(1);\n\n    if (self.escape.indexOf(character) !== -1) {\n      /* istanbul ignore if - never used (yet) */\n      if (silent) {\n        return true;\n      }\n\n      if (character === '\\n') {\n        node = {type: 'break'};\n      } else {\n        node = {\n          type: 'text',\n          value: character\n        };\n      }\n\n      return eat('\\\\' + character)(node);\n    }\n  }\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar normalize = require('../util/normalize');\n\nmodule.exports = footnoteDefinition;\nfootnoteDefinition.notInList = true;\nfootnoteDefinition.notInBlock = true;\n\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 = ':';\n\nvar EXPRESSION_INITIAL_TAB = /^( {4}|\\t)?/gm;\n\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\n  if (!self.options.footnotes) {\n    return;\n  }\n\n  index = 0;\n  length = value.length;\n  subvalue = '';\n  now = eat.now();\n  currentLine = now.line;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (!whitespace(character)) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  if (\n    value.charAt(index) !== C_BRACKET_OPEN ||\n    value.charAt(index + 1) !== C_CARET\n  ) {\n    return;\n  }\n\n  subvalue += C_BRACKET_OPEN + C_CARET;\n  index = subvalue.length;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\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\n    queue += character;\n    index++;\n  }\n\n  if (\n    !queue ||\n    value.charAt(index) !== C_BRACKET_CLOSE ||\n    value.charAt(index + 1) !== C_COLON\n  ) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  identifier = normalize(queue);\n  subvalue += queue + C_BRACKET_CLOSE + C_COLON;\n  index = subvalue.length;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n  queue = '';\n  content = '';\n  subqueue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character === C_NEWLINE) {\n      subqueue = character;\n      index++;\n\n      while (index < length) {\n        character = value.charAt(index);\n\n        if (character !== C_NEWLINE) {\n          break;\n        }\n\n        subqueue += character;\n        index++;\n      }\n\n      queue += subqueue;\n      subqueue = '';\n\n      while (index < length) {\n        character = value.charAt(index);\n\n        if (character !== C_SPACE) {\n          break;\n        }\n\n        subqueue += character;\n        index++;\n      }\n\n      if (subqueue.length === 0) {\n        break;\n      }\n\n      queue += subqueue;\n    }\n\n    if (queue) {\n      content += queue;\n      queue = '';\n    }\n\n    content += character;\n    index++;\n  }\n\n  subvalue += content;\n\n  content = content.replace(EXPRESSION_INITIAL_TAB, function (line) {\n    offsets[currentLine] = (offsets[currentLine] || 0) + line.length;\n    currentLine++;\n\n    return '';\n  });\n\n  add = eat(subvalue);\n\n  exit = self.enterBlock();\n  content = self.tokenizeBlock(content, now);\n  exit();\n\n  return add({\n    type: 'footnoteDefinition',\n    identifier: identifier,\n    children: content\n  });\n}\n","'use strict';\n\nmodule.exports = atxHeading;\n\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_HASH = '#';\n\nvar MAX_ATX_COUNT = 6;\n\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\n    if (character !== C_SPACE && character !== C_TAB) {\n      index--;\n      break;\n    }\n\n    subvalue += character;\n  }\n\n  /* Eat hashes. */\n  depth = 0;\n\n  while (++index <= length) {\n    character = value.charAt(index);\n\n    if (character !== C_HASH) {\n      index--;\n      break;\n    }\n\n    subvalue += character;\n    depth++;\n  }\n\n  if (depth > MAX_ATX_COUNT) {\n    return;\n  }\n\n  if (\n    !depth ||\n    (!settings.pedantic && value.charAt(index + 1) === C_HASH)\n  ) {\n    return;\n  }\n\n  length = value.length + 1;\n\n  /* Eat intermediate white-space. */\n  queue = '';\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      index--;\n      break;\n    }\n\n    queue += character;\n  }\n\n  /* Exit when not in pedantic mode without spacing. */\n  if (\n    !settings.pedantic &&\n    queue.length === 0 &&\n    character &&\n    character !== C_NEWLINE\n  ) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  /* Eat content. */\n  subvalue += queue;\n  queue = '';\n  content = '';\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (!character || character === C_NEWLINE) {\n      break;\n    }\n\n    if (\n      character !== C_SPACE &&\n      character !== C_TAB &&\n      character !== C_HASH\n    ) {\n      content += queue + character;\n      queue = '';\n      continue;\n    }\n\n    while (character === C_SPACE || character === C_TAB) {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    while (character === C_HASH) {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    while (character === C_SPACE || character === C_TAB) {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    index--;\n  }\n\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n  subvalue += content + queue;\n\n  return eat(subvalue)({\n    type: 'heading',\n    depth: depth,\n    children: self.tokenizeInline(content, now)\n  });\n}\n","'use strict';\n\nmodule.exports = setextHeading;\n\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_EQUALS = '=';\nvar C_DASH = '-';\n\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 = {};\n\nSETEXT_MARKERS[C_EQUALS] = 1;\nSETEXT_MARKERS[C_DASH] = 2;\n\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\n    if (character !== C_SPACE || index >= MAX_HEADING_INDENT) {\n      index--;\n      break;\n    }\n\n    subvalue += character;\n  }\n\n  /* Eat content. */\n  content = '';\n  queue = '';\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character === C_NEWLINE) {\n      index--;\n      break;\n    }\n\n    if (character === C_SPACE || character === C_TAB) {\n      queue += character;\n    } else {\n      content += queue + character;\n      queue = '';\n    }\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\n  if (character !== C_NEWLINE || !SETEXT_MARKERS[marker]) {\n    return;\n  }\n\n  subvalue += character;\n\n  /* Eat Setext-line. */\n  queue = marker;\n  depth = SETEXT_MARKERS[marker];\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character !== marker) {\n      if (character !== C_NEWLINE) {\n        return;\n      }\n\n      index--;\n      break;\n    }\n\n    queue += character;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  return eat(subvalue + queue)({\n    type: 'heading',\n    depth: depth,\n    children: self.tokenizeInline(content, now)\n  });\n}\n","'use strict';\n\nvar openCloseTag = require('../util/html').openCloseTag;\n\nmodule.exports = blockHTML;\n\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_NEWLINE = '\\n';\nvar C_LT = '<';\n\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\n  var sequences = [\n    [/^<(script|pre|style)(?=(\\s|>|$))/i, /<\\/(script|pre|style)>/i, true],\n    [/^<!--/, /-->/, true],\n    [/^<\\?/, /\\?>/, true],\n    [/^<![A-Za-z]/, />/, true],\n    [/^<!\\[CDATA\\[/, /\\]\\]>/, true],\n    [new RegExp('^</?(' + blocks.join('|') + ')(?=(\\\\s|/?>|$))', 'i'), /^$/, true],\n    [new RegExp(openCloseTag.source + '\\\\s*$'), /^$/, false]\n  ];\n\n  /* Eat initial spacing. */\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n\n    index++;\n  }\n\n  if (value.charAt(index) !== C_LT) {\n    return;\n  }\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\n  while (++offset < count) {\n    if (sequences[offset][0].test(line)) {\n      sequence = sequences[offset];\n      break;\n    }\n  }\n\n  if (!sequence) {\n    return;\n  }\n\n  if (silent) {\n    return sequence[2];\n  }\n\n  index = next;\n\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\n      if (sequence[1].test(line)) {\n        if (line) {\n          index = next;\n        }\n\n        break;\n      }\n\n      index = next;\n    }\n  }\n\n  subvalue = value.slice(0, index);\n\n  return eat(subvalue)({type: 'html', value: subvalue});\n}\n","'use strict';\n\nvar alphabetical = require('is-alphabetical');\nvar locate = require('../locate/tag');\nvar tag = require('../util/html').tag;\n\nmodule.exports = inlineHTML;\ninlineHTML.locator = locate;\n\nvar EXPRESSION_HTML_LINK_OPEN = /^<a /i;\nvar EXPRESSION_HTML_LINK_CLOSE = /^<\\/a>/i;\n\nfunction inlineHTML(eat, value, silent) {\n  var self = this;\n  var length = value.length;\n  var character;\n  var subvalue;\n\n  if (value.charAt(0) !== '<' || length < 3) {\n    return;\n  }\n\n  character = value.charAt(1);\n\n  if (\n    !alphabetical(character) &&\n    character !== '?' &&\n    character !== '!' &&\n    character !== '/'\n  ) {\n    return;\n  }\n\n  subvalue = value.match(tag);\n\n  if (!subvalue) {\n    return;\n  }\n\n  /* istanbul ignore if - not used yet. */\n  if (silent) {\n    return true;\n  }\n\n  subvalue = subvalue[0];\n\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\n  return eat(subvalue)({type: 'html', value: subvalue});\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/link');\n\nmodule.exports = link;\nlink.locator = locate;\n\nvar own = {}.hasOwnProperty;\n\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 = {};\n\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 = {};\n\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;\n\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\n  subvalue += character;\n  queue = '';\n  index++;\n\n  /* Eat the content. */\n  length = value.length;\n  now = eat.now();\n  depth = 0;\n\n  now.column += index;\n  now.offset += index;\n\n  while (index < length) {\n    character = value.charAt(index);\n    subqueue = character;\n\n    if (character === C_TICK) {\n      /* Inline-code in link content. */\n      count = 1;\n\n      while (value.charAt(index + 1) === C_TICK) {\n        subqueue += character;\n        index++;\n        count++;\n      }\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\n            if (!whitespace(character)) {\n              break;\n            }\n\n            subqueue += character;\n            index++;\n          }\n        }\n\n        if (value.charAt(index + 1) !== C_PAREN_OPEN) {\n          return;\n        }\n\n        subqueue += C_PAREN_OPEN;\n        closed = true;\n        index++;\n\n        break;\n      }\n    }\n\n    queue += subqueue;\n    subqueue = '';\n    index++;\n  }\n\n  /* Eat the content closing. */\n  if (!closed) {\n    return;\n  }\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\n    if (!whitespace(character)) {\n      break;\n    }\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\n  if (character === C_LT) {\n    index++;\n    beforeURL += C_LT;\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character === C_GT) {\n        break;\n      }\n\n      if (commonmark && character === '\\n') {\n        return;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    if (value.charAt(index) !== C_GT) {\n      return;\n    }\n\n    subvalue += C_LT + queue + C_GT;\n    url = queue;\n    index++;\n  } else {\n    character = null;\n    subqueue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (subqueue && own.call(markers, character)) {\n        break;\n      }\n\n      if (whitespace(character)) {\n        if (!pedantic) {\n          break;\n        }\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\n          depth--;\n        }\n\n        queue += subqueue;\n        subqueue = '';\n\n        if (character === C_BACKSLASH) {\n          queue += C_BACKSLASH;\n          character = value.charAt(++index);\n        }\n\n        queue += character;\n      }\n\n      index++;\n    }\n\n    subvalue += queue;\n    url = queue;\n    index = subvalue.length;\n  }\n\n  /* Eat white-space. */\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (!whitespace(character)) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\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\n        if (character === marker) {\n          break;\n        }\n\n        if (character === C_BACKSLASH) {\n          queue += C_BACKSLASH;\n          character = value.charAt(++index);\n        }\n\n        index++;\n        queue += character;\n      }\n\n      character = value.charAt(index);\n\n      if (character !== marker) {\n        return;\n      }\n\n      title = queue;\n      subvalue += queue + character;\n      index++;\n\n      while (index < length) {\n        character = value.charAt(index);\n\n        if (!whitespace(character)) {\n          break;\n        }\n\n        subvalue += character;\n        index++;\n      }\n    } else {\n      subqueue = '';\n\n      while (index < length) {\n        character = value.charAt(index);\n\n        if (character === marker) {\n          if (hasMarker) {\n            queue += marker + subqueue;\n            subqueue = '';\n          }\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\n        index++;\n      }\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\n  subvalue += C_PAREN_CLOSE;\n\n  url = self.decode.raw(self.unescape(url), eat(beforeURL).test().end, {nonTerminated: false});\n\n  if (title) {\n    beforeTitle = eat(beforeTitle).test().end;\n    title = self.decode.raw(self.unescape(title), beforeTitle);\n  }\n\n  node = {\n    type: isImage ? 'image' : 'link',\n    title: title || null,\n    url: url\n  };\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\n  return eat(subvalue)(node);\n}\n","'use strict';\n\n/* eslint-disable max-params */\n\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');\n\nmodule.exports = list;\n\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';\n\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 = {};\n\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 = {};\n\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 = {};\n\nLIST_ORDERED_COMMONMARK_MARKERS[C_DOT] = true;\nLIST_ORDERED_COMMONMARK_MARKERS[C_PAREN_CLOSE] = true;\n\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\n  while (index < length) {\n    character = value.charAt(index);\n\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\n    index++;\n  }\n\n  if (size >= TAB_SIZE) {\n    return;\n  }\n\n  character = value.charAt(index);\n\n  markers = commonmark ?\n    LIST_ORDERED_COMMONMARK_MARKERS :\n    LIST_ORDERED_MARKERS;\n\n  if (LIST_UNORDERED_MARKERS[character] === true) {\n    marker = character;\n    ordered = false;\n  } else {\n    ordered = true;\n    queue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (!decimal(character)) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    character = value.charAt(index);\n\n    if (!queue || markers[character] !== true) {\n      return;\n    }\n\n    start = parseInt(queue, 10);\n    marker = character;\n  }\n\n  character = value.charAt(++index);\n\n  if (character !== C_SPACE && character !== C_TAB) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  index = 0;\n  items = [];\n  allLines = [];\n  emptyLines = [];\n\n  while (index < length) {\n    nextIndex = value.indexOf(C_NEWLINE, index);\n    startIndex = index;\n    prefixed = false;\n    indented = false;\n\n    if (nextIndex === -1) {\n      nextIndex = length;\n    }\n\n    end = index + TAB_SIZE;\n    size = 0;\n\n    while (index < length) {\n      character = value.charAt(index);\n\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\n      index++;\n    }\n\n    if (size >= TAB_SIZE) {\n      indented = true;\n    }\n\n    if (item && size >= item.indent) {\n      indented = true;\n    }\n\n    character = value.charAt(index);\n    currentMarker = null;\n\n    if (!indented) {\n      if (LIST_UNORDERED_MARKERS[character] === true) {\n        currentMarker = character;\n        index++;\n        size++;\n      } else {\n        queue = '';\n\n        while (index < length) {\n          character = value.charAt(index);\n\n          if (!decimal(character)) {\n            break;\n          }\n\n          queue += character;\n          index++;\n        }\n\n        character = value.charAt(index);\n        index++;\n\n        if (queue && markers[character] === true) {\n          currentMarker = character;\n          size += queue.length + 1;\n        }\n      }\n\n      if (currentMarker) {\n        character = value.charAt(index);\n\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\n          while (index < end) {\n            if (value.charAt(index) !== C_SPACE) {\n              break;\n            }\n\n            index++;\n            size++;\n          }\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\n    if (currentMarker) {\n      if (!pedantic && marker !== currentMarker) {\n        break;\n      }\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\n      prefixed = false;\n      index = startIndex;\n    }\n\n    line = value.slice(startIndex, nextIndex);\n    content = startIndex === index ? line : value.slice(index, nextIndex);\n\n    if (\n      currentMarker === C_ASTERISK ||\n      currentMarker === C_UNDERSCORE ||\n      currentMarker === C_DASH\n    ) {\n      if (tokenizers.thematicBreak.call(self, eat, line, true)) {\n        break;\n      }\n    }\n\n    prevEmpty = empty;\n    empty = !trim(content).length;\n\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\n      item = {\n        value: [line],\n        indent: size,\n        trail: []\n      };\n\n      items.push(item);\n      allLines = allLines.concat(emptyLines, line);\n      emptyLines = [];\n    } else if (empty) {\n      if (prevEmpty) {\n        break;\n      }\n\n      emptyLines.push(line);\n    } else {\n      if (prevEmpty) {\n        break;\n      }\n\n      if (interrupt(interuptors, tokenizers, self, [eat, line, true])) {\n        break;\n      }\n\n      item.value = item.value.concat(emptyLines, line);\n      allLines = allLines.concat(emptyLines, line);\n      emptyLines = [];\n    }\n\n    index = nextIndex + 1;\n  }\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\n  enterTop = self.enterList();\n  exitBlockquote = self.enterBlock();\n  isLoose = false;\n  index = -1;\n  length = items.length;\n\n  while (++index < length) {\n    item = items[index].value.join(C_NEWLINE);\n    now = eat.now();\n\n    item = eat(item)(listItem(self, item, now), node);\n\n    if (item.loose) {\n      isLoose = true;\n    }\n\n    item = items[index].trail.join(C_NEWLINE);\n\n    if (index !== length - 1) {\n      item += C_NEWLINE;\n    }\n\n    eat(item);\n  }\n\n  enterTop();\n  exitBlockquote();\n\n  node.loose = isLoose;\n\n  return node;\n}\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\n  value = fn.apply(null, arguments);\n\n  if (ctx.options.gfm) {\n    task = value.match(EXPRESSION_TASK_ITEM);\n\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\n  return {\n    type: 'listItem',\n    loose: EXPRESSION_LOOSE_LIST_ITEM.test(value) ||\n      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\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\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\n  lines = value.split(C_NEWLINE);\n\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\n  offsets[line] = (offsets[line] || 0) + bullet.length;\n  line++;\n\n  index = 0;\n  length = lines.length;\n\n  while (++index < length) {\n    offsets[line] = (offsets[line] || 0) +\n      lines[index].length - trimmedLines[index].length;\n    line++;\n  }\n\n  return trimmedLines.join(C_NEWLINE);\n\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\n    max = $1 + repeat(C_SPACE, $2.length) + $3;\n\n    return max + rest;\n  }\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\n\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\n  if (character !== '\\n') {\n    return;\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n\n  index = 1;\n  length = value.length;\n  subvalue = character;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (!whitespace(character)) {\n      break;\n    }\n\n    queue += character;\n\n    if (character === '\\n') {\n      subvalue += queue;\n      queue = '';\n    }\n\n    index++;\n  }\n\n  eat(subvalue);\n}\n","'use strict';\n\nvar trim = require('trim');\nvar decimal = require('is-decimal');\nvar trimTrailingLines = require('trim-trailing-lines');\nvar interrupt = require('../util/interrupt');\n\nmodule.exports = paragraph;\n\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\n\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\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\n      while (position < length) {\n        character = value.charAt(position);\n\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\n        position++;\n      }\n\n      if (size >= TAB_SIZE) {\n        index = value.indexOf(C_NEWLINE, index + 1);\n        continue;\n      }\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 (\n      tokenizers.list.call(self, eat, subvalue, true) &&\n      (\n        self.inList ||\n        commonmark ||\n        (gfm && !decimal(trim.left(subvalue).charAt(0)))\n      )\n    ) {\n      break;\n    }\n\n    position = index;\n    index = value.indexOf(C_NEWLINE, index + 1);\n\n    if (index !== -1 && trim(value.slice(position, index)) === '') {\n      index = position;\n      break;\n    }\n  }\n\n  subvalue = value.slice(0, index);\n\n  if (trim(subvalue) === '') {\n    eat(subvalue);\n\n    return null;\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n\n  now = eat.now();\n  subvalue = trimTrailingLines(subvalue);\n\n  return eat(subvalue)({\n    type: 'paragraph',\n    children: self.tokenizeInline(subvalue, now)\n  });\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/link');\nvar normalize = require('../util/normalize');\n\nmodule.exports = reference;\nreference.locator = locate;\n\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 = ']';\n\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\n  if (character !== C_BRACKET_OPEN) {\n    return;\n  }\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\n    intro += C_CARET;\n    index++;\n    type = T_FOOTNOTE;\n  }\n\n  /* Eat the text. */\n  depth = 0;\n\n  while (index < length) {\n    character = value.charAt(index);\n\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\n      depth--;\n    }\n\n    if (character === C_BACKSLASH) {\n      queue += C_BACKSLASH;\n      character = value.charAt(++index);\n    }\n\n    queue += character;\n    index++;\n  }\n\n  subvalue = queue;\n  content = queue;\n  character = value.charAt(index);\n\n  if (character !== C_BRACKET_CLOSE) {\n    return;\n  }\n\n  index++;\n  subvalue += character;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (!whitespace(character)) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\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\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character === C_BRACKET_OPEN || character === C_BRACKET_CLOSE) {\n        break;\n      }\n\n      if (character === C_BACKSLASH) {\n        identifier += C_BACKSLASH;\n        character = value.charAt(++index);\n      }\n\n      identifier += character;\n      index++;\n    }\n\n    character = value.charAt(index);\n\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\n    subvalue += queue;\n    queue = '';\n  } else {\n    if (!content) {\n      return;\n    }\n\n    identifier = content;\n  }\n\n  /* Brackets cannot be inside the identifier. */\n  if (referenceType !== REFERENCE_TYPE_FULL && bracketed) {\n    return;\n  }\n\n  subvalue = intro + subvalue;\n\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\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\n  now = eat.now();\n  now.column += intro.length;\n  now.offset += intro.length;\n  identifier = referenceType === REFERENCE_TYPE_FULL ? identifier : content;\n\n  node = {\n    type: type + 'Reference',\n    identifier: normalize(identifier)\n  };\n\n  if (type === T_LINK || type === T_IMAGE) {\n    node.referenceType = referenceType;\n  }\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\n  return eat(subvalue)(node);\n}\n","'use strict';\n\nvar trim = require('trim');\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/strong');\n\nmodule.exports = strong;\nstrong.locator = locate;\n\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\n\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\n  if (\n    (character !== C_ASTERISK && character !== C_UNDERSCORE) ||\n    value.charAt(++index) !== character\n  ) {\n    return;\n  }\n\n  pedantic = self.options.pedantic;\n  marker = character;\n  subvalue = marker + marker;\n  length = value.length;\n  index++;\n  queue = '';\n  character = '';\n\n  if (pedantic && whitespace(value.charAt(index))) {\n    return;\n  }\n\n  while (index < length) {\n    prev = character;\n    character = value.charAt(index);\n\n    if (\n      character === marker &&\n      value.charAt(index + 1) === marker &&\n      (!pedantic || !whitespace(prev))\n    ) {\n      character = value.charAt(index + 2);\n\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\n        now = eat.now();\n        now.column += 2;\n        now.offset += 2;\n\n        return eat(subvalue + queue + subvalue)({\n          type: 'strong',\n          children: self.tokenizeInline(queue, now)\n        });\n      }\n    }\n\n    if (!pedantic && character === '\\\\') {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    queue += character;\n    index++;\n  }\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\n\nmodule.exports = table;\n\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';\n\nvar MIN_TABLE_COLUMNS = 1;\nvar MIN_TABLE_ROWS = 2;\n\nvar TABLE_ALIGN_LEFT = 'left';\nvar TABLE_ALIGN_CENTER = 'center';\nvar TABLE_ALIGN_RIGHT = 'right';\nvar TABLE_ALIGN_NONE = null;\n\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\n  while (index < length) {\n    lineIndex = value.indexOf(C_NEWLINE, index);\n    pipeIndex = value.indexOf(C_PIPE, index + 1);\n\n    if (lineIndex === -1) {\n      lineIndex = value.length;\n    }\n\n    if (pipeIndex === -1 || pipeIndex > lineIndex) {\n      if (lineCount < MIN_TABLE_ROWS) {\n        return;\n      }\n\n      break;\n    }\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\n  while (index < length) {\n    character = alignments.charAt(index);\n\n    if (character === C_PIPE) {\n      hasDash = null;\n\n      if (alignment === false) {\n        if (first === false) {\n          return;\n        }\n      } else {\n        align.push(alignment);\n        alignment = false;\n      }\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\n    index++;\n  }\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\n  table = eat(subvalue).reset({\n    type: 'table',\n    align: align,\n    children: rows\n  });\n\n  while (++position < lineCount) {\n    line = lines[position];\n    row = {type: 'tableRow', children: []};\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\n    length = line.length + 1;\n    index = 0;\n    queue = '';\n    cell = '';\n    preamble = true;\n    count = null;\n    opening = null;\n\n    while (index < length) {\n      character = line.charAt(index);\n\n      if (character === C_TAB || character === C_SPACE) {\n        if (cell) {\n          queue += character;\n        } else {\n          eat(character);\n        }\n\n        index++;\n        continue;\n      }\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\n          if ((cell || character) && !preamble) {\n            subvalue = cell;\n\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\n            now = eat.now();\n\n            eat(subvalue)({\n              type: 'tableCell',\n              children: self.tokenizeInline(cell, now)\n            }, row);\n          }\n\n          eat(queue + character);\n\n          queue = '';\n          cell = '';\n        }\n      } else {\n        if (queue) {\n          cell += queue;\n          queue = '';\n        }\n\n        cell += character;\n\n        if (character === C_BACKSLASH && index !== length - 2) {\n          cell += line.charAt(index + 1);\n          index++;\n        }\n\n        if (character === C_TICK) {\n          count = 1;\n\n          while (line.charAt(index + 1) === character) {\n            cell += character;\n            index++;\n            count++;\n          }\n\n          if (!opening) {\n            opening = count;\n          } else if (count >= opening) {\n            opening = 0;\n          }\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\n  return table;\n}\n","'use strict';\n\nmodule.exports = text;\n\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\n  methods = self.inlineMethods;\n  length = methods.length;\n  tokenizers = self.inlineTokenizers;\n  index = -1;\n  min = value.length;\n\n  while (++index < length) {\n    name = methods[index];\n\n    if (name === 'text' || !tokenizers[name]) {\n      continue;\n    }\n\n    tokenizer = tokenizers[name].locator;\n\n    if (!tokenizer) {\n      eat.file.fail('Missing locator: `' + name + '`');\n    }\n\n    position = tokenizer.call(self, value, 1);\n\n    if (position !== -1 && position < min) {\n      min = position;\n    }\n  }\n\n  subvalue = value.slice(0, min);\n  now = eat.now();\n\n  self.decode(subvalue, now, function (content, position, source) {\n    eat(source || content)({\n      type: 'text',\n      value: content\n    });\n  });\n}\n","'use strict';\n\nmodule.exports = thematicBreak;\n\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\nvar C_DASH = '-';\n\nvar THEMATIC_BREAK_MARKER_COUNT = 3;\n\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\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n\n    subvalue += character;\n  }\n\n  if (\n    character !== C_ASTERISK &&\n    character !== C_DASH &&\n    character !== C_UNDERSCORE\n  ) {\n    return;\n  }\n\n  marker = character;\n  subvalue += character;\n  markerCount = 1;\n  queue = '';\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character === marker) {\n      markerCount++;\n      subvalue += queue + marker;\n      queue = '';\n    } else if (character === C_SPACE) {\n      queue += character;\n    } else if (\n      markerCount >= THEMATIC_BREAK_MARKER_COUNT &&\n      (!character || character === C_NEWLINE)\n    ) {\n      subvalue += queue;\n\n      if (silent) {\n        return true;\n      }\n\n      return eat(subvalue)({type: 'thematicBreak'});\n    } else {\n      return;\n    }\n  }\n}\n","'use strict';\n\nvar decode = require('parse-entities');\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/url');\n\nmodule.exports = url;\nurl.locator = locate;\nurl.notInLink = true;\n\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\nvar C_PAREN_OPEN = '(';\nvar C_PAREN_CLOSE = ')';\nvar C_LT = '<';\nvar C_AT_SIGN = '@';\n\nvar HTTP_PROTOCOL = 'http://';\nvar HTTPS_PROTOCOL = 'https://';\nvar MAILTO_PROTOCOL = 'mailto:';\n\nvar PROTOCOLS = [\n  HTTP_PROTOCOL,\n  HTTPS_PROTOCOL,\n  MAILTO_PROTOCOL\n];\n\nvar PROTOCOLS_LENGTH = PROTOCOLS.length;\n\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\n  if (!self.options.gfm) {\n    return;\n  }\n\n  subvalue = '';\n  index = -1;\n  length = PROTOCOLS_LENGTH;\n\n  while (++index < length) {\n    protocol = PROTOCOLS[index];\n    match = value.slice(0, protocol.length);\n\n    if (match.toLowerCase() === protocol) {\n      subvalue = match;\n      break;\n    }\n  }\n\n  if (!subvalue) {\n    return;\n  }\n\n  index = subvalue.length;\n  length = value.length;\n  queue = '';\n  parenCount = 0;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (whitespace(character) || character === C_LT) {\n      break;\n    }\n\n    if (\n      character === '.' ||\n      character === ',' ||\n      character === ':' ||\n      character === ';' ||\n      character === '\"' ||\n      character === '\\'' ||\n      character === ')' ||\n      character === ']'\n    ) {\n      nextCharacter = value.charAt(index + 1);\n\n      if (!nextCharacter || whitespace(nextCharacter)) {\n        break;\n      }\n    }\n\n    if (character === C_PAREN_OPEN || character === C_BRACKET_OPEN) {\n      parenCount++;\n    }\n\n    if (character === C_PAREN_CLOSE || character === C_BRACKET_CLOSE) {\n      parenCount--;\n\n      if (parenCount < 0) {\n        break;\n      }\n    }\n\n    queue += character;\n    index++;\n  }\n\n  if (!queue) {\n    return;\n  }\n\n  subvalue += queue;\n  content = subvalue;\n\n  if (protocol === MAILTO_PROTOCOL) {\n    position = queue.indexOf(C_AT_SIGN);\n\n    if (position === -1 || position === length - 1) {\n      return;\n    }\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\n  exit = self.enterLink();\n  content = self.tokenizeInline(content, eat.now());\n  exit();\n\n  return eat(subvalue)({\n    type: 'link',\n    title: null,\n    url: decode(subvalue, {nonTerminated: false}),\n    children: content\n  });\n}\n","'use strict';\n\nmodule.exports = factory;\n\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\n  if (node.type !== 'text' || !node.position) {\n    return true;\n  }\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 ||\n      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\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\n  prev.children = prev.children.concat(node.children);\n\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\n      while (++index < length) {\n        name = methods[index];\n        method = tokenizers[name];\n\n        if (\n          method &&\n          /* istanbul ignore next */ (!method.onlyAtStart || self.atStart) &&\n          (!method.notInList || !self.inList) &&\n          (!method.notInBlock || !self.inBlock) &&\n          (!method.notInLink || !self.inLink)\n        ) {\n          valueLength = value.length;\n\n          method.apply(self, [eat, value]);\n\n          matched = valueLength !== value.length;\n\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\n    self.eof = now();\n\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\n      while (index !== -1) {\n        line++;\n        lastIndex = index;\n        index = subvalue.indexOf('\\n', index + 1);\n      }\n\n      if (lastIndex === -1) {\n        column += subvalue.length;\n      } else {\n        column = subvalue.length - lastIndex;\n      }\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\n        while (pos < last) {\n          indentation.push((offset[pos] || 0) + 1);\n\n          pos++;\n        }\n\n        return indentation;\n      };\n    }\n\n    /* Get the current position. */\n    function now() {\n      var pos = {line: line, column: column};\n\n      pos.offset = self.toOffset(pos);\n\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(\n          new Error(\n            'Incorrectly eaten value: please report this ' +\n            'warning on http://git.io/vg5Ft'\n          ),\n          now()\n        );\n      }\n    }\n\n    /* Mark position and patch `node.position`. */\n    function position() {\n      var before = now();\n\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\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\n          if (n < l) {\n            while (++n < l) {\n              combined.push((offset[n] || 0) + 1);\n            }\n\n            combined.push(before.column);\n          }\n\n          indent = combined.concat(indent);\n        }\n\n        node.position.indent = indent || [];\n\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\n      if (\n        prev &&\n        node.type === prev.type &&\n        node.type in MERGEABLE_NODES &&\n        mergeable(prev) &&\n        mergeable(node)\n      ) {\n        node = MERGEABLE_NODES[node.type].call(self, prev, node);\n      }\n\n      if (node !== prev) {\n        children.push(node);\n      }\n\n      if (self.atStart && tokens.length !== 0) {\n        self.exitStart();\n      }\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\n      validateEat(subvalue);\n\n      apply.reset = reset;\n      reset.test = test;\n      apply.test = test;\n\n      value = value.substring(subvalue.length);\n\n      updatePosition(subvalue);\n\n      indent = indent();\n\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\n        line = current.line;\n        column = current.column;\n        value = subvalue + value;\n\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\n        line = current.line;\n        column = current.column;\n        value = subvalue + value;\n\n        return result.position;\n      }\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\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\n      index = value.indexOf('\\\\', prev);\n    }\n\n    queue.push(value.slice(prev));\n\n    return queue.join('');\n  }\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 = {' ': 1, '\\t': 4};\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\n  while (character in characters) {\n    size = characters[character];\n\n    indent += size;\n\n    if (size > 1) {\n      indent = Math.floor(indent / size) * size;\n    }\n\n    stops[indent] = index;\n\n    character = value.charAt(++index);\n  }\n\n  return {indent: indent, 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]*?\\\\]\\\\]>';\n\nexports.openCloseTag = new RegExp('^(?:' + openTag + '|' + closeTag + ')');\n\nexports.tag = new RegExp('^(?:' +\n  openTag + '|' +\n  closeTag + '|' +\n  comment + '|' +\n  processing + '|' +\n  declaration + '|' +\n  cdata +\n')');\n","'use strict';\n\nmodule.exports = interrupt;\n\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\n  while (++index < length) {\n    interruptor = interruptors[index];\n    config = interruptor[1] || {};\n    fn = interruptor[0];\n    offset = -1;\n    ignore = false;\n\n    while (++offset < count) {\n      bool = bools[offset];\n\n      if (config[bool] !== undefined && config[bool] !== ctx.options[bool]) {\n        ignore = true;\n        break;\n      }\n    }\n\n    if (ignore) {\n      continue;\n    }\n\n    if (tokenizers[fn].apply(ctx, params)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n","'use strict';\n\nvar collapseWhiteSpace = require('collapse-white-space');\n\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}\n","'use strict';\n\nvar trim = require('trim');\nvar repeat = require('repeat-string');\nvar getIndent = require('./get-indentation');\n\nmodule.exports = indentation;\n\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\n  values.unshift(repeat(C_SPACE, maximum) + '!');\n\n  while (position--) {\n    indentation = getIndent(values[position]);\n\n    matrix[position] = indentation.stops;\n\n    if (trim(values[position]).length === 0) {\n      continue;\n    }\n\n    if (indentation.indent) {\n      if (indentation.indent > 0 && indentation.indent < minIndent) {\n        minIndent = indentation.indent;\n      }\n    } else {\n      minIndent = Infinity;\n\n      break;\n    }\n  }\n\n  if (minIndent !== Infinity) {\n    position = values.length;\n\n    while (position--) {\n      stops = matrix[position];\n      index = minIndent;\n\n      while (index && !(index in stops)) {\n        index--;\n      }\n\n      if (\n        trim(values[position]).length !== 0 &&\n        minIndent &&\n        index !== minIndent\n      ) {\n        padding = C_TAB;\n      } else {\n        padding = '';\n      }\n\n      values[position] = padding + values[position].slice(\n        index in stops ? stops[index] + 1 : 0\n      );\n    }\n  }\n\n  values.shift();\n\n  return values.join(C_NEWLINE);\n}\n"],"names":["unherit","require","xtend","Parser","parse","options","Local","prototype","this","data","module","exports","entities","ctx","decoder","raw","value","position","normalize","warning","handleWarning","offsets","offset","line","result","push","start","indent","reason","code","file","message","handler","text","reference","textContext","referenceContext","gfm","commonmark","footnotes","pedantic","blocks","fromIndex","index","indexOf","charAt","asterisk","underscore","link","image","length","PROTOCOLS","min","removePosition","node","self","String","column","content","replace","EXPRESSION_LINE_BREAKS","charCodeAt","slice","type","children","tokenizeBlock","end","eof","toggle","vfileLocation","unescape","decode","tokenizer","doc","setOptions","inList","inBlock","inLink","atStart","toOffset","proto","keys","key","exitStart","enterList","enterLink","enterBlock","interruptParagraph","interruptList","interruptBlockquote","blockTokenizers","newline","indentedCode","fencedCode","blockquote","atxHeading","thematicBreak","list","setextHeading","html","footnote","definition","table","paragraph","inlineTokenizers","escape","autoLink","url","strong","emphasis","deletion","break","blockMethods","inlineMethods","tokenizeInline","tokenizeFactory","escapes","defaults","current","Error","whitespace","locate","locator","notInLink","MAILTO","MAILTO_LENGTH","eat","silent","subvalue","queue","character","hasAtCharacter","now","tokenizers","exit","toLowerCase","substr","title","nonTerminated","trim","interrupt","add","rest","nextIndex","startIndex","prefixed","interruptors","currentLine","values","contents","indents","join","hardBreak","fenceCount","marker","flag","exdentedContent","closing","exdentedClosing","settings","C_SPACE","C_TAB","C_NEWLINE","lang","repeat","blankQueue","subvalueQueue","contentQueue","CODE_INDENT","inlineCode","C_TICK","subqueue","count","openingCount","found","next","tickQueue","notInList","notInBlock","C_BRACKET_CLOSE","beforeURL","beforeTitle","test","identifier","isEnclosedURLCharacter","delimiter","isUnclosedURLCharacter","strikethrough","C_TILDE","previous","preceding","word","prev","footnoteDefinition","EXPRESSION_INITIAL_TAB","C_BRACKET_OPEN","depth","C_HASH","SETEXT_MARKERS","openCloseTag","sequence","sequences","RegExp","source","alphabetical","tag","inlineHTML","EXPRESSION_HTML_LINK_OPEN","EXPRESSION_HTML_LINK_CLOSE","match","own","hasOwnProperty","C_BACKSLASH","C_PAREN_CLOSE","LINK_MARKERS","COMMONMARK_LINK_MARKERS","closed","opening","hasMarker","markers","isImage","call","alt","C_DOUBLE_QUOTE","C_SINGLE_QUOTE","C_PAREN_OPEN","decimal","getIndent","removeIndent","ordered","currentMarker","prevEmpty","empty","items","allLines","emptyLines","item","enterTop","exitBlockquote","isLoose","indented","interuptors","size","LIST_ORDERED_COMMONMARK_MARKERS","LIST_ORDERED_MARKERS","LIST_UNORDERED_MARKERS","parseInt","TAB_SIZE","concat","trail","reset","loose","listItem","EXPRESSION_LOOSE_LIST_ITEM","EXPRESSION_TASK_ITEM","EXPRESSION_BULLET","EXPRESSION_PEDANTIC_BULLET","EXPRESSION_INITIAL_INDENT","task","fn","pedanticListItem","normalListItem","checked","apply","arguments","replacer","$0","max","bullet","lines","trimmedLines","$1","$2","$3","$4","Number","split","trimTrailingLines","left","T_LINK","T_IMAGE","T_FOOTNOTE","REFERENCE_TYPE_FULL","bracketed","intro","referenceType","alignments","alignment","row","hasDash","align","cell","preamble","lineCount","rows","lineIndex","pipeIndex","first","splice","TABLE_ALIGN_LEFT","methods","name","fail","markerCount","MAILTO_PROTOCOL","PROTOCOLS_LENGTH","protocol","parenCount","nextCharacter","location","method","matched","valueLength","tokens","updatePosition","onlyAtStart","lastIndex","pos","Position","before","indentation","last","getOffset","combined","n","l","substring","validateEat","parent","MERGEABLE_NODES","mergeable","stops","characters","Math","floor","openTag","closeTag","params","interruptor","config","bool","ignore","bools","undefined","collapseWhiteSpace","maximum","padding","minIndent","Infinity","matrix","unshift","shift"],"sourceRoot":""}