{"version":3,"sources":["webpack:///./node_modules/vfile/lib/minproc.browser.js","webpack:///./node_modules/micromark/dist/initialize/text.js","webpack:///./node_modules/micromark/dist/util/move-point.js","webpack:///./node_modules/micromark/dist/tokenize/code-text.js","webpack:///./node_modules/unist-util-stringify-position/index.js","webpack:///./node_modules/micromark/dist/parse.js","webpack:///./node_modules/micromark/dist/constant/splice.js","webpack:///./node_modules/micromark/dist/initialize/content.js","webpack:///./node_modules/micromark/dist/tokenize/factory-whitespace.js","webpack:///./node_modules/micromark/dist/postprocess.js","webpack:///./node_modules/micromark/dist/util/slice-chunks.js","webpack:///./node_modules/micromark/dist/character/markdown-space.js","webpack:///./node_modules/micromark/dist/tokenize/thematic-break.js","webpack:///./node_modules/micromark/dist/tokenize/html-text.js","webpack:///./node_modules/react-markdown/lib/renderers.js","webpack:///./node_modules/micromark/dist/tokenize/character-reference.js","webpack:///./node_modules/micromark/dist/tokenize/list.js","webpack:///./node_modules/micromark/dist/util/create-tokenizer.js","webpack:///./node_modules/extend/index.js","webpack:///./node_modules/micromark/dist/tokenize/label-start-image.js","webpack:///./node_modules/micromark/dist/character/ascii-atext.js","webpack:///./node_modules/micromark/dist/character/ascii-control.js","webpack:///./node_modules/react-markdown/lib/wrap-table-rows.js","webpack:///./node_modules/micromark/dist/tokenize/factory-title.js","webpack:///./node_modules/micromark/dist/tokenize/autolink.js","webpack:///./node_modules/is-buffer/index.js","webpack:///./node_modules/micromark/dist/util/normalize-identifier.js","webpack:///./node_modules/micromark/dist/character/unicode-punctuation.js","webpack:///./node_modules/micromark/dist/tokenize/heading-atx.js","webpack:///./node_modules/micromark/dist/character/markdown-line-ending.js","webpack:///./node_modules/trough/wrap.js","webpack:///./node_modules/micromark/dist/constant/from-char-code.js","webpack:///./node_modules/vfile/index.js","webpack:///./node_modules/micromark/dist/util/serialize-chunks.js","webpack:///./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/color.browser.js","webpack:///./node_modules/bail/index.js","webpack:///./node_modules/micromark/dist/util/chunked-push.js","webpack:///./node_modules/micromark/dist/tokenize/definition.js","webpack:///./node_modules/mdast-util-to-string/index.js","webpack:///./node_modules/micromark/dist/tokenize/label-start-link.js","webpack:///./node_modules/micromark/dist/util/resolve-all.js","webpack:///./node_modules/react-markdown/lib/get-definitions.js","webpack:///./node_modules/react-markdown/lib/react-markdown.js","webpack:///./node_modules/micromark/dist/tokenize/setext-underline.js","webpack:///./node_modules/micromark/dist/constant/html-raw-names.js","webpack:///./node_modules/micromark/dist/tokenize/html-flow.js","webpack:///./node_modules/micromark/dist/initialize/flow.js","webpack:///./node_modules/mdast-util-from-markdown/index.js","webpack:///./node_modules/micromark/dist/constant/unicode-punctuation-regex.js","webpack:///./node_modules/micromark/dist/util/subtokenize.js","webpack:///./node_modules/micromark/dist/tokenize/code-indented.js","webpack:///./node_modules/micromark/dist/constant/assign.js","webpack:///./node_modules/react-markdown/lib/uri-transformer.js","webpack:///./node_modules/micromark/dist/character/ascii-alphanumeric.js","webpack:///./node_modules/micromark/dist/util/prefix-size.js","webpack:///./node_modules/micromark/dist/tokenize/label-end.js","webpack:///./node_modules/vfile/lib/index.js","webpack:///./node_modules/micromark/dist/tokenize/code-fenced.js","webpack:///./node_modules/micromark/dist/character/markdown-line-ending-or-space.js","webpack:///./node_modules/micromark/dist/character/ascii-hex-digit.js","webpack:///./node_modules/micromark/dist/constant/html-block-names.js","webpack:///./node_modules/micromark/dist/constructs.js","webpack:///./node_modules/micromark/dist/util/shallow.js","webpack:///./node_modules/micromark/dist/constant/has-own-property.js","webpack:///./node_modules/xtend/immutable.js","webpack:///./node_modules/react-markdown/lib/ast-to-react.js","webpack:///./node_modules/micromark/dist/tokenize/character-escape.js","webpack:///./node_modules/micromark/dist/tokenize/partial-blank-line.js","webpack:///./node_modules/micromark/dist/util/chunked-splice.js","webpack:///./node_modules/parse-entities/decode-entity.browser.js","webpack:///./node_modules/react-markdown/node_modules/react-is/cjs/react-is.production.min.js","webpack:///./node_modules/react-markdown/node_modules/is-plain-obj/index.js","webpack:///./node_modules/micromark/dist/initialize/document.js","webpack:///./node_modules/micromark/dist/util/safe-from-int.js","webpack:///./node_modules/react-markdown/node_modules/unified/index.js","webpack:///./node_modules/unist-util-is/convert.js","webpack:///./node_modules/unist-util-visit/index.js","webpack:///./node_modules/vfile-message/index.js","webpack:///./node_modules/react-markdown/lib/plugins/naive-html.js","webpack:///./node_modules/micromark/dist/tokenize/attention.js","webpack:///./node_modules/micromark/dist/tokenize/line-ending.js","webpack:///./node_modules/micromark/dist/util/classify-character.js","webpack:///./node_modules/micromark/dist/tokenize/hard-break-escape.js","webpack:///./node_modules/react-markdown/lib/symbols.js","webpack:///./node_modules/micromark/dist/tokenize/factory-destination.js","webpack:///./node_modules/micromark/dist/character/ascii-alpha.js","webpack:///./node_modules/micromark/dist/util/size-chunks.js","webpack:///./node_modules/micromark/dist/tokenize/block-quote.js","webpack:///./node_modules/micromark/dist/tokenize/factory-label.js","webpack:///./node_modules/micromark/dist/character/ascii-digit.js","webpack:///./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js","webpack:///./node_modules/micromark/dist/preprocess.js","webpack:///./node_modules/micromark/dist/util/combine-extensions.js","webpack:///./node_modules/micromark/dist/util/miniflat.js","webpack:///./node_modules/micromark/dist/character/ascii-punctuation.js","webpack:///./node_modules/micromark/dist/tokenize/content.js","webpack:///./node_modules/react-markdown/node_modules/react-is/index.js","webpack:///./node_modules/micromark/dist/util/regex-check.js","webpack:///./node_modules/vfile/lib/core.js","webpack:///./node_modules/react-markdown/lib/plugins/disallow-node.js","webpack:///./node_modules/micromark/dist/character/unicode-whitespace.js","webpack:///./node_modules/vfile/lib/minpath.browser.js","webpack:///./node_modules/unist-util-visit-parents/index.js","webpack:///./node_modules/react-markdown/node_modules/remark-parse/index.js","webpack:///./node_modules/mdast-util-from-markdown/dist/index.js","webpack:///./node_modules/mdast-add-list-metadata/index.js","webpack:///./node_modules/trough/index.js","webpack:///./node_modules/micromark/dist/tokenize/factory-space.js"],"names":["exports","cwd","Object","defineProperty","value","assign","shallow","text","initializeFactory","string","resolver","resolveAll","createResolver","field","tokenize","effects","self","this","constructs","parser","attempt","start","notText","code","atBreak","enter","consume","data","exit","list","index","length","previous","call","resolveAllLineSuffixes","undefined","extraResolver","events","context","type","end","splice","chunks","chunk","bufferIndex","size","tabs","token","eventIndex","sliceStream","charCodeAt","line","column","offset","_index","_bufferIndex","module","point","markdownLineEnding","codeText","name","ok","nok","sizeOpen","openingSequence","gap","closingSequence","resolve","tailExitIndex","headEnterIndex","own","hasOwnProperty","position","pos","content","document","flow","combineExtensions","createTokenizer","miniflat","options","defined","concat","extensions","create","initializer","from","factorySpace","contentStart","contentInitial","lineStart","contentType","next","markdownSpace","seen","subtokenize","view","startIndex","startBufferIndex","endIndex","endBufferIndex","slice","push","thematicBreak","marker","sequence","asciiAlpha","asciiAlphanumeric","markdownLineEndingOrSpace","htmlText","buffer","returnState","open","declarationOpen","tagCloseStart","instruction","tagOpen","commentOpen","cdataOpen","declaration","commentStart","commentStartDash","comment","commentClose","atLineEnding","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","afterPrefix","disable","null","indexOf","xtend","React","supportsStringRender","parseInt","version","createElement","SimpleRenderer","tag","props","getCoreProps","children","source","break","paragraph","emphasis","strong","blockquote","delete","link","image","linkReference","imageReference","table","bind","tableHead","tableBody","tableRow","tableCell","style","align","textAlign","coreProps","isHeader","root","className","Fragment","attrs","toString","ordered","listItem","checkbox","checked","readOnly","definition","heading","level","inlineCode","language","html","skipHtml","dangerous","allowDangerousHtml","escapeHtml","isBlock","nodeProps","dangerouslySetInnerHTML","__html","virtualHtml","parsedHtml","cloneElement","element","decodeEntity","asciiDigit","asciiHexDigit","_interopDefaultLegacy","e","default","decodeEntity__default","characterReference","max","test","numeric","sliceSerialize","prefixSize","sizeChunks","partialBlankLine","initialSize","kind","containerState","_container","check","atMarker","interrupt","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","continuation","_closeFlow","furtherBlankLines","notInCurrentItem","indentConstruct","partial","chunkedPush","chunkedSplice","serializeChunks","sliceChunks","initialize","columnStart","resolveAllConstructs","stack","accountForPotentialSkip","fields","now","pop","constructFactory","construct","info","addResult","onsuccessfulcheck","lazy","defineSkip","write","main","state","chunkIndex","go","restore","onreturn","bogusState","listOfConstructs","constructIndex","currentConstruct","handleListOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","Array","store","resolveTo","hasOwn","prototype","toStr","gOPD","getOwnPropertyDescriptor","isArray","arr","isPlainObject","obj","key","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","enumerable","configurable","newValue","writable","getProperty","extend","src","copy","copyIsArray","clone","arguments","i","deep","labelStartImage","after","asciiAtext","regexCheck","visit","wrap","node","markerType","stringType","atFirstTitleBreak","atTitleBreak","title","titleEscape","asciiControl","autolink","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","isBuffer","replace","toLowerCase","toUpperCase","unicodePunctuationRegex","unicodePunctuation","headingAtx","fenceOpenInside","headingBreak","contentEnd","fn","callback","invoked","result","params","done","apply","error","then","Error","fromCharCode","String","atTab","join","d","err","items","normalizeIdentifier","factoryDestination","factoryLabel","factoryWhitespace","factoryTitle","identifier","labelAfter","titleConstruct","before","alt","all","values","labelStartLink","called","tree","definitions","href","url","unified","parse","PropTypes","addListMetadata","naiveHtml","disallowNode","astToReact","wrapTableRows","getDefinitions","uriTransformer","defaultRenderers","symbols","allTypes","keys","ReactMarkdown","allowedTypes","disallowedTypes","renderers","processor","use","plugins","runSync","renderProps","transforms","filter","removalMethod","unwrapDisallowed","ofType","allowNode","ifNotMatch","renderHtml","hasHtmlParser","astPlugins","some","transform","identity","HtmlParser","determineAstToReactTransforms","forEach","defaultProps","transformLinkUri","propTypes","sourcePos","bool","rawSourcePos","func","arrayOf","oneOf","oneOfType","linkTarget","transformImageUri","object","array","types","setextUnderline","closingSequenceEnd","htmlBlockNames","htmlRawNames","htmlFlow","startTag","declarationStart","continuationDeclarationInside","tagName","commentOpenInside","cdataOpenInside","basicSelfClosing","completeAttributeNameBefore","completeClosingTagAfter","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCharacterDataInside","continuationAtLineEnding","nextBlankConstruct","htmlContinueStart","continuationRawEndTag","concrete","initial","flowInitial","afterConstruct","subcontent","stream","entered","adjust","startPosition","startPositions","tokenizer","_tokenizer","childEvents","jumps","gaps","isInFirstContentOfListItem","_gfmTasklistFirstContentOfListItem","add","unshift","event","lineIndex","otherIndex","otherEvent","parameters","subevents","more","_movePreviousLineEndings","codeIndented","indentedContentConstruct","protocols","uri","trim","first","charAt","colon","protocol","tail","labelEnd","labelStart","_balanced","_inactive","balanced","afterLabelEnd","resourceConstruct","fullReferenceConstruct","collapsedReferenceConstruct","group","label","close","media","insideSpan","_used","destinationAfter","between","afterLabel","VMessage","VFile","message","reason","origin","path","file","fatal","messages","fail","codeFenced","closingFenceConstruct","initialPrefix","sequenceOpen","infoOpen","openAfter","infoAfter","meta","contentContinue","text$1","attention","blockQuote","characterEscape","hardBreakEscape","lineEnding","42","43","45","48","49","50","51","52","53","54","55","56","57","62","91","32","35","60","61","95","96","126","38","92","33","93","ReactIs","parent","renderer","isValidElementType","getNodeProps","resolveChildren","map","childNode","opts","isSimpleRenderer","sourcePosition","includeNodeIndex","parentChildCount","ref","assignDefined","nodeKey","depth","spread","loose","listItemLoose","listLoose","reduce","child","unwrapParagraphs","getListItemChildren","lang","split","inline","columnAlignment","parsedChildren","el","Children","toArray","mergeNodeChildren","asciiPunctuation","remove","chunkStart","characters","char","entity","innerHTML","textContent","b","Symbol","for","c","f","g","h","k","l","m","n","p","q","r","t","v","w","x","y","z","a","u","$$typeof","A","AsyncMode","ConcurrentMode","ContextConsumer","ContextProvider","Element","ForwardRef","Lazy","Memo","Portal","Profiler","StrictMode","Suspense","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isFragment","isLazy","isMemo","isPortal","isProfiler","isStrictMode","isSuspense","typeOf","getPrototypeOf","inspectResult","childFlow","childToken","continued","inspectConstruct","subcontinued","inspectStart","inspectContinue","inspectLess","flowContinue","inspectDone","interruptible","containerConstruct","inspectFlowEnd","lazyFlowConstruct","inspectLazy","flowEnd","documentContinue","documentContinued","flowStart","containerContinue","exitContainers","continueFlow","documentAfterPeek","base","bail","plain","trough","vfile","frozen","attachers","transformers","namespace","freezeIndex","assertUnfrozen","freeze","settings","addPlugin","addList","addPreset","plugin","entry","find","doc","Parser","assertParser","newable","stringify","Compiler","assertCompiler","assertNode","compile","run","complete","assertDone","process","processSync","destination","transformer","Infinity","cb","Promise","executor","reject","pipeline","ctx","contents","asyncName","convert","Boolean","typeFactory","tests","checks","anyFactory","allFactory","visitParents","CONTINUE","SKIP","EXIT","visitor","reverse","parents","VMessagePrototype","proto","parts","range","location","parseOrigin","ruleId","selfClosingRe","simpleTagRe","currentParent","selfClosing","match","getSelfClosing","current","opening","getSimpleTag","matching","matchingTag","findAndPull","fromNode","toNode","fromIndex","toIndex","indent","virtual","classifyCharacter","movePoint","_open","_close","nextEvents","unicodeWhitespace","literalType","literalMarkerType","rawType","limit","balance","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","labelEscape","color","step","is","factory","displayName","subresult","grandparents","toResult","search","atCarriageReturn","encoding","endPosition","lastIndex","exec","Math","ceil","extension","hook","left","right","existing","continuationConstruct","prefixed","regex","proc","order","prop","history","assertPart","part","sep","assertNonEmpty","assertPath","get","set","dirname","basename","extname","stem","allow","mode","includes","normalize","absolute","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","lastIndexOf","normalizeString","TypeError","JSON","ext","firstNonSlashEnd","seenNonSlash","extIndex","unmatchedSlash","startDot","startPart","preDotState","joined","one","fromMarkdown","mdastExtensions","config","configure","canContainEols","opener","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","hardBreak","hardBreakTrailing","htmlFlowData","htmlTextData","_spread","listItemValue","getData","setData","listOrdered","listUnordered","reference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","closer","atxHeadingSequence","onexitdata","characterEscapeValue","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","safeFromInt","decode","resume","codeFencedFence","onexithardbreak","referenceType","fragment","labelText","resource","setextHeadingLineSequence","setextHeadingText","handler","listStart","tokenStack","listStack","prepareList","stringifyPosition","tailIndex","tailEvent","firstBlankLineIndex","containerBalance","listSpread","and","siblings","compiler","postprocess","preprocessor","visitWithParents","ast","listNode","fns","middleware","input","prefix"],"mappings":"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","file":"6c96444697eaae0b820a41f83f2927398fa02de2-a53d6928cde2bf627c8e.js","sourcesContent":["'use strict'; // Somewhat based on:\n// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.\n// But I don’t think one tiny line of code can be copyrighted. 😅\n\nexports.cwd = cwd;\n\nfunction cwd() {\n  return '/';\n}","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar assign = require('../constant/assign.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar text = initializeFactory('text');\nvar string = initializeFactory('string');\nvar resolver = {\n  resolveAll: createResolver()\n};\n\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined)\n  };\n\n  function initializeText(effects) {\n    var self = this;\n    var constructs = this.parser.constructs[field];\n    var text = effects.attempt(constructs, start, notText);\n    return start;\n\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n\n      effects.enter('data');\n      effects.consume(code);\n      return data;\n    }\n\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data');\n        return text(code);\n      } // Data.\n\n\n      effects.consume(code);\n      return data;\n    }\n\n    function atBreak(code) {\n      var list = constructs[code];\n      var index = -1;\n\n      if (code === null) {\n        return true;\n      }\n\n      if (list) {\n        while (++index < list.length) {\n          if (!list[index].previous || list[index].previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n    }\n  }\n}\n\nfunction createResolver(extraResolver) {\n  return resolveAllText;\n\n  function resolveAllText(events, context) {\n    var index = -1;\n    var enter; // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === 'data') {\n          enter = index;\n          index++;\n        }\n      } else if (!events[index] || events[index][1].type !== 'data') {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end;\n          events.splice(enter + 2, index - enter - 2);\n          index = enter + 2;\n        }\n\n        enter = undefined;\n      }\n    }\n\n    return extraResolver ? extraResolver(events, context) : events;\n  }\n} // A rather ugly set of instructions which again looks at chunks in the input\n// stream.\n// The reason to do this here is that it is *much* faster to parse in reverse.\n// And that we can’t hook into `null` to split the line suffix before an EOF.\n// To do: figure out if we can make this into a clean utility, or even in core.\n// As it will be useful for GFMs literal autolink extension (and maybe even\n// tables?)\n\n\nfunction resolveAllLineSuffixes(events, context) {\n  var eventIndex = -1;\n  var chunks;\n  var data;\n  var chunk;\n  var index;\n  var bufferIndex;\n  var size;\n  var tabs;\n  var token;\n\n  while (++eventIndex <= events.length) {\n    if ((eventIndex === events.length || events[eventIndex][1].type === 'lineEnding') && events[eventIndex - 1][1].type === 'data') {\n      data = events[eventIndex - 1][1];\n      chunks = context.sliceStream(data);\n      index = chunks.length;\n      bufferIndex = -1;\n      size = 0;\n      tabs = undefined;\n\n      while (index--) {\n        chunk = chunks[index];\n\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\n          }\n\n          if (bufferIndex) break;\n          bufferIndex = -1;\n        } // Number\n        else if (chunk === -2) {\n            tabs = true;\n            size++;\n          } else if (chunk === -1) ;else {\n            // Replacement character, exit.\n            index++;\n            break;\n          }\n      }\n\n      if (size) {\n        token = {\n          type: eventIndex === events.length || tabs || size < 2 ? 'lineSuffix' : 'hardBreakTrailing',\n          start: {\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size,\n            _index: data.start._index + index,\n            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex\n          },\n          end: shallow(data.end)\n        };\n        data.end = shallow(token.start);\n\n        if (data.start.offset === data.end.offset) {\n          assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n\n      eventIndex++;\n    }\n  }\n\n  return events;\n}\n\nexports.resolver = resolver;\nexports.string = string;\nexports.text = text;","'use strict'; // chunks (replacement characters, tabs, or line endings).\n\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n  return point;\n}\n\nmodule.exports = movePoint;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous: previous\n};\n\nfunction resolveCodeText(events) {\n  var tailExitIndex = events.length - 4;\n  var headEnterIndex = 3;\n  var index;\n  var enter; // If we start and end with an EOL or a space.\n\n  if ((events[headEnterIndex][1].type === 'lineEnding' || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === 'lineEnding' || events[tailExitIndex][1].type === 'space')) {\n    index = headEnterIndex; // And we have data.\n\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === 'codeTextData') {\n        // Then we have padding.\n        events[tailExitIndex][1].type = events[headEnterIndex][1].type = 'codeTextPadding';\n        headEnterIndex += 2;\n        tailExitIndex -= 2;\n        break;\n      }\n    }\n  } // Merge adjacent spaces and data.\n\n\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === 'lineEnding') {\n      events[enter][1].type = 'codeTextData';\n\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end;\n        events.splice(enter + 2, index - enter - 2);\n        tailExitIndex -= index - enter - 2;\n        index = enter + 2;\n      }\n\n      enter = undefined;\n    }\n  }\n\n  return events;\n}\n\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === 'characterEscape';\n}\n\nfunction tokenizeCodeText(effects, ok, nok) {\n  var sizeOpen = 0;\n  var size;\n  var token;\n  return start;\n\n  function start(code) {\n    effects.enter('codeText');\n    effects.enter('codeTextSequence');\n    return openingSequence(code);\n  }\n\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return openingSequence;\n    }\n\n    effects.exit('codeTextSequence');\n    return gap(code);\n  }\n\n  function gap(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    } // Closing fence?\n    // Could also be data.\n\n\n    if (code === 96) {\n      token = effects.enter('codeTextSequence');\n      size = 0;\n      return closingSequence(code);\n    } // Tabs don’t work, and virtual spaces don’t make sense.\n\n\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return gap;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return gap;\n    } // Data.\n\n\n    effects.enter('codeTextData');\n    return data(code);\n  } // In code.\n\n\n  function data(code) {\n    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit('codeTextData');\n      return gap(code);\n    }\n\n    effects.consume(code);\n    return data;\n  } // Closing fence.\n\n\n  function closingSequence(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return closingSequence;\n    } // Done!\n\n\n    if (size === sizeOpen) {\n      effects.exit('codeTextSequence');\n      effects.exit('codeText');\n      return ok(code);\n    } // More or less accents: mark as data.\n\n\n    token.type = 'codeTextData';\n    return data(code);\n  }\n}\n\nmodule.exports = codeText;","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = stringify;\n\nfunction stringify(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return '';\n  } // Node.\n\n\n  if (own.call(value, 'position') || own.call(value, 'type')) {\n    return position(value.position);\n  } // Position.\n\n\n  if (own.call(value, 'start') || own.call(value, 'end')) {\n    return position(value);\n  } // Point.\n\n\n  if (own.call(value, 'line') || own.call(value, 'column')) {\n    return point(value);\n  } // ?\n\n\n  return '';\n}\n\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {};\n  }\n\n  return index(point.line) + ':' + index(point.column);\n}\n\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {};\n  }\n\n  return point(pos.start) + '-' + point(pos.end);\n}\n\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1;\n}","'use strict';\n\nvar content = require('./initialize/content.js');\n\nvar document = require('./initialize/document.js');\n\nvar flow = require('./initialize/flow.js');\n\nvar text = require('./initialize/text.js');\n\nvar combineExtensions = require('./util/combine-extensions.js');\n\nvar createTokenizer = require('./util/create-tokenizer.js');\n\nvar miniflat = require('./util/miniflat.js');\n\nvar constructs = require('./constructs.js');\n\nfunction parse(options) {\n  var settings = options || {};\n  var parser = {\n    defined: [],\n    constructs: combineExtensions([constructs].concat(miniflat(settings.extensions))),\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(text.string),\n    text: create(text.text)\n  };\n  return parser;\n\n  function create(initializer) {\n    return creator;\n\n    function creator(from) {\n      return createTokenizer(parser, initializer, from);\n    }\n  }\n}\n\nmodule.exports = parse;","'use strict';\n\nvar splice = [].splice;\nmodule.exports = splice;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('../tokenize/factory-space.js');\n\nvar tokenize = initializeContent;\n\nfunction initializeContent(effects) {\n  var contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\n  var previous;\n  return contentStart;\n\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, contentStart, 'linePrefix');\n  }\n\n  function paragraphInitial(code) {\n    effects.enter('paragraph');\n    return lineStart(code);\n  }\n\n  function lineStart(code) {\n    var token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous: previous\n    });\n\n    if (previous) {\n      previous.next = token;\n    }\n\n    previous = token;\n    return data(code);\n  }\n\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText');\n      effects.exit('paragraph');\n      effects.consume(code);\n      return;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      effects.exit('chunkText');\n      return lineStart;\n    } // Data.\n\n\n    effects.consume(code);\n    return data;\n  }\n}\n\nexports.tokenize = tokenize;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nfunction whitespaceFactory(effects, ok) {\n  var seen;\n  return start;\n\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      seen = true;\n      return start;\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, start, seen ? 'linePrefix' : 'lineSuffix')(code);\n    }\n\n    return ok(code);\n  }\n}\n\nmodule.exports = whitespaceFactory;","'use strict';\n\nvar subtokenize = require('./util/subtokenize.js');\n\nfunction postprocess(events) {\n  while (!subtokenize(events)) {// Empty\n  }\n\n  return events;\n}\n\nmodule.exports = postprocess;","'use strict';\n\nfunction sliceChunks(chunks, token) {\n  var startIndex = token.start._index;\n  var startBufferIndex = token.start._bufferIndex;\n  var endIndex = token.end._index;\n  var endBufferIndex = token.end._bufferIndex;\n  var view;\n\n  if (startIndex === endIndex) {\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n\n    if (startBufferIndex > -1) {\n      view[0] = view[0].slice(startBufferIndex);\n    }\n\n    if (endBufferIndex > 0) {\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n\n  return view;\n}\n\nmodule.exports = sliceChunks;","'use strict';\n\nfunction markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\nmodule.exports = markdownSpace;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\n\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  var size = 0;\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('thematicBreak');\n    marker = code;\n    return atBreak(code);\n  }\n\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence');\n      return sequence(code);\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code);\n    }\n\n    if (size < 3 || code !== null && !markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    effects.exit('thematicBreak');\n    return ok(code);\n  }\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n\n    effects.exit('thematicBreakSequence');\n    return atBreak(code);\n  }\n}\n\nmodule.exports = thematicBreak;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n};\n\nfunction tokenizeHtmlText(effects, ok, nok) {\n  var self = this;\n  var marker;\n  var buffer;\n  var index;\n  var returnState;\n  return start;\n\n  function start(code) {\n    effects.enter('htmlText');\n    effects.enter('htmlTextData');\n    effects.consume(code);\n    return open;\n  }\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n\n    return nok(code);\n  }\n\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpen;\n    }\n\n    if (code === 91) {\n      effects.consume(code);\n      buffer = 'CDATA[';\n      index = 0;\n      return cdataOpen;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n\n    return nok(code);\n  }\n\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentStart;\n    }\n\n    return nok(code);\n  }\n\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code);\n    }\n\n    if (code === 45) {\n      effects.consume(code);\n      return commentStartDash;\n    }\n\n    return comment(code);\n  }\n\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code);\n    }\n\n    return comment(code);\n  }\n\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return comment;\n  }\n\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return end;\n    }\n\n    return comment(code);\n  }\n\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === buffer.length ? cdata : cdataOpen;\n    }\n\n    return nok(code);\n  }\n\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return cdata;\n  }\n\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n\n    return cdata(code);\n  }\n\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n\n    return cdata(code);\n  }\n\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return declaration;\n  }\n\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return instruction;\n  }\n\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n\n    return nok(code);\n  }\n\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n\n    return tagCloseBetween(code);\n  }\n\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n\n    return end(code);\n  }\n\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    return nok(code);\n  }\n\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n\n    return end(code);\n  }\n\n  function tagOpenAttributeName(code) {\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n\n    return tagOpenAttributeNameAfter(code);\n  }\n\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n\n    return tagOpenBetween(code);\n  }\n\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n\n    effects.consume(code);\n    marker = undefined;\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return tagOpenAttributeValueQuotedAfter;\n    }\n\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    return nok(code);\n  }\n\n  function tagOpenAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  } // We can’t have blank lines in content, so no need to worry about empty\n  // tokens.\n\n\n  function atLineEnding(code) {\n    effects.exit('htmlTextData');\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, afterPrefix, 'linePrefix', self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n  }\n\n  function afterPrefix(code) {\n    effects.enter('htmlTextData');\n    return returnState(code);\n  }\n\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code);\n      effects.exit('htmlTextData');\n      effects.exit('htmlText');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = htmlText;","/* eslint-disable react/prop-types, react/no-multi-comp */\n'use strict';\n\nvar xtend = require('xtend');\n\nvar React = require('react');\n/* istanbul ignore next - Don’t crash on old React. */\n\n\nvar supportsStringRender = parseInt((React.version || '16').slice(0, 2), 10) >= 16;\nvar createElement = React.createElement;\nmodule.exports = {\n  break: 'br',\n  paragraph: 'p',\n  emphasis: 'em',\n  strong: 'strong',\n  thematicBreak: 'hr',\n  blockquote: 'blockquote',\n  delete: 'del',\n  link: 'a',\n  image: 'img',\n  linkReference: 'a',\n  imageReference: 'img',\n  table: SimpleRenderer.bind(null, 'table'),\n  tableHead: SimpleRenderer.bind(null, 'thead'),\n  tableBody: SimpleRenderer.bind(null, 'tbody'),\n  tableRow: SimpleRenderer.bind(null, 'tr'),\n  tableCell: TableCell,\n  root: Root,\n  text: TextRenderer,\n  list: List,\n  listItem: ListItem,\n  definition: NullRenderer,\n  heading: Heading,\n  inlineCode: InlineCode,\n  code: CodeBlock,\n  html: Html,\n  virtualHtml: VirtualHtml,\n  parsedHtml: ParsedHtml\n};\n\nfunction TextRenderer(props) {\n  /* istanbul ignore next - a text node w/o a value could be injected by plugins */\n  var children = props.children || '';\n  /* istanbul ignore next - `span` is a fallback for old React. */\n\n  return supportsStringRender ? children : createElement('span', null, children);\n}\n\nfunction Root(props) {\n  var className = props.className;\n  var root = !className && React.Fragment || 'div';\n  return createElement(root, className ? {\n    className: className\n  } : null, props.children);\n}\n\nfunction SimpleRenderer(tag, props) {\n  return createElement(tag, getCoreProps(props), props.children);\n}\n\nfunction TableCell(props) {\n  var style = props.align ? {\n    textAlign: props.align\n  } : undefined;\n  var coreProps = getCoreProps(props);\n  return createElement(props.isHeader ? 'th' : 'td', style ? xtend({\n    style: style\n  }, coreProps) : coreProps, props.children);\n}\n\nfunction Heading(props) {\n  return createElement(\"h\".concat(props.level), getCoreProps(props), props.children);\n}\n\nfunction List(props) {\n  var attrs = getCoreProps(props);\n\n  if (props.start !== null && props.start !== 1 && props.start !== undefined) {\n    attrs.start = props.start.toString();\n  }\n\n  return createElement(props.ordered ? 'ol' : 'ul', attrs, props.children);\n}\n\nfunction ListItem(props) {\n  var checkbox = null;\n\n  if (props.checked !== null && props.checked !== undefined) {\n    var checked = props.checked;\n    checkbox = createElement('input', {\n      type: 'checkbox',\n      checked: checked,\n      readOnly: true\n    });\n  }\n\n  return createElement('li', getCoreProps(props), checkbox, props.children);\n}\n\nfunction CodeBlock(props) {\n  var className = props.language && \"language-\".concat(props.language);\n  var code = createElement('code', className ? {\n    className: className\n  } : null, props.value);\n  return createElement('pre', getCoreProps(props), code);\n}\n\nfunction InlineCode(props) {\n  return createElement('code', getCoreProps(props), props.children);\n}\n\nfunction Html(props) {\n  if (props.skipHtml) {\n    return null;\n  }\n\n  var dangerous = props.allowDangerousHtml || props.escapeHtml === false;\n  var tag = props.isBlock ? 'div' : 'span';\n\n  if (!dangerous) {\n    /* istanbul ignore next - `tag` is a fallback for old React. */\n    return createElement(React.Fragment || tag, null, props.value);\n  }\n\n  var nodeProps = {\n    dangerouslySetInnerHTML: {\n      __html: props.value\n    }\n  };\n  return createElement(tag, nodeProps);\n}\n\nfunction ParsedHtml(props) {\n  /* To do: `React.cloneElement` is slow, is it really needed? */\n  return props['data-sourcepos'] ? React.cloneElement(props.element, {\n    'data-sourcepos': props['data-sourcepos']\n  }) : props.element;\n}\n\nfunction VirtualHtml(props) {\n  return createElement(props.tag, getCoreProps(props), props.children);\n}\n\nfunction NullRenderer() {\n  return null;\n}\n\nfunction getCoreProps(props) {\n  var source = props['data-sourcepos'];\n  /* istanbul ignore next - nodes from plugins w/o position */\n\n  return source ? {\n    'data-sourcepos': source\n  } : {};\n}","'use strict';\n\nvar decodeEntity = require('parse-entities/decode-entity.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar asciiDigit = require('../character/ascii-digit.js');\n\nvar asciiHexDigit = require('../character/ascii-hex-digit.js');\n\nfunction _interopDefaultLegacy(e) {\n  return e && typeof e === 'object' && 'default' in e ? e : {\n    default: e\n  };\n}\n\nvar decodeEntity__default = /*#__PURE__*/_interopDefaultLegacy(decodeEntity);\n\nvar characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\n\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  var self = this;\n  var size = 0;\n  var max;\n  var test;\n  return start;\n\n  function start(code) {\n    effects.enter('characterReference');\n    effects.enter('characterReferenceMarker');\n    effects.consume(code);\n    effects.exit('characterReferenceMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric');\n      effects.consume(code);\n      effects.exit('characterReferenceMarkerNumeric');\n      return numeric;\n    }\n\n    effects.enter('characterReferenceValue');\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\n  }\n\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter('characterReferenceMarkerHexadecimal');\n      effects.consume(code);\n      effects.exit('characterReferenceMarkerHexadecimal');\n      effects.enter('characterReferenceValue');\n      max = 6;\n      test = asciiHexDigit;\n      return value;\n    }\n\n    effects.enter('characterReferenceValue');\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n\n  function value(code) {\n    var token;\n\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue');\n\n      if (test === asciiAlphanumeric && !decodeEntity__default['default'](self.sliceSerialize(token))) {\n        return nok(code);\n      }\n\n      effects.enter('characterReferenceMarker');\n      effects.consume(code);\n      effects.exit('characterReferenceMarker');\n      effects.exit('characterReference');\n      return ok;\n    }\n\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = characterReference;","'use strict';\n\nvar asciiDigit = require('../character/ascii-digit.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar sizeChunks = require('../util/size-chunks.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar partialBlankLine = require('./partial-blank-line.js');\n\nvar thematicBreak = require('./thematic-break.js');\n\nvar list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n};\nvar listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n};\nvar indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n};\n\nfunction tokenizeListStart(effects, ok, nok) {\n  var self = this;\n  var initialSize = prefixSize(self.events, 'linePrefix');\n  var size = 0;\n  return start;\n\n  function start(code) {\n    var kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? 'listUnordered' : 'listOrdered');\n\n    if (kind === 'listUnordered' ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind;\n        effects.enter(kind, {\n          _container: true\n        });\n      }\n\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix');\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix');\n        effects.enter('listItemValue');\n        return inside(code);\n      }\n    }\n\n    return nok(code);\n  }\n\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\n    }\n\n    if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {\n      effects.exit('listItemValue');\n      return atMarker(code);\n    }\n\n    return nok(code);\n  }\n\n  function atMarker(code) {\n    effects.enter('listItemMarker');\n    effects.consume(code);\n    effects.exit('listItemMarker');\n    self.containerState.marker = self.containerState.marker || code;\n    return effects.check(partialBlankLine, // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\n  }\n\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter('listItemPrefixWhitespace');\n      effects.consume(code);\n      effects.exit('listItemPrefixWhitespace');\n      return endOfPrefix;\n    }\n\n    return nok(code);\n  }\n\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + sizeChunks(self.sliceStream(effects.exit('listItemPrefix')));\n    return ok(code);\n  }\n}\n\nfunction tokenizeListContinuation(effects, ok, nok) {\n  var self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(partialBlankLine, onBlank, notBlank);\n\n  function onBlank(code) {\n    self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine; // We have a blank line.\n    // Still, try to consume at most the items size.\n\n    return factorySpace(effects, ok, 'listItemIndent', self.containerState.size + 1)(code);\n  }\n\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;\n      return notInCurrentItem(code);\n    }\n\n    self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\n  }\n\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true; // As we’re closing flow, we’re no longer interrupting.\n\n    self.interrupt = undefined;\n    return factorySpace(effects, effects.attempt(list, ok, nok), 'linePrefix', self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4)(code);\n  }\n}\n\nfunction tokenizeIndent(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'listItemIndent', self.containerState.size + 1);\n\n  function afterPrefix(code) {\n    return prefixSize(self.events, 'listItemIndent') === self.containerState.size ? ok(code) : nok(code);\n  }\n}\n\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\n\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'listItemPrefixWhitespace', self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4 + 1);\n\n  function afterPrefix(code) {\n    return markdownSpace(code) || !prefixSize(self.events, 'listItemPrefixWhitespace') ? nok(code) : ok(code);\n  }\n}\n\nmodule.exports = list;","'use strict';\n\nvar assign = require('../constant/assign.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar chunkedPush = require('./chunked-push.js');\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nvar miniflat = require('./miniflat.js');\n\nvar resolveAll = require('./resolve-all.js');\n\nvar serializeChunks = require('./serialize-chunks.js');\n\nvar shallow = require('./shallow.js');\n\nvar sliceChunks = require('./slice-chunks.js'); // Create a tokenizer.\n// Tokenizers deal with one type of data (e.g., containers, flow, text).\n// The parser is the object dealing with it all.\n// `initialize` works like other constructs, except that only its `tokenize`\n// function is used, in which case it doesn’t receive an `ok` or `nok`.\n// `from` can be given to set the point before the first character, although\n// when further lines are indented, they must be set with `defineSkip`.\n\n\nfunction createTokenizer(parser, initialize, from) {\n  var point = from ? shallow(from) : {\n    line: 1,\n    column: 1,\n    offset: 0\n  };\n  var columnStart = {};\n  var resolveAllConstructs = [];\n  var chunks = [];\n  var stack = [];\n  var effects = {\n    consume: consume,\n    enter: enter,\n    exit: exit,\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    }),\n    lazy: constructFactory(onsuccessfulcheck, {\n      lazy: true\n    })\n  }; // State and tools for resolving and serializing.\n\n  var context = {\n    previous: null,\n    events: [],\n    parser: parser,\n    sliceStream: sliceStream,\n    sliceSerialize: sliceSerialize,\n    now: now,\n    defineSkip: skip,\n    write: write\n  }; // The state function.\n\n  var state = initialize.tokenize.call(context, effects); // Track which character we expect to be consumed, to catch bugs.\n\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize);\n  } // Store where we are in the input stream.\n\n\n  point._index = 0;\n  point._bufferIndex = -1;\n  return context;\n\n  function write(slice) {\n    chunks = chunkedPush(chunks, slice);\n    main(); // Exit if we’re not done, resolve might change stuff.\n\n    if (chunks[chunks.length - 1] !== null) {\n      return [];\n    }\n\n    addResult(initialize, 0); // Otherwise, resolve, and exit.\n\n    context.events = resolveAll(resolveAllConstructs, context.events, context);\n    return context.events;\n  } //\n  // Tools.\n  //\n\n\n  function sliceSerialize(token) {\n    return serializeChunks(sliceStream(token));\n  }\n\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n\n  function now() {\n    return shallow(point);\n  }\n\n  function skip(value) {\n    columnStart[value.line] = value.column;\n    accountForPotentialSkip();\n  } //\n  // State management.\n  //\n  // Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n  // `consume`).\n  // Here is where we walk through the chunks, which either include strings of\n  // several characters, or numerical character codes.\n  // The reason to do this in a loop instead of a call is so the stack can\n  // drain.\n\n\n  function main() {\n    var chunkIndex;\n    var chunk;\n\n    while (point._index < chunks.length) {\n      chunk = chunks[point._index]; // If we’re in a buffer chunk, loop through it.\n\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index;\n\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\n        }\n\n        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {\n          go(chunk.charCodeAt(point._bufferIndex));\n        }\n      } else {\n        go(chunk);\n      }\n    }\n  } // Deal with one code.\n\n\n  function go(code) {\n    state = state(code);\n  } // Move a character forward.\n\n\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++;\n      point.column = 1;\n      point.offset += code === -3 ? 2 : 1;\n      accountForPotentialSkip();\n    } else if (code !== -1) {\n      point.column++;\n      point.offset++;\n    } // Not in a string chunk.\n\n\n    if (point._bufferIndex < 0) {\n      point._index++;\n    } else {\n      point._bufferIndex++; // At end of string chunk.\n\n      if (point._bufferIndex === chunks[point._index].length) {\n        point._bufferIndex = -1;\n        point._index++;\n      }\n    } // Expose the previous character.\n\n\n    context.previous = code; // Mark as consumed.\n  } // Start a token.\n\n\n  function enter(type, fields) {\n    var token = fields || {};\n    token.type = type;\n    token.start = now();\n    context.events.push(['enter', token, context]);\n    stack.push(token);\n    return token;\n  } // Stop a token.\n\n\n  function exit(type) {\n    var token = stack.pop();\n    token.end = now();\n    context.events.push(['exit', token, context]);\n    return token;\n  } // Use results.\n\n\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  } // Discard results.\n\n\n  function onsuccessfulcheck(construct, info) {\n    info.restore();\n  } // Factory to attempt/check/interrupt.\n\n\n  function constructFactory(onreturn, fields) {\n    return hook; // Handle either an object mapping codes to constructs, a list of\n    // constructs, or a single construct.\n\n    function hook(constructs, returnState, bogusState) {\n      var listOfConstructs;\n      var constructIndex;\n      var currentConstruct;\n      var info;\n      return constructs.tokenize || 'length' in constructs ? handleListOfConstructs(miniflat(constructs)) : handleMapOfConstructs;\n\n      function handleMapOfConstructs(code) {\n        if (code in constructs || null in constructs) {\n          return handleListOfConstructs(constructs.null ?\n          /* c8 ignore next */\n          miniflat(constructs[code]).concat(miniflat(constructs.null)) : constructs[code])(code);\n        }\n\n        return bogusState(code);\n      }\n\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        return handleConstruct(list[constructIndex]);\n      }\n\n      function handleConstruct(construct) {\n        return start;\n\n        function start(code) {\n          // To do: not nede to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store();\n          currentConstruct = construct;\n\n          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n\n          if (construct.name && context.parser.constructs.disable.null.indexOf(construct.name) > -1) {\n            return nok();\n          }\n\n          return construct.tokenize.call(fields ? assign({}, context, fields) : context, effects, ok, nok)(code);\n        }\n      }\n\n      function ok(code) {\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n\n      function nok(code) {\n        info.restore();\n\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n\n        return bogusState;\n      }\n    }\n  }\n\n  function addResult(construct, from) {\n    if (construct.resolveAll && resolveAllConstructs.indexOf(construct) < 0) {\n      resolveAllConstructs.push(construct);\n    }\n\n    if (construct.resolve) {\n      chunkedSplice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\n    }\n  }\n\n  function store() {\n    var startPoint = now();\n    var startPrevious = context.previous;\n    var startCurrentConstruct = context.currentConstruct;\n    var startEventsIndex = context.events.length;\n    var startStack = Array.from(stack);\n    return {\n      restore: restore,\n      from: startEventsIndex\n    };\n\n    function restore() {\n      point = startPoint;\n      context.previous = startPrevious;\n      context.currentConstruct = startCurrentConstruct;\n      context.events.length = startEventsIndex;\n      stack = startStack;\n      accountForPotentialSkip();\n    }\n  }\n\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line];\n      point.offset += columnStart[point.line] - 1;\n    }\n  }\n}\n\nmodule.exports = createTokenizer;","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n  if (typeof Array.isArray === 'function') {\n    return Array.isArray(arr);\n  }\n\n  return toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n  if (!obj || toStr.call(obj) !== '[object Object]') {\n    return false;\n  }\n\n  var hasOwnConstructor = hasOwn.call(obj, 'constructor');\n  var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); // Not own constructor property must be Object\n\n  if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n    return false;\n  } // Own properties are enumerated firstly, so to speed up,\n  // if last one is own, then all properties are own.\n\n\n  var key;\n\n  for (key in obj) {\n    /**/\n  }\n\n  return typeof key === 'undefined' || hasOwn.call(obj, key);\n}; // If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\n\n\nvar setProperty = function setProperty(target, options) {\n  if (defineProperty && options.name === '__proto__') {\n    defineProperty(target, options.name, {\n      enumerable: true,\n      configurable: true,\n      value: options.newValue,\n      writable: true\n    });\n  } else {\n    target[options.name] = options.newValue;\n  }\n}; // Return undefined instead of __proto__ if '__proto__' is not an own property\n\n\nvar getProperty = function getProperty(obj, name) {\n  if (name === '__proto__') {\n    if (!hasOwn.call(obj, name)) {\n      return void 0;\n    } else if (gOPD) {\n      // In early versions of node, obj['__proto__'] is buggy when obj has\n      // __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n      return gOPD(obj, name).value;\n    }\n  }\n\n  return obj[name];\n};\n\nmodule.exports = function extend() {\n  var options, name, src, copy, copyIsArray, clone;\n  var target = arguments[0];\n  var i = 1;\n  var length = arguments.length;\n  var deep = false; // Handle a deep copy situation\n\n  if (typeof target === 'boolean') {\n    deep = target;\n    target = arguments[1] || {}; // skip the boolean and the target\n\n    i = 2;\n  }\n\n  if (target == null || typeof target !== 'object' && typeof target !== 'function') {\n    target = {};\n  }\n\n  for (; i < length; ++i) {\n    options = arguments[i]; // Only deal with non-null/undefined values\n\n    if (options != null) {\n      // Extend the base object\n      for (name in options) {\n        src = getProperty(target, name);\n        copy = getProperty(options, name); // Prevent never-ending loop\n\n        if (target !== copy) {\n          // Recurse if we're merging plain objects or arrays\n          if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n            if (copyIsArray) {\n              copyIsArray = false;\n              clone = src && isArray(src) ? src : [];\n            } else {\n              clone = src && isPlainObject(src) ? src : {};\n            } // Never move original objects, clone them\n\n\n            setProperty(target, {\n              name: name,\n              newValue: extend(deep, clone, copy)\n            }); // Don't bring in undefined values\n          } else if (typeof copy !== 'undefined') {\n            setProperty(target, {\n              name: name,\n              newValue: copy\n            });\n          }\n        }\n      }\n    }\n  } // Return the modified object\n\n\n  return target;\n};","'use strict';\n\nvar labelEnd = require('./label-end.js');\n\nvar labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n};\n\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    effects.enter('labelImage');\n    effects.enter('labelImageMarker');\n    effects.consume(code);\n    effects.exit('labelImageMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (code === 91) {\n      effects.enter('labelMarker');\n      effects.consume(code);\n      effects.exit('labelMarker');\n      effects.exit('labelImage');\n      return after;\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 &&\n    /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs ?\n    /* c8 ignore next */\n    nok(code) : ok(code);\n  }\n}\n\nmodule.exports = labelStartImage;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\nmodule.exports = asciiAtext;","'use strict'; // Note: EOF is seen as ASCII control here, because `null < 32 == true`.\n\nfunction asciiControl(code) {\n  return (// Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code < 32 || code === 127\n  );\n}\n\nmodule.exports = asciiControl;","'use strict';\n\nvar visit = require('unist-util-visit');\n\nmodule.exports = function (node) {\n  visit(node, 'table', wrap);\n  return node;\n};\n\nfunction wrap(table) {\n  var children = table.children;\n  table.children = [{\n    type: 'tableHead',\n    align: table.align,\n    children: [children[0]],\n    position: children[0].position\n  }];\n\n  if (children.length > 1) {\n    table.children.push({\n      type: 'tableBody',\n      align: table.align,\n      children: children.slice(1),\n      position: {\n        start: children[1].position.start,\n        end: children[children.length - 1].position.end\n      }\n    });\n  }\n}","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('./factory-space.js');\n\nfunction titleFactory(effects, ok, nok, type, markerType, stringType) {\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    marker = code === 40 ? 41 : code;\n    return atFirstTitleBreak;\n  }\n\n  function atFirstTitleBreak(code) {\n    if (code === marker) {\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    effects.enter(stringType);\n    return atTitleBreak(code);\n  }\n\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType);\n      return atFirstTitleBreak(marker);\n    }\n\n    if (code === null) {\n      return nok(code);\n    } // Note: blank lines can’t exist in content.\n\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return factorySpace(effects, atTitleBreak, 'linePrefix');\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return title(code);\n  }\n\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString');\n      return atTitleBreak(code);\n    }\n\n    effects.consume(code);\n    return code === 92 ? titleEscape : title;\n  }\n\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code);\n      return title;\n    }\n\n    return title(code);\n  }\n}\n\nmodule.exports = titleFactory;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar asciiAtext = require('../character/ascii-atext.js');\n\nvar asciiControl = require('../character/ascii-control.js');\n\nvar autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\n\nfunction tokenizeAutolink(effects, ok, nok) {\n  var size = 1;\n  return start;\n\n  function start(code) {\n    effects.enter('autolink');\n    effects.enter('autolinkMarker');\n    effects.consume(code);\n    effects.exit('autolinkMarker');\n    effects.enter('autolinkProtocol');\n    return open;\n  }\n\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n\n    return asciiAtext(code) ? emailAtext(code) : nok(code);\n  }\n\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code) ? schemeInsideOrEmailAtext(code) : emailAtext(code);\n  }\n\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      return urlInside;\n    }\n\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n\n    return emailAtext(code);\n  }\n\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol');\n      return end(code);\n    }\n\n    if (code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n\n    effects.consume(code);\n    return urlInside;\n  }\n\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n\n    return nok(code);\n  }\n\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail';\n      return end(code);\n    }\n\n    return emailValue(code);\n  }\n\n  function emailValue(code) {\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      effects.consume(code);\n      return code === 45 ? emailValue : emailLabel;\n    }\n\n    return nok(code);\n  }\n\n  function end(code) {\n    effects.enter('autolinkMarker');\n    effects.consume(code);\n    effects.exit('autolinkMarker');\n    effects.exit('autolink');\n    return ok;\n  }\n}\n\nmodule.exports = autolink;","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\nmodule.exports = function isBuffer(obj) {\n  return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj);\n};","'use strict';\n\nfunction normalizeIdentifier(value) {\n  return value // Collapse Markdown whitespace.\n  .replace(/[\\t\\n\\r ]+/g, ' ') // Trim.\n  .replace(/^ | $/g, '') // Some characters are considered “uppercase”, but if their lowercase\n  // counterpart is uppercased will result in a different uppercase\n  // character.\n  // Hence, to get that form, we perform both lower- and uppercase.\n  // Upper case makes sure keys will not interact with default prototypal\n  // methods: no object method is uppercase.\n  .toLowerCase().toUpperCase();\n}\n\nmodule.exports = normalizeIdentifier;","'use strict';\n\nvar unicodePunctuationRegex = require('../constant/unicode-punctuation-regex.js');\n\nvar regexCheck = require('../util/regex-check.js'); // In fact adds to the bundle size.\n\n\nvar unicodePunctuation = regexCheck(unicodePunctuationRegex);\nmodule.exports = unicodePunctuation;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n};\n\nfunction resolveHeadingAtx(events, context) {\n  var contentEnd = events.length - 2;\n  var contentStart = 3;\n  var content;\n  var text; // Prefix whitespace, part of the opening.\n\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2;\n  } // Suffix whitespace, part of the closing.\n\n\n  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === 'whitespace') {\n    contentEnd -= 2;\n  }\n\n  if (events[contentEnd][1].type === 'atxHeadingSequence' && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === 'whitespace')) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;\n  }\n\n  if (contentEnd > contentStart) {\n    content = {\n      type: 'atxHeadingText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    };\n    text = {\n      type: 'chunkText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      contentType: 'text'\n    };\n    chunkedSplice(events, contentStart, contentEnd - contentStart + 1, [['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]]);\n  }\n\n  return events;\n}\n\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  var self = this;\n  var size = 0;\n  return start;\n\n  function start(code) {\n    effects.enter('atxHeading');\n    effects.enter('atxHeadingSequence');\n    return fenceOpenInside(code);\n  }\n\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return fenceOpenInside;\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence');\n      return self.interrupt ? ok(code) : headingBreak(code);\n    }\n\n    return nok(code);\n  }\n\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence');\n      return sequence(code);\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading');\n      return ok(code);\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code);\n    }\n\n    effects.enter('atxHeadingText');\n    return data(code);\n  }\n\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequence;\n    }\n\n    effects.exit('atxHeadingSequence');\n    return headingBreak(code);\n  }\n\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText');\n      return headingBreak(code);\n    }\n\n    effects.consume(code);\n    return data;\n  }\n}\n\nmodule.exports = headingAtx;","'use strict';\n\nfunction markdownLineEnding(code) {\n  return code < -2;\n}\n\nmodule.exports = markdownLineEnding;","'use strict';\n\nvar slice = [].slice;\nmodule.exports = wrap; // Wrap `fn`.\n// Can be sync or async; return a promise, receive a completion handler, return\n// new values and errors.\n\nfunction wrap(fn, callback) {\n  var invoked;\n  return wrapped;\n\n  function wrapped() {\n    var params = slice.call(arguments, 0);\n    var callback = fn.length > params.length;\n    var result;\n\n    if (callback) {\n      params.push(done);\n    }\n\n    try {\n      result = fn.apply(null, params);\n    } catch (error) {\n      // Well, this is quite the pickle.\n      // `fn` received a callback and invoked it (thus continuing the pipeline),\n      // but later also threw an error.\n      // We’re not about to restart the pipeline again, so the only thing left\n      // to do is to throw the thing instead.\n      if (callback && invoked) {\n        throw error;\n      }\n\n      return done(error);\n    }\n\n    if (!callback) {\n      if (result && typeof result.then === 'function') {\n        result.then(then, done);\n      } else if (result instanceof Error) {\n        done(result);\n      } else {\n        then(result);\n      }\n    }\n  } // Invoke `next`, only once.\n\n\n  function done() {\n    if (!invoked) {\n      invoked = true;\n      callback.apply(null, arguments);\n    }\n  } // Invoke `done` with one value.\n  // Tracks if an error is passed, too.\n\n\n  function then(value) {\n    done(null, value);\n  }\n}","'use strict';\n\nvar fromCharCode = String.fromCharCode;\nmodule.exports = fromCharCode;","'use strict';\n\nmodule.exports = require('./lib');","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nfunction serializeChunks(chunks) {\n  var index = -1;\n  var result = [];\n  var chunk;\n  var value;\n  var atTab;\n\n  while (++index < chunks.length) {\n    chunk = chunks[index];\n\n    if (typeof chunk === 'string') {\n      value = chunk;\n    } else if (chunk === -5) {\n      value = '\\r';\n    } else if (chunk === -4) {\n      value = '\\n';\n    } else if (chunk === -3) {\n      value = '\\r' + '\\n';\n    } else if (chunk === -2) {\n      value = '\\t';\n    } else if (chunk === -1) {\n      if (atTab) continue;\n      value = ' ';\n    } else {\n      // Currently only replacement character.\n      value = fromCharCode(chunk);\n    }\n\n    atTab = chunk === -2;\n    result.push(value);\n  }\n\n  return result.join('');\n}\n\nmodule.exports = serializeChunks;","module.exports = identity;\n\nfunction identity(d) {\n  return d;\n}","'use strict';\n\nmodule.exports = bail;\n\nfunction bail(err) {\n  if (err) {\n    throw err;\n  }\n}","'use strict';\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nfunction chunkedPush(list, items) {\n  if (list.length) {\n    chunkedSplice(list, list.length, 0, items);\n    return list;\n  }\n\n  return items;\n}\n\nmodule.exports = chunkedPush;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar normalizeIdentifier = require('../util/normalize-identifier.js');\n\nvar factoryDestination = require('./factory-destination.js');\n\nvar factoryLabel = require('./factory-label.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar factoryWhitespace = require('./factory-whitespace.js');\n\nvar factoryTitle = require('./factory-title.js');\n\nvar definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\nvar titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n};\n\nfunction tokenizeDefinition(effects, ok, nok) {\n  var self = this;\n  var identifier;\n  return start;\n\n  function start(code) {\n    effects.enter('definition');\n    return factoryLabel.call(self, effects, labelAfter, nok, 'definitionLabel', 'definitionLabelMarker', 'definitionLabelString')(code);\n  }\n\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n\n    if (code === 58) {\n      effects.enter('definitionMarker');\n      effects.consume(code);\n      effects.exit('definitionMarker'); // Note: blank lines can’t exist in content.\n\n      return factoryWhitespace(effects, factoryDestination(effects, effects.attempt(titleConstruct, factorySpace(effects, after, 'whitespace'), factorySpace(effects, after, 'whitespace')), nok, 'definitionDestination', 'definitionDestinationLiteral', 'definitionDestinationLiteralMarker', 'definitionDestinationRaw', 'definitionDestinationString'));\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition');\n\n      if (self.parser.defined.indexOf(identifier) < 0) {\n        self.parser.defined.push(identifier);\n      }\n\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nfunction tokenizeTitle(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, before)(code) : nok(code);\n  }\n\n  function before(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, factorySpace(effects, after, 'whitespace'), nok, 'definitionTitle', 'definitionTitleMarker', 'definitionTitleString')(code);\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}\n\nmodule.exports = definition;","'use strict';\n\nmodule.exports = toString; // Get the text content of a node.\n// Prefer the node’s plain-text fields, otherwise serialize its children,\n// and if the given value is an array, serialize the nodes in it.\n\nfunction toString(node) {\n  return node && (node.value || node.alt || node.title || 'children' in node && all(node.children) || 'length' in node && all(node)) || '';\n}\n\nfunction all(values) {\n  var result = [];\n  var index = -1;\n\n  while (++index < values.length) {\n    result[index] = toString(values[index]);\n  }\n\n  return result.join('');\n}","'use strict';\n\nvar labelEnd = require('./label-end.js');\n\nvar labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n};\n\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    effects.enter('labelLink');\n    effects.enter('labelMarker');\n    effects.consume(code);\n    effects.exit('labelMarker');\n    effects.exit('labelLink');\n    return after;\n  }\n\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 &&\n    /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs ?\n    /* c8 ignore next */\n    nok(code) : ok(code);\n  }\n}\n\nmodule.exports = labelStartLink;","'use strict';\n\nfunction resolveAll(constructs, events, context) {\n  var called = [];\n  var index = -1;\n  var resolve;\n\n  while (++index < constructs.length) {\n    resolve = constructs[index].resolveAll;\n\n    if (resolve && called.indexOf(resolve) < 0) {\n      events = resolve(events, context);\n      called.push(resolve);\n    }\n  }\n\n  return events;\n}\n\nmodule.exports = resolveAll;","'use strict';\n\nvar visit = require('unist-util-visit');\n\nmodule.exports = function getDefinitions(tree) {\n  var definitions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  visit(tree, 'definition', function (node) {\n    var identifier = node.identifier.toUpperCase();\n    if (identifier in definitions) return;\n    definitions[identifier] = {\n      href: node.url,\n      title: node.title\n    };\n  });\n  return definitions;\n};","'use strict';\n\nvar xtend = require('xtend');\n\nvar unified = require('unified');\n\nvar parse = require('remark-parse');\n\nvar PropTypes = require('prop-types');\n\nvar addListMetadata = require('mdast-add-list-metadata');\n\nvar naiveHtml = require('./plugins/naive-html');\n\nvar disallowNode = require('./plugins/disallow-node');\n\nvar astToReact = require('./ast-to-react');\n\nvar wrapTableRows = require('./wrap-table-rows');\n\nvar getDefinitions = require('./get-definitions');\n\nvar uriTransformer = require('./uri-transformer');\n\nvar defaultRenderers = require('./renderers');\n\nvar symbols = require('./symbols');\n\nvar allTypes = Object.keys(defaultRenderers);\n\nvar ReactMarkdown = function ReactMarkdown(props) {\n  // To do in next major: remove `source`.\n  var src = props.source || props.children || '';\n\n  if (props.allowedTypes && props.disallowedTypes) {\n    throw new Error('Only one of `allowedTypes` and `disallowedTypes` should be defined');\n  }\n\n  var renderers = xtend(defaultRenderers, props.renderers);\n  var processor = unified().use(parse).use(props.plugins || []); // eslint-disable-next-line no-sync\n\n  var tree = processor.runSync(processor.parse(src));\n  var renderProps = xtend(props, {\n    renderers: renderers,\n    definitions: getDefinitions(tree)\n  });\n  determineAstToReactTransforms(props).forEach(function (transform) {\n    tree = transform(tree, renderProps);\n  });\n  return tree;\n};\n\nfunction determineAstToReactTransforms(props) {\n  var transforms = [wrapTableRows, addListMetadata()];\n  var disallowedTypes = props.disallowedTypes;\n\n  if (props.allowedTypes) {\n    disallowedTypes = allTypes.filter(function (type) {\n      return type !== 'root' && props.allowedTypes.indexOf(type) === -1;\n    });\n  }\n\n  var removalMethod = props.unwrapDisallowed ? 'unwrap' : 'remove';\n\n  if (disallowedTypes && disallowedTypes.length > 0) {\n    transforms.push(disallowNode.ofType(disallowedTypes, removalMethod));\n  }\n\n  if (props.allowNode) {\n    transforms.push(disallowNode.ifNotMatch(props.allowNode, removalMethod));\n  } // To do in next major: remove `escapeHtml`.\n\n\n  var renderHtml = (props.allowDangerousHtml || props.escapeHtml === false) && !props.skipHtml;\n  var hasHtmlParser = (props.astPlugins || []).some(function (transform) {\n    return transform.identity === symbols.HtmlParser;\n  });\n\n  if (renderHtml && !hasHtmlParser) {\n    transforms.push(naiveHtml);\n  }\n\n  if (props.astPlugins) {\n    transforms = transforms.concat(props.astPlugins);\n  } // Add the final transform to turn everything into React.\n\n\n  transforms.push(astToReact);\n  return transforms;\n}\n\nReactMarkdown.defaultProps = {\n  transformLinkUri: uriTransformer\n};\nReactMarkdown.propTypes = {\n  className: PropTypes.string,\n  source: PropTypes.string,\n  children: PropTypes.string,\n  sourcePos: PropTypes.bool,\n  rawSourcePos: PropTypes.bool,\n  escapeHtml: PropTypes.bool,\n  allowDangerousHtml: PropTypes.bool,\n  skipHtml: PropTypes.bool,\n  allowNode: PropTypes.func,\n  allowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  disallowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n  linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  transformImageUri: PropTypes.func,\n  astPlugins: PropTypes.arrayOf(PropTypes.func),\n  unwrapDisallowed: PropTypes.bool,\n  renderers: PropTypes.object,\n  plugins: PropTypes.array\n};\nReactMarkdown.types = allTypes;\nReactMarkdown.renderers = defaultRenderers;\nReactMarkdown.uriTransformer = uriTransformer;\nmodule.exports = ReactMarkdown;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n};\n\nfunction resolveToSetextUnderline(events, context) {\n  var index = events.length;\n  var content;\n  var text;\n  var definition;\n  var heading; // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index;\n        break;\n      }\n\n      if (events[index][1].type === 'paragraph') {\n        text = index;\n      }\n    } // Exit\n    else {\n        if (events[index][1].type === 'content') {\n          // Remove the content end (if needed we’ll add it later)\n          events.splice(index, 1);\n        }\n\n        if (!definition && events[index][1].type === 'definition') {\n          definition = index;\n        }\n      }\n  }\n\n  heading = {\n    type: 'setextHeading',\n    start: shallow(events[text][1].start),\n    end: shallow(events[events.length - 1][1].end)\n  }; // Change the paragraph to setext heading text.\n\n  events[text][1].type = 'setextHeadingText'; // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context]);\n    events.splice(definition + 1, 0, ['exit', events[content][1], context]);\n    events[content][1].end = shallow(events[definition][1].end);\n  } else {\n    events[content][1] = heading;\n  } // Add the heading exit at the end.\n\n\n  events.push(['exit', heading, context]);\n  return events;\n}\n\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  var self = this;\n  var index = self.events.length;\n  var marker;\n  var paragraph; // Find an opening.\n\n  while (index--) {\n    // Skip enter/exit of line ending, line prefix, and content.\n    // We can now either have a definition or a paragraph.\n    if (self.events[index][1].type !== 'lineEnding' && self.events[index][1].type !== 'linePrefix' && self.events[index][1].type !== 'content') {\n      paragraph = self.events[index][1].type === 'paragraph';\n      break;\n    }\n  }\n\n  return start;\n\n  function start(code) {\n    if (!self.lazy && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine');\n      effects.enter('setextHeadingLineSequence');\n      marker = code;\n      return closingSequence(code);\n    }\n\n    return nok(code);\n  }\n\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return closingSequence;\n    }\n\n    effects.exit('setextHeadingLineSequence');\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code);\n  }\n\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine');\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = setextUnderline;","'use strict'; // This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\n\nvar raws = ['pre', 'script', 'style', 'textarea'];\nmodule.exports = raws;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nvar htmlBlockNames = require('../constant/html-block-names.js');\n\nvar htmlRawNames = require('../constant/html-raw-names.js');\n\nvar partialBlankLine = require('./partial-blank-line.js');\n\nvar htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n};\nvar nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n};\n\nfunction resolveToHtmlFlow(events) {\n  var index = events.length;\n\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break;\n    }\n  }\n\n  if (index > 1 && events[index - 2][1].type === 'linePrefix') {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start; // Add the prefix start to the HTML line token.\n\n    events[index + 1][1].start = events[index - 2][1].start; // Remove the line prefix.\n\n    events.splice(index - 2, 2);\n  }\n\n  return events;\n}\n\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  var self = this;\n  var kind;\n  var startTag;\n  var buffer;\n  var index;\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('htmlFlow');\n    effects.enter('htmlFlowData');\n    effects.consume(code);\n    return open;\n  }\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationStart;\n    }\n\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      kind = 3; // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      buffer = fromCharCode(code);\n      startTag = true;\n      return tagName;\n    }\n\n    return nok(code);\n  }\n\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code);\n      kind = 2;\n      return commentOpenInside;\n    }\n\n    if (code === 91) {\n      effects.consume(code);\n      kind = 5;\n      buffer = 'CDATA[';\n      index = 0;\n      return cdataOpenInside;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      kind = 4;\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    return nok(code);\n  }\n\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    return nok(code);\n  }\n\n  function cdataOpenInside(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === buffer.length ? self.interrupt ? ok : continuation : cdataOpenInside;\n    }\n\n    return nok(code);\n  }\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      buffer = fromCharCode(code);\n      return tagName;\n    }\n\n    return nok(code);\n  }\n\n  function tagName(code) {\n    if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      if (code !== 47 && startTag && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {\n        kind = 1;\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n\n      if (htmlBlockNames.indexOf(buffer.toLowerCase()) > -1) {\n        kind = 6;\n\n        if (code === 47) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n\n      kind = 7; // Do not support complete HTML when interrupting.\n\n      return self.interrupt ? nok(code) : startTag ? completeAttributeNameBefore(code) : completeClosingTagAfter(code);\n    }\n\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += fromCharCode(code);\n      return tagName;\n    }\n\n    return nok(code);\n  }\n\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return self.interrupt ? ok : continuation;\n    }\n\n    return nok(code);\n  }\n\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n\n    return completeEnd(code);\n  }\n\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n\n    return completeEnd(code);\n  }\n\n  function completeAttributeName(code) {\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n\n    return completeAttributeNameAfter(code);\n  }\n\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n\n    return completeAttributeNameBefore(code);\n  }\n\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return completeAttributeValueQuoted;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n\n    marker = undefined;\n    return completeAttributeValueUnquoted(code);\n  }\n\n  function completeAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return completeAttributeValueQuotedAfter;\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    effects.consume(code);\n    return completeAttributeValueQuoted;\n  }\n\n  function completeAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\n      return completeAttributeNameAfter(code);\n    }\n\n    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n\n    return nok(code);\n  }\n\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n\n    return nok(code);\n  }\n\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n\n    return code === null || markdownLineEnding(code) ? continuation(code) : nok(code);\n  }\n\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n\n    if (code === 60 && kind === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n\n    if (code === 62 && kind === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    if (code === 63 && kind === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    if (code === 93 && kind === 5) {\n      effects.consume(code);\n      return continuationCharacterDataInside;\n    }\n\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(nextBlankConstruct, continuationClose, continuationAtLineEnding)(code);\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code);\n    }\n\n    effects.consume(code);\n    return continuation;\n  }\n\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData');\n    return htmlContinueStart(code);\n  }\n\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return htmlContinueStart;\n    }\n\n    effects.enter('htmlFlowData');\n    return continuation(code);\n  }\n\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code);\n      buffer += fromCharCode(code);\n      return continuationRawEndTag;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData');\n      return done(code);\n    }\n\n    effects.consume(code);\n    return continuationClose;\n  }\n\n  function done(code) {\n    effects.exit('htmlFlow');\n    return ok(code);\n  }\n}\n\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.exit('htmlFlowData');\n    effects.enter('lineEndingBlank');\n    effects.consume(code);\n    effects.exit('lineEndingBlank');\n    return effects.attempt(partialBlankLine, ok, nok);\n  }\n}\n\nmodule.exports = htmlFlow;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar content = require('../tokenize/content.js');\n\nvar factorySpace = require('../tokenize/factory-space.js');\n\nvar partialBlankLine = require('../tokenize/partial-blank-line.js');\n\nvar tokenize = initializeFlow;\n\nfunction initializeFlow(effects) {\n  var self = this;\n  var initial = effects.attempt( // Try to parse a blank line.\n  partialBlankLine, atBlankEnding, // Try to parse initial flow (essentially, only code).\n  effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), 'linePrefix')));\n  return initial;\n\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEndingBlank');\n    effects.consume(code);\n    effects.exit('lineEndingBlank');\n    self.currentConstruct = undefined;\n    return initial;\n  }\n\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    self.currentConstruct = undefined;\n    return initial;\n  }\n}\n\nexports.tokenize = tokenize;","'use strict';\n\nmodule.exports = require('./dist');","'use strict'; // This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\n\nvar unicodePunctuation = /[!-\\/:-@\\[-`\\{-~\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/;\nmodule.exports = unicodePunctuation;","'use strict';\n\nvar assign = require('../constant/assign.js');\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nvar shallow = require('./shallow.js');\n\nfunction subtokenize(events) {\n  var jumps = {};\n  var index = -1;\n  var event;\n  var lineIndex;\n  var otherIndex;\n  var otherEvent;\n  var parameters;\n  var subevents;\n  var more;\n\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\n    }\n\n    event = events[index]; // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n\n    if (index && event[1].type === 'chunkFlow' && events[index - 1][1].type === 'listItemPrefix') {\n      subevents = event[1]._tokenizer.events;\n      otherIndex = 0;\n\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === 'lineEndingBlank') {\n        otherIndex += 2;\n      }\n\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === 'content') {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break;\n          }\n\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1].isInFirstContentOfListItem = true;\n            otherIndex++;\n          }\n        }\n      }\n    } // Enter.\n\n\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        assign(jumps, subcontent(events, index));\n        index = jumps[index];\n        more = true;\n      }\n    } // Exit.\n    else if (event[1]._container || event[1]._movePreviousLineEndings) {\n        otherIndex = index;\n        lineIndex = undefined;\n\n        while (otherIndex--) {\n          otherEvent = events[otherIndex];\n\n          if (otherEvent[1].type === 'lineEnding' || otherEvent[1].type === 'lineEndingBlank') {\n            if (otherEvent[0] === 'enter') {\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank';\n              }\n\n              otherEvent[1].type = 'lineEnding';\n              lineIndex = otherIndex;\n            }\n          } else {\n            break;\n          }\n        }\n\n        if (lineIndex) {\n          // Fix position.\n          event[1].end = shallow(events[lineIndex][1].start); // Switch container exit w/ line endings.\n\n          parameters = events.slice(lineIndex, index);\n          parameters.unshift(event);\n          chunkedSplice(events, lineIndex, index - lineIndex + 1, parameters);\n        }\n      }\n  }\n\n  return !more;\n}\n\nfunction subcontent(events, eventIndex) {\n  var token = events[eventIndex][1];\n  var context = events[eventIndex][2];\n  var startPosition = eventIndex - 1;\n  var startPositions = [];\n  var tokenizer = token._tokenizer || context.parser[token.contentType](token.start);\n  var childEvents = tokenizer.events;\n  var jumps = [];\n  var gaps = {};\n  var stream;\n  var previous;\n  var index;\n  var entered;\n  var end;\n  var adjust; // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n\n  while (token) {\n    // Find the position of the event for this token.\n    while (events[++startPosition][1] !== token) {// Empty.\n    }\n\n    startPositions.push(startPosition);\n\n    if (!token._tokenizer) {\n      stream = context.sliceStream(token);\n\n      if (!token.next) {\n        stream.push(null);\n      }\n\n      if (previous) {\n        tokenizer.defineSkip(token.start);\n      }\n\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n\n      tokenizer.write(stream);\n\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined;\n      }\n    } // Unravel the next token.\n\n\n    previous = token;\n    token = token.next;\n  } // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n\n\n  token = previous;\n  index = childEvents.length;\n\n  while (index--) {\n    // Make sure we’ve at least seen something (final eol is part of the last\n    // token).\n    if (childEvents[index][0] === 'enter') {\n      entered = true;\n    } else if ( // Find a void token that includes a break.\n    entered && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {\n      add(childEvents.slice(index + 1, end)); // Help GC.\n\n      token._tokenizer = token.next = undefined;\n      token = token.previous;\n      end = index + 1;\n    }\n  } // Help GC.\n\n\n  tokenizer.events = token._tokenizer = token.next = undefined; // Do head:\n\n  add(childEvents.slice(0, end));\n  index = -1;\n  adjust = 0;\n\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];\n    adjust += jumps[index][1] - jumps[index][0] - 1;\n  }\n\n  return gaps;\n\n  function add(slice) {\n    var start = startPositions.pop();\n    jumps.unshift([start, start + slice.length - 1]);\n    chunkedSplice(events, start, 2, slice);\n  }\n}\n\nmodule.exports = subtokenize;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented,\n  resolve: resolveCodeIndented\n};\nvar indentedContentConstruct = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\n};\n\nfunction resolveCodeIndented(events, context) {\n  var code = {\n    type: 'codeIndented',\n    start: events[0][1].start,\n    end: events[events.length - 1][1].end\n  };\n  chunkedSplice(events, 0, 0, [['enter', code, context]]);\n  chunkedSplice(events, events.length, 0, [['exit', code, context]]);\n  return events;\n}\n\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  return effects.attempt(indentedContentConstruct, afterPrefix, nok);\n\n  function afterPrefix(code) {\n    if (code === null) {\n      return ok(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContentConstruct, afterPrefix, ok)(code);\n    }\n\n    effects.enter('codeFlowValue');\n    return content(code);\n  }\n\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue');\n      return afterPrefix(code);\n    }\n\n    effects.consume(code);\n    return content;\n  }\n}\n\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1);\n\n  function afterPrefix(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1);\n    }\n\n    return prefixSize(self.events, 'linePrefix') < 4 ? nok(code) : ok(code);\n  }\n}\n\nmodule.exports = codeIndented;","'use strict';\n\nvar assign = Object.assign;\nmodule.exports = assign;","\"use strict\";\n\nvar protocols = ['http', 'https', 'mailto', 'tel'];\n\nmodule.exports = function uriTransformer(uri) {\n  var url = (uri || '').trim();\n  var first = url.charAt(0);\n\n  if (first === '#' || first === '/') {\n    return url;\n  }\n\n  var colon = url.indexOf(':');\n\n  if (colon === -1) {\n    return url;\n  }\n\n  var length = protocols.length;\n  var index = -1;\n\n  while (++index < length) {\n    var protocol = protocols[index];\n\n    if (colon === protocol.length && url.slice(0, protocol.length).toLowerCase() === protocol) {\n      return url;\n    }\n  }\n\n  index = url.indexOf('?');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  }\n\n  index = url.indexOf('#');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  } // eslint-disable-next-line no-script-url\n\n\n  return 'javascript:void(0)';\n};","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\nmodule.exports = asciiAlphanumeric;","'use strict';\n\nvar sizeChunks = require('./size-chunks.js');\n\nfunction prefixSize(events, type) {\n  var tail = events[events.length - 1];\n  if (!tail || tail[1].type !== type) return 0;\n  return sizeChunks(tail[2].sliceStream(tail[1]));\n}\n\nmodule.exports = prefixSize;","'use strict';\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar chunkedPush = require('../util/chunked-push.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar normalizeIdentifier = require('../util/normalize-identifier.js');\n\nvar resolveAll = require('../util/resolve-all.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar factoryDestination = require('./factory-destination.js');\n\nvar factoryLabel = require('./factory-label.js');\n\nvar factoryTitle = require('./factory-title.js');\n\nvar factoryWhitespace = require('./factory-whitespace.js');\n\nvar labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n};\nvar resourceConstruct = {\n  tokenize: tokenizeResource\n};\nvar fullReferenceConstruct = {\n  tokenize: tokenizeFullReference\n};\nvar collapsedReferenceConstruct = {\n  tokenize: tokenizeCollapsedReference\n};\n\nfunction resolveAllLabelEnd(events) {\n  var index = -1;\n  var token;\n\n  while (++index < events.length) {\n    token = events[index][1];\n\n    if (!token._used && (token.type === 'labelImage' || token.type === 'labelLink' || token.type === 'labelEnd')) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2);\n      token.type = 'data';\n      index++;\n    }\n  }\n\n  return events;\n}\n\nfunction resolveToLabelEnd(events, context) {\n  var index = events.length;\n  var offset = 0;\n  var group;\n  var label;\n  var text;\n  var token;\n  var open;\n  var close;\n  var media; // Find an opening.\n\n  while (index--) {\n    token = events[index][1];\n\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (token.type === 'link' || token.type === 'labelLink' && token._inactive) {\n        break;\n      } // Mark other link openings as inactive, as we can’t have links in\n      // links.\n\n\n      if (events[index][0] === 'enter' && token.type === 'labelLink') {\n        token._inactive = true;\n      }\n    } else if (close) {\n      if (events[index][0] === 'enter' && (token.type === 'labelImage' || token.type === 'labelLink') && !token._balanced) {\n        open = index;\n\n        if (token.type !== 'labelLink') {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index;\n    }\n  }\n\n  group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: shallow(events[open][1].start),\n    end: shallow(events[events.length - 1][1].end)\n  };\n  label = {\n    type: 'label',\n    start: shallow(events[open][1].start),\n    end: shallow(events[close][1].end)\n  };\n  text = {\n    type: 'labelText',\n    start: shallow(events[open + offset + 2][1].end),\n    end: shallow(events[close - 2][1].start)\n  };\n  media = [['enter', group, context], ['enter', label, context]]; // Opening marker.\n\n  media = chunkedPush(media, events.slice(open + 1, open + offset + 3)); // Text open.\n\n  media = chunkedPush(media, [['enter', text, context]]); // Between.\n\n  media = chunkedPush(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context)); // Text close, marker close, label close.\n\n  media = chunkedPush(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]); // Reference, resource, or so.\n\n  media = chunkedPush(media, events.slice(close + 1)); // Media close.\n\n  media = chunkedPush(media, [['exit', group, context]]);\n  chunkedSplice(events, open, events.length, media);\n  return events;\n}\n\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  var self = this;\n  var index = self.events.length;\n  var labelStart;\n  var defined; // Find an opening.\n\n  while (index--) {\n    if ((self.events[index][1].type === 'labelImage' || self.events[index][1].type === 'labelLink') && !self.events[index][1]._balanced) {\n      labelStart = self.events[index][1];\n      break;\n    }\n  }\n\n  return start;\n\n  function start(code) {\n    if (!labelStart) {\n      return nok(code);\n    } // It’s a balanced bracket, but contains a link.\n\n\n    if (labelStart._inactive) return balanced(code);\n    defined = self.parser.defined.indexOf(normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    }))) > -1;\n    effects.enter('labelEnd');\n    effects.enter('labelMarker');\n    effects.consume(code);\n    effects.exit('labelMarker');\n    effects.exit('labelEnd');\n    return afterLabelEnd;\n  }\n\n  function afterLabelEnd(code) {\n    // Resource: `[asd](fgh)`.\n    if (code === 40) {\n      return effects.attempt(resourceConstruct, ok, defined ? ok : balanced)(code);\n    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?\n\n\n    if (code === 91) {\n      return effects.attempt(fullReferenceConstruct, ok, defined ? effects.attempt(collapsedReferenceConstruct, ok, balanced) : balanced)(code);\n    } // Shortcut reference: `[asd]`?\n\n\n    return defined ? ok(code) : balanced(code);\n  }\n\n  function balanced(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\n\nfunction tokenizeResource(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('resource');\n    effects.enter('resourceMarker');\n    effects.consume(code);\n    effects.exit('resourceMarker');\n    return factoryWhitespace(effects, open);\n  }\n\n  function open(code) {\n    if (code === 41) {\n      return end(code);\n    }\n\n    return factoryDestination(effects, destinationAfter, nok, 'resourceDestination', 'resourceDestinationLiteral', 'resourceDestinationLiteralMarker', 'resourceDestinationRaw', 'resourceDestinationString', 3)(code);\n  }\n\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, between)(code) : end(code);\n  }\n\n  function between(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, factoryWhitespace(effects, end), nok, 'resourceTitle', 'resourceTitleMarker', 'resourceTitleString')(code);\n    }\n\n    return end(code);\n  }\n\n  function end(code) {\n    if (code === 41) {\n      effects.enter('resourceMarker');\n      effects.consume(code);\n      effects.exit('resourceMarker');\n      effects.exit('resource');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nfunction tokenizeFullReference(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    return factoryLabel.call(self, effects, afterLabel, nok, 'reference', 'referenceMarker', 'referenceString')(code);\n  }\n\n  function afterLabel(code) {\n    return self.parser.defined.indexOf(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) < 0 ? nok(code) : ok(code);\n  }\n}\n\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('reference');\n    effects.enter('referenceMarker');\n    effects.consume(code);\n    effects.exit('referenceMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (code === 93) {\n      effects.enter('referenceMarker');\n      effects.consume(code);\n      effects.exit('referenceMarker');\n      effects.exit('reference');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = labelEnd;","'use strict';\n\nvar VMessage = require('vfile-message');\n\nvar VFile = require('./core.js');\n\nmodule.exports = VFile;\nVFile.prototype.message = message;\nVFile.prototype.info = info;\nVFile.prototype.fail = fail; // Create a message with `reason` at `position`.\n// When an error is passed in as `reason`, copies the stack.\n\nfunction message(reason, position, origin) {\n  var message = new VMessage(reason, position, origin);\n\n  if (this.path) {\n    message.name = this.path + ':' + message.name;\n    message.file = this.path;\n  }\n\n  message.fatal = false;\n  this.messages.push(message);\n  return message;\n} // Fail: creates a vmessage, associates it with the file, and throws it.\n\n\nfunction fail() {\n  var message = this.message.apply(this, arguments);\n  message.fatal = true;\n  throw message;\n} // Info: creates a vmessage, associates it with the file, and marks the fatality\n// as null.\n\n\nfunction info() {\n  var message = this.message.apply(this, arguments);\n  message.fatal = null;\n  return message;\n}","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n};\n\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  var self = this;\n  var closingFenceConstruct = {\n    tokenize: tokenizeClosingFence,\n    partial: true\n  };\n  var initialPrefix = prefixSize(this.events, 'linePrefix');\n  var sizeOpen = 0;\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('codeFenced');\n    effects.enter('codeFencedFence');\n    effects.enter('codeFencedFenceSequence');\n    marker = code;\n    return sequenceOpen(code);\n  }\n\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n\n    effects.exit('codeFencedFenceSequence');\n    return sizeOpen < 3 ? nok(code) : factorySpace(effects, infoOpen, 'whitespace')(code);\n  }\n\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code);\n    }\n\n    effects.enter('codeFencedFenceInfo');\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return info(code);\n  }\n\n  function info(code) {\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('chunkString');\n      effects.exit('codeFencedFenceInfo');\n      return factorySpace(effects, infoAfter, 'whitespace')(code);\n    }\n\n    if (code === 96 && code === marker) return nok(code);\n    effects.consume(code);\n    return info;\n  }\n\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code);\n    }\n\n    effects.enter('codeFencedFenceMeta');\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return meta(code);\n  }\n\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString');\n      effects.exit('codeFencedFenceMeta');\n      return openAfter(code);\n    }\n\n    if (code === 96 && code === marker) return nok(code);\n    effects.consume(code);\n    return meta;\n  }\n\n  function openAfter(code) {\n    effects.exit('codeFencedFence');\n    return self.interrupt ? ok(code) : content(code);\n  }\n\n  function content(code) {\n    if (code === null) {\n      return after(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return effects.attempt(closingFenceConstruct, after, initialPrefix ? factorySpace(effects, content, 'linePrefix', initialPrefix + 1) : content);\n    }\n\n    effects.enter('codeFlowValue');\n    return contentContinue(code);\n  }\n\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue');\n      return content(code);\n    }\n\n    effects.consume(code);\n    return contentContinue;\n  }\n\n  function after(code) {\n    effects.exit('codeFenced');\n    return ok(code);\n  }\n\n  function tokenizeClosingFence(effects, ok, nok) {\n    var size = 0;\n    return factorySpace(effects, closingSequenceStart, 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n\n    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence');\n      effects.enter('codeFencedFenceSequence');\n      return closingSequence(code);\n    }\n\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code);\n        size++;\n        return closingSequence;\n      }\n\n      if (size < sizeOpen) return nok(code);\n      effects.exit('codeFencedFenceSequence');\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code);\n    }\n\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence');\n        return ok(code);\n      }\n\n      return nok(code);\n    }\n  }\n}\n\nmodule.exports = codeFenced;","'use strict';\n\nfunction markdownLineEndingOrSpace(code) {\n  return code < 0 || code === 32;\n}\n\nmodule.exports = markdownLineEndingOrSpace;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\nmodule.exports = asciiHexDigit;","'use strict'; // This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\n\nvar basics = ['address', 'article', 'aside', 'base', 'basefont', 'blockquote', 'body', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hr', 'html', 'iframe', 'legend', 'li', 'link', 'main', 'menu', 'menuitem', 'nav', 'noframes', 'ol', 'optgroup', 'option', 'p', 'param', 'section', 'source', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul'];\nmodule.exports = basics;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar text$1 = require('./initialize/text.js');\n\nvar attention = require('./tokenize/attention.js');\n\nvar autolink = require('./tokenize/autolink.js');\n\nvar blockQuote = require('./tokenize/block-quote.js');\n\nvar characterEscape = require('./tokenize/character-escape.js');\n\nvar characterReference = require('./tokenize/character-reference.js');\n\nvar codeFenced = require('./tokenize/code-fenced.js');\n\nvar codeIndented = require('./tokenize/code-indented.js');\n\nvar codeText = require('./tokenize/code-text.js');\n\nvar definition = require('./tokenize/definition.js');\n\nvar hardBreakEscape = require('./tokenize/hard-break-escape.js');\n\nvar headingAtx = require('./tokenize/heading-atx.js');\n\nvar htmlFlow = require('./tokenize/html-flow.js');\n\nvar htmlText = require('./tokenize/html-text.js');\n\nvar labelEnd = require('./tokenize/label-end.js');\n\nvar labelStartImage = require('./tokenize/label-start-image.js');\n\nvar labelStartLink = require('./tokenize/label-start-link.js');\n\nvar lineEnding = require('./tokenize/line-ending.js');\n\nvar list = require('./tokenize/list.js');\n\nvar setextUnderline = require('./tokenize/setext-underline.js');\n\nvar thematicBreak = require('./tokenize/thematic-break.js');\n\nvar document = {\n  42: list,\n  // Asterisk\n  43: list,\n  // Plus sign\n  45: list,\n  // Dash\n  48: list,\n  // 0\n  49: list,\n  // 1\n  50: list,\n  // 2\n  51: list,\n  // 3\n  52: list,\n  // 4\n  53: list,\n  // 5\n  54: list,\n  // 6\n  55: list,\n  // 7\n  56: list,\n  // 8\n  57: list,\n  // 9\n  62: blockQuote // Greater than\n\n};\nvar contentInitial = {\n  91: definition // Left square bracket\n\n};\nvar flowInitial = {\n  '-2': codeIndented,\n  // Horizontal tab\n  '-1': codeIndented,\n  // Virtual space\n  32: codeIndented // Space\n\n};\nvar flow = {\n  35: headingAtx,\n  // Number sign\n  42: thematicBreak,\n  // Asterisk\n  45: [setextUnderline, thematicBreak],\n  // Dash\n  60: htmlFlow,\n  // Less than\n  61: setextUnderline,\n  // Equals to\n  95: thematicBreak,\n  // Underscore\n  96: codeFenced,\n  // Grave accent\n  126: codeFenced // Tilde\n\n};\nvar string = {\n  38: characterReference,\n  // Ampersand\n  92: characterEscape // Backslash\n\n};\nvar text = {\n  '-5': lineEnding,\n  // Carriage return\n  '-4': lineEnding,\n  // Line feed\n  '-3': lineEnding,\n  // Carriage return + line feed\n  33: labelStartImage,\n  // Exclamation mark\n  38: characterReference,\n  // Ampersand\n  42: attention,\n  // Asterisk\n  60: [autolink, htmlText],\n  // Less than\n  91: labelStartLink,\n  // Left square bracket\n  92: [hardBreakEscape, characterEscape],\n  // Backslash\n  93: labelEnd,\n  // Right square bracket\n  95: attention,\n  // Underscore\n  96: codeText // Grave accent\n\n};\nvar insideSpan = {\n  null: [attention, text$1.resolver]\n};\nvar disable = {\n  null: []\n};\nexports.contentInitial = contentInitial;\nexports.disable = disable;\nexports.document = document;\nexports.flow = flow;\nexports.flowInitial = flowInitial;\nexports.insideSpan = insideSpan;\nexports.string = string;\nexports.text = text;","'use strict';\n\nvar assign = require('../constant/assign.js');\n\nfunction shallow(object) {\n  return assign({}, object);\n}\n\nmodule.exports = shallow;","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = own;","module.exports = extend;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n  var target = {};\n\n  for (var i = 0; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n}","'use strict';\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nvar React = require('react');\n\nvar xtend = require('xtend');\n\nvar ReactIs = require('react-is');\n\nfunction astToReact(node, options) {\n  var parent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n  var renderer = options.renderers[node.type]; // Nodes created by plugins do not have positional info, in which case we set\n  // an object that matches the positon interface.\n\n  if (!node.position) {\n    node.position = {\n      start: {\n        line: null,\n        column: null,\n        offset: null\n      },\n      end: {\n        line: null,\n        column: null,\n        offset: null\n      }\n    };\n  }\n\n  var pos = node.position.start;\n  var key = [node.type, pos.line, pos.column, index].join('-');\n\n  if (!ReactIs.isValidElementType(renderer)) {\n    throw new Error(\"Renderer for type `\".concat(node.type, \"` not defined or is not renderable\"));\n  }\n\n  var nodeProps = getNodeProps(node, key, options, renderer, parent, index);\n  return React.createElement(renderer, nodeProps, nodeProps.children || resolveChildren() || undefined);\n\n  function resolveChildren() {\n    return node.children && node.children.map(function (childNode, i) {\n      return astToReact(childNode, options, {\n        node: node,\n        props: nodeProps\n      }, i);\n    });\n  }\n} // eslint-disable-next-line max-params, complexity\n\n\nfunction getNodeProps(node, key, opts, renderer, parent, index) {\n  var props = {\n    key: key\n  };\n  var isSimpleRenderer = typeof renderer === 'string' || renderer === React.Fragment; // `sourcePos` is true if the user wants source information (line/column info from markdown source)\n\n  if (opts.sourcePos && node.position) {\n    props['data-sourcepos'] = flattenPosition(node.position);\n  }\n\n  if (opts.rawSourcePos && !isSimpleRenderer) {\n    props.sourcePosition = node.position;\n  } // If `includeNodeIndex` is true, pass node index info to all non-tag renderers\n\n\n  if (opts.includeNodeIndex && parent.node && parent.node.children && !isSimpleRenderer) {\n    props.index = parent.node.children.indexOf(node);\n    props.parentChildCount = parent.node.children.length;\n  }\n\n  var ref = node.identifier !== null && node.identifier !== undefined ?\n  /* istanbul ignore next - plugins could inject an undefined reference. */\n  opts.definitions[node.identifier.toUpperCase()] || {} : null;\n\n  switch (node.type) {\n    case 'root':\n      assignDefined(props, {\n        className: opts.className\n      });\n      break;\n\n    case 'text':\n      props.nodeKey = key;\n      props.children = node.value;\n      break;\n\n    case 'heading':\n      props.level = node.depth;\n      break;\n\n    case 'list':\n      props.start = node.start;\n      props.ordered = node.ordered;\n      props.spread = node.spread;\n      props.depth = node.depth;\n      break;\n\n    case 'listItem':\n      props.checked = node.checked;\n      props.spread = node.spread;\n      props.ordered = node.ordered;\n      props.index = node.index;\n      props.children = getListItemChildren(node, parent).map(function (childNode, i) {\n        return astToReact(childNode, opts, {\n          node: node,\n          props: props\n        }, i);\n      });\n      break;\n\n    case 'definition':\n      assignDefined(props, {\n        identifier: node.identifier,\n        title: node.title,\n        url: node.url\n      });\n      break;\n\n    case 'code':\n      assignDefined(props, {\n        language: node.lang && node.lang.split(/\\s/, 1)[0]\n      });\n      break;\n\n    case 'inlineCode':\n      props.children = node.value;\n      props.inline = true;\n      break;\n\n    case 'link':\n      assignDefined(props, {\n        title: node.title || undefined,\n        target: typeof opts.linkTarget === 'function' ? opts.linkTarget(node.url, node.children, node.title) : opts.linkTarget,\n        href: opts.transformLinkUri ? opts.transformLinkUri(node.url, node.children, node.title) : node.url\n      });\n      break;\n\n    case 'image':\n      assignDefined(props, {\n        src: opts.transformImageUri ? opts.transformImageUri(node.url, node.children, node.title, node.alt) : node.url,\n        alt: node.alt || '',\n        title: node.title || undefined\n      });\n      break;\n\n    case 'linkReference':\n      assignDefined(props, xtend(ref, {\n        href: opts.transformLinkUri ? opts.transformLinkUri(ref.href) : ref.href\n      }));\n      break;\n\n    case 'imageReference':\n      assignDefined(props, {\n        src: opts.transformImageUri && ref.href ? opts.transformImageUri(ref.href, node.children, ref.title, node.alt) : ref.href,\n        alt: node.alt || '',\n        title: ref.title || undefined\n      });\n      break;\n\n    case 'table':\n    case 'tableHead':\n    case 'tableBody':\n      props.columnAlignment = node.align;\n      break;\n\n    case 'tableRow':\n      props.isHeader = parent.node.type === 'tableHead';\n      props.columnAlignment = parent.props.columnAlignment;\n      break;\n\n    case 'tableCell':\n      assignDefined(props, {\n        isHeader: parent.props.isHeader,\n        align: parent.props.columnAlignment[index]\n      });\n      break;\n\n    case 'virtualHtml':\n      props.tag = node.tag;\n      break;\n\n    case 'html':\n      // @todo find a better way than this\n      props.isBlock = node.position.start.line !== node.position.end.line;\n      props.allowDangerousHtml = opts.allowDangerousHtml;\n      props.escapeHtml = opts.escapeHtml;\n      props.skipHtml = opts.skipHtml;\n      break;\n\n    case 'parsedHtml':\n      {\n        var parsedChildren;\n\n        if (node.children) {\n          parsedChildren = node.children.map(function (child, i) {\n            return astToReact(child, opts, {\n              node: node,\n              props: props\n            }, i);\n          });\n        }\n\n        props.allowDangerousHtml = opts.allowDangerousHtml;\n        props.escapeHtml = opts.escapeHtml;\n        props.skipHtml = opts.skipHtml;\n        props.element = node.element ? mergeNodeChildren(node, parsedChildren) : null;\n        break;\n      }\n\n    default:\n      assignDefined(props, xtend(node, {\n        type: undefined,\n        position: undefined,\n        children: undefined\n      }));\n  }\n\n  if (!isSimpleRenderer && node.value) {\n    props.value = node.value;\n  }\n\n  if (!isSimpleRenderer) {\n    props.node = node;\n  }\n\n  return props;\n}\n\nfunction assignDefined(target, attrs) {\n  for (var key in attrs) {\n    if (typeof attrs[key] !== 'undefined') {\n      target[key] = attrs[key];\n    }\n  }\n}\n\nfunction mergeNodeChildren(node, parsedChildren) {\n  var el = node.element;\n\n  if (Array.isArray(el)) {\n    /* istanbul ignore next - `div` fallback for old React. */\n    var Fragment = React.Fragment || 'div';\n    return React.createElement(Fragment, null, el);\n  }\n\n  if (el.props.children || parsedChildren) {\n    var children = React.Children.toArray(el.props.children).concat(parsedChildren);\n    return React.cloneElement(el, null, children);\n  }\n\n  return React.cloneElement(el, null);\n}\n\nfunction flattenPosition(pos) {\n  return [pos.start.line, ':', pos.start.column, '-', pos.end.line, ':', pos.end.column].map(String).join('');\n}\n\nfunction getListItemChildren(node, parent) {\n  /* istanbul ignore next - list items are always in a list, but best to be sure. */\n  var loose = parent && parent.node ? listLoose(parent.node) : listItemLoose(node);\n  return loose ? node.children : unwrapParagraphs(node);\n}\n\nfunction unwrapParagraphs(node) {\n  return node.children.reduce(function (array, child) {\n    return array.concat(child.type === 'paragraph' ? child.children : [child]);\n  }, []);\n}\n\nfunction listLoose(node) {\n  var children = node.children;\n  var loose = node.spread;\n  var index = -1;\n\n  while (!loose && ++index < children.length) {\n    loose = listItemLoose(children[index]);\n  }\n\n  return loose;\n}\n\nfunction listItemLoose(node) {\n  var spread = node.spread;\n  /* istanbul ignore next - spread is present from remark-parse, but maybe plugins don’t set it. */\n\n  return spread === undefined || spread === null ? node.children.length > 1 : spread;\n}\n\nmodule.exports = astToReact;","'use strict';\n\nvar asciiPunctuation = require('../character/ascii-punctuation.js');\n\nvar characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\n\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('characterEscape');\n    effects.enter('escapeMarker');\n    effects.consume(code);\n    effects.exit('escapeMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (asciiPunctuation(code)) {\n      effects.enter('characterEscapeValue');\n      effects.consume(code);\n      effects.exit('characterEscapeValue');\n      effects.exit('characterEscape');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = characterEscape;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar partialBlankLine = {\n  tokenize: tokenizePartialBlankLine,\n  partial: true\n};\n\nfunction tokenizePartialBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix');\n\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}\n\nmodule.exports = partialBlankLine;","'use strict';\n\nvar splice = require('../constant/splice.js'); // causes a stack overflow in V8 when trying to insert 100k items for instance.\n\n\nfunction chunkedSplice(list, start, remove, items) {\n  var end = list.length;\n  var chunkStart = 0;\n  var parameters; // Make start between zero and `end` (included).\n\n  if (start < 0) {\n    start = -start > end ? 0 : end + start;\n  } else {\n    start = start > end ? end : start;\n  }\n\n  remove = remove > 0 ? remove : 0; // No need to chunk the items if there’s only a couple (10k) items.\n\n  if (items.length < 10000) {\n    parameters = Array.from(items);\n    parameters.unshift(start, remove);\n    splice.apply(list, parameters);\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) splice.apply(list, [start, remove]); // Insert the items in chunks to not cause stack overflows.\n\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000);\n      parameters.unshift(start, 0);\n      splice.apply(list, parameters);\n      chunkStart += 10000;\n      start += 10000;\n    }\n  }\n}\n\nmodule.exports = chunkedSplice;","'use strict';\n/* eslint-env browser */\n\nvar el;\nvar semicolon = 59; //  ';'\n\nmodule.exports = decodeEntity;\n\nfunction decodeEntity(characters) {\n  var entity = '&' + characters + ';';\n  var char;\n  el = el || document.createElement('i');\n  el.innerHTML = entity;\n  char = el.textContent; // Some entities do not require the closing semicolon (`&not` - for instance),\n  // which leads to situations where parsing the assumed entity of &notit; will\n  // result in the string `¬it;`.  When we encounter a trailing semicolon after\n  // parsing and the entity to decode was not a semicolon (`&semi;`), we can\n  // assume that the matching was incomplete\n\n  if (char.charCodeAt(char.length - 1) === semicolon && characters !== 'semi') {\n    return false;\n  } // If the decoded string is equal to the input, the entity was not valid\n\n\n  return char === entity ? false : char;\n}","/** @license React v16.13.1\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';\n\nvar b = \"function\" === typeof Symbol && Symbol.for,\n    c = b ? Symbol.for(\"react.element\") : 60103,\n    d = b ? Symbol.for(\"react.portal\") : 60106,\n    e = b ? Symbol.for(\"react.fragment\") : 60107,\n    f = b ? Symbol.for(\"react.strict_mode\") : 60108,\n    g = b ? Symbol.for(\"react.profiler\") : 60114,\n    h = b ? Symbol.for(\"react.provider\") : 60109,\n    k = b ? Symbol.for(\"react.context\") : 60110,\n    l = b ? Symbol.for(\"react.async_mode\") : 60111,\n    m = b ? Symbol.for(\"react.concurrent_mode\") : 60111,\n    n = b ? Symbol.for(\"react.forward_ref\") : 60112,\n    p = b ? Symbol.for(\"react.suspense\") : 60113,\n    q = b ? Symbol.for(\"react.suspense_list\") : 60120,\n    r = b ? Symbol.for(\"react.memo\") : 60115,\n    t = b ? Symbol.for(\"react.lazy\") : 60116,\n    v = b ? Symbol.for(\"react.block\") : 60121,\n    w = b ? Symbol.for(\"react.fundamental\") : 60117,\n    x = b ? Symbol.for(\"react.responder\") : 60118,\n    y = b ? Symbol.for(\"react.scope\") : 60119;\n\nfunction z(a) {\n  if (\"object\" === typeof a && null !== a) {\n    var u = a.$$typeof;\n\n    switch (u) {\n      case c:\n        switch (a = a.type, a) {\n          case l:\n          case m:\n          case e:\n          case g:\n          case f:\n          case p:\n            return a;\n\n          default:\n            switch (a = a && a.$$typeof, a) {\n              case k:\n              case n:\n              case t:\n              case r:\n              case h:\n                return a;\n\n              default:\n                return u;\n            }\n\n        }\n\n      case d:\n        return u;\n    }\n  }\n}\n\nfunction A(a) {\n  return z(a) === m;\n}\n\nexports.AsyncMode = l;\nexports.ConcurrentMode = m;\nexports.ContextConsumer = k;\nexports.ContextProvider = h;\nexports.Element = c;\nexports.ForwardRef = n;\nexports.Fragment = e;\nexports.Lazy = t;\nexports.Memo = r;\nexports.Portal = d;\nexports.Profiler = g;\nexports.StrictMode = f;\nexports.Suspense = p;\n\nexports.isAsyncMode = function (a) {\n  return A(a) || z(a) === l;\n};\n\nexports.isConcurrentMode = A;\n\nexports.isContextConsumer = function (a) {\n  return z(a) === k;\n};\n\nexports.isContextProvider = function (a) {\n  return z(a) === h;\n};\n\nexports.isElement = function (a) {\n  return \"object\" === typeof a && null !== a && a.$$typeof === c;\n};\n\nexports.isForwardRef = function (a) {\n  return z(a) === n;\n};\n\nexports.isFragment = function (a) {\n  return z(a) === e;\n};\n\nexports.isLazy = function (a) {\n  return z(a) === t;\n};\n\nexports.isMemo = function (a) {\n  return z(a) === r;\n};\n\nexports.isPortal = function (a) {\n  return z(a) === d;\n};\n\nexports.isProfiler = function (a) {\n  return z(a) === g;\n};\n\nexports.isStrictMode = function (a) {\n  return z(a) === f;\n};\n\nexports.isSuspense = function (a) {\n  return z(a) === p;\n};\n\nexports.isValidElementType = function (a) {\n  return \"string\" === typeof a || \"function\" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || \"object\" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);\n};\n\nexports.typeOf = z;","'use strict';\n\nmodule.exports = function (value) {\n  if (Object.prototype.toString.call(value) !== '[object Object]') {\n    return false;\n  }\n\n  var prototype = Object.getPrototypeOf(value);\n  return prototype === null || prototype === Object.prototype;\n};","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('../tokenize/factory-space.js');\n\nvar partialBlankLine = require('../tokenize/partial-blank-line.js');\n\nvar tokenize = initializeDocument;\nvar containerConstruct = {\n  tokenize: tokenizeContainer\n};\nvar lazyFlowConstruct = {\n  tokenize: tokenizeLazyFlow\n};\n\nfunction initializeDocument(effects) {\n  var self = this;\n  var stack = [];\n  var continued = 0;\n  var inspectConstruct = {\n    tokenize: tokenizeInspect,\n    partial: true\n  };\n  var inspectResult;\n  var childFlow;\n  var childToken;\n  return start;\n\n  function start(code) {\n    if (continued < stack.length) {\n      self.containerState = stack[continued][1];\n      return effects.attempt(stack[continued][0].continuation, documentContinue, documentContinued)(code);\n    }\n\n    return documentContinued(code);\n  }\n\n  function documentContinue(code) {\n    continued++;\n    return start(code);\n  }\n\n  function documentContinued(code) {\n    // If we’re in a concrete construct (such as when expecting another line of\n    // HTML, or we resulted in lazy content), we can immediately start flow.\n    if (inspectResult && inspectResult.flowContinue) {\n      return flowStart(code);\n    }\n\n    self.interrupt = childFlow && childFlow.currentConstruct && childFlow.currentConstruct.interruptible;\n    self.containerState = {};\n    return effects.attempt(containerConstruct, containerContinue, flowStart)(code);\n  }\n\n  function containerContinue(code) {\n    stack.push([self.currentConstruct, self.containerState]);\n    self.containerState = undefined;\n    return documentContinued(code);\n  }\n\n  function flowStart(code) {\n    if (code === null) {\n      exitContainers(0, true);\n      effects.consume(code);\n      return;\n    }\n\n    childFlow = childFlow || self.parser.flow(self.now());\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    });\n    return flowContinue(code);\n  }\n\n  function flowContinue(code) {\n    if (code === null) {\n      continueFlow(effects.exit('chunkFlow'));\n      return flowStart(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      continueFlow(effects.exit('chunkFlow'));\n      return effects.check(inspectConstruct, documentAfterPeek);\n    }\n\n    effects.consume(code);\n    return flowContinue;\n  }\n\n  function documentAfterPeek(code) {\n    exitContainers(inspectResult.continued, inspectResult && inspectResult.flowEnd);\n    continued = 0;\n    return start(code);\n  }\n\n  function continueFlow(token) {\n    if (childToken) childToken.next = token;\n    childToken = token;\n    childFlow.lazy = inspectResult && inspectResult.lazy;\n    childFlow.defineSkip(token.start);\n    childFlow.write(self.sliceStream(token));\n  }\n\n  function exitContainers(size, end) {\n    var index = stack.length; // Close the flow.\n\n    if (childFlow && end) {\n      childFlow.write([null]);\n      childToken = childFlow = undefined;\n    } // Exit open containers.\n\n\n    while (index-- > size) {\n      self.containerState = stack[index][1];\n      stack[index][0].exit.call(self, effects);\n    }\n\n    stack.length = size;\n  }\n\n  function tokenizeInspect(effects, ok) {\n    var subcontinued = 0;\n    inspectResult = {};\n    return inspectStart;\n\n    function inspectStart(code) {\n      if (subcontinued < stack.length) {\n        self.containerState = stack[subcontinued][1];\n        return effects.attempt(stack[subcontinued][0].continuation, inspectContinue, inspectLess)(code);\n      } // If we’re continued but in a concrete flow, we can’t have more\n      // containers.\n\n\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        inspectResult.flowContinue = true;\n        return inspectDone(code);\n      }\n\n      self.interrupt = childFlow.currentConstruct && childFlow.currentConstruct.interruptible;\n      self.containerState = {};\n      return effects.attempt(containerConstruct, inspectFlowEnd, inspectDone)(code);\n    }\n\n    function inspectContinue(code) {\n      subcontinued++;\n      return self.containerState._closeFlow ? inspectFlowEnd(code) : inspectStart(code);\n    }\n\n    function inspectLess(code) {\n      if (childFlow.currentConstruct && childFlow.currentConstruct.lazy) {\n        // Maybe another container?\n        self.containerState = {};\n        return effects.attempt(containerConstruct, inspectFlowEnd, // Maybe flow, or a blank line?\n        effects.attempt(lazyFlowConstruct, inspectFlowEnd, effects.check(partialBlankLine, inspectFlowEnd, inspectLazy)))(code);\n      } // Otherwise we’re interrupting.\n\n\n      return inspectFlowEnd(code);\n    }\n\n    function inspectLazy(code) {\n      // Act as if all containers are continued.\n      subcontinued = stack.length;\n      inspectResult.lazy = true;\n      inspectResult.flowContinue = true;\n      return inspectDone(code);\n    } // We’re done with flow if we have more containers, or an interruption.\n\n\n    function inspectFlowEnd(code) {\n      inspectResult.flowEnd = true;\n      return inspectDone(code);\n    }\n\n    function inspectDone(code) {\n      inspectResult.continued = subcontinued;\n      self.interrupt = self.containerState = undefined;\n      return ok(code);\n    }\n  }\n}\n\nfunction tokenizeContainer(effects, ok, nok) {\n  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n}\n\nfunction tokenizeLazyFlow(effects, ok, nok) {\n  return factorySpace(effects, effects.lazy(this.parser.constructs.flow, ok, nok), 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n}\n\nexports.tokenize = tokenize;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nfunction safeFromInt(value, base) {\n  var code = parseInt(value, base);\n\n  if ( // C0 except for HT, LF, FF, CR, space\n  code < 9 || code === 11 || code > 13 && code < 32 || // Control character (DEL) of the basic block and C1 controls.\n  code > 126 && code < 160 || // Lone high surrogates and low surrogates.\n  code > 55295 && code < 57344 || // Noncharacters.\n  code > 64975 && code < 65008 || (code & 65535) === 65535 || (code & 65535) === 65534 || // Out of range\n  code > 1114111) {\n    return \"\\uFFFD\";\n  }\n\n  return fromCharCode(code);\n}\n\nmodule.exports = safeFromInt;","'use strict';\n\nvar bail = require('bail');\n\nvar buffer = require('is-buffer');\n\nvar extend = require('extend');\n\nvar plain = require('is-plain-obj');\n\nvar trough = require('trough');\n\nvar vfile = require('vfile'); // Expose a frozen processor.\n\n\nmodule.exports = unified().freeze();\nvar slice = [].slice;\nvar own = {}.hasOwnProperty; // Process pipeline.\n\nvar pipeline = trough().use(pipelineParse).use(pipelineRun).use(pipelineStringify);\n\nfunction pipelineParse(p, ctx) {\n  ctx.tree = p.parse(ctx.file);\n}\n\nfunction pipelineRun(p, ctx, next) {\n  p.run(ctx.tree, ctx.file, done);\n\n  function done(error, tree, file) {\n    if (error) {\n      next(error);\n    } else {\n      ctx.tree = tree;\n      ctx.file = file;\n      next();\n    }\n  }\n}\n\nfunction pipelineStringify(p, ctx) {\n  var result = p.stringify(ctx.tree, ctx.file);\n\n  if (result === undefined || result === null) {// Empty.\n  } else if (typeof result === 'string' || buffer(result)) {\n    ctx.file.contents = result;\n  } else {\n    ctx.file.result = result;\n  }\n} // Function to create the first processor.\n\n\nfunction unified() {\n  var attachers = [];\n  var transformers = trough();\n  var namespace = {};\n  var freezeIndex = -1;\n  var frozen; // Data management.\n\n  processor.data = data; // Lock.\n\n  processor.freeze = freeze; // Plugins.\n\n  processor.attachers = attachers;\n  processor.use = use; // API.\n\n  processor.parse = parse;\n  processor.stringify = stringify;\n  processor.run = run;\n  processor.runSync = runSync;\n  processor.process = process;\n  processor.processSync = processSync; // Expose.\n\n  return processor; // Create a new processor based on the processor in the current scope.\n\n  function processor() {\n    var destination = unified();\n    var index = -1;\n\n    while (++index < attachers.length) {\n      destination.use.apply(null, attachers[index]);\n    }\n\n    destination.data(extend(true, {}, namespace));\n    return destination;\n  } // Freeze: used to signal a processor that has finished configuration.\n  //\n  // For example, take unified itself: it’s frozen.\n  // Plugins should not be added to it.\n  // Rather, it should be extended, by invoking it, before modifying it.\n  //\n  // In essence, always invoke this when exporting a processor.\n\n\n  function freeze() {\n    var values;\n    var transformer;\n\n    if (frozen) {\n      return processor;\n    }\n\n    while (++freezeIndex < attachers.length) {\n      values = attachers[freezeIndex];\n\n      if (values[1] === false) {\n        continue;\n      }\n\n      if (values[1] === true) {\n        values[1] = undefined;\n      }\n\n      transformer = values[0].apply(processor, values.slice(1));\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer);\n      }\n    }\n\n    frozen = true;\n    freezeIndex = Infinity;\n    return processor;\n  } // Data management.\n  // Getter / setter for processor-specific informtion.\n\n\n  function data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen);\n        namespace[key] = value;\n        return processor;\n      } // Get `key`.\n\n\n      return own.call(namespace, key) && namespace[key] || null;\n    } // Set space.\n\n\n    if (key) {\n      assertUnfrozen('data', frozen);\n      namespace = key;\n      return processor;\n    } // Get space.\n\n\n    return namespace;\n  } // Plugin management.\n  //\n  // Pass it:\n  // *   an attacher and options,\n  // *   a preset,\n  // *   a list of presets, attachers, and arguments (list of attachers and\n  //     options).\n\n\n  function use(value) {\n    var settings;\n    assertUnfrozen('use', frozen);\n\n    if (value === null || value === undefined) {// Empty.\n    } else if (typeof value === 'function') {\n      addPlugin.apply(null, arguments);\n    } else if (typeof value === 'object') {\n      if ('length' in value) {\n        addList(value);\n      } else {\n        addPreset(value);\n      }\n    } else {\n      throw new Error('Expected usable value, not `' + value + '`');\n    }\n\n    if (settings) {\n      namespace.settings = extend(namespace.settings || {}, settings);\n    }\n\n    return processor;\n\n    function addPreset(result) {\n      addList(result.plugins);\n\n      if (result.settings) {\n        settings = extend(settings || {}, result.settings);\n      }\n    }\n\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value);\n      } else if (typeof value === 'object') {\n        if ('length' in value) {\n          addPlugin.apply(null, value);\n        } else {\n          addPreset(value);\n        }\n      } else {\n        throw new Error('Expected usable value, not `' + value + '`');\n      }\n    }\n\n    function addList(plugins) {\n      var index = -1;\n\n      if (plugins === null || plugins === undefined) {// Empty.\n      } else if (typeof plugins === 'object' && 'length' in plugins) {\n        while (++index < plugins.length) {\n          add(plugins[index]);\n        }\n      } else {\n        throw new Error('Expected a list of plugins, not `' + plugins + '`');\n      }\n    }\n\n    function addPlugin(plugin, value) {\n      var entry = find(plugin);\n\n      if (entry) {\n        if (plain(entry[1]) && plain(value)) {\n          value = extend(true, entry[1], value);\n        }\n\n        entry[1] = value;\n      } else {\n        attachers.push(slice.call(arguments));\n      }\n    }\n  }\n\n  function find(plugin) {\n    var index = -1;\n\n    while (++index < attachers.length) {\n      if (attachers[index][0] === plugin) {\n        return attachers[index];\n      }\n    }\n  } // Parse a file (in string or vfile representation) into a unist node using\n  // the `Parser` on the processor.\n\n\n  function parse(doc) {\n    var file = vfile(doc);\n    var Parser;\n    freeze();\n    Parser = processor.Parser;\n    assertParser('parse', Parser);\n\n    if (newable(Parser, 'parse')) {\n      return new Parser(String(file), file).parse();\n    }\n\n    return Parser(String(file), file); // eslint-disable-line new-cap\n  } // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), async.\n\n\n  function run(node, file, cb) {\n    assertNode(node);\n    freeze();\n\n    if (!cb && typeof file === 'function') {\n      cb = file;\n      file = null;\n    }\n\n    if (!cb) {\n      return new Promise(executor);\n    }\n\n    executor(null, cb);\n\n    function executor(resolve, reject) {\n      transformers.run(node, vfile(file), done);\n\n      function done(error, tree, file) {\n        tree = tree || node;\n\n        if (error) {\n          reject(error);\n        } else if (resolve) {\n          resolve(tree);\n        } else {\n          cb(null, tree, file);\n        }\n      }\n    }\n  } // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), sync.\n\n\n  function runSync(node, file) {\n    var result;\n    var complete;\n    run(node, file, done);\n    assertDone('runSync', 'run', complete);\n    return result;\n\n    function done(error, tree) {\n      complete = true;\n      result = tree;\n      bail(error);\n    }\n  } // Stringify a unist node representation of a file (in string or vfile\n  // representation) into a string using the `Compiler` on the processor.\n\n\n  function stringify(node, doc) {\n    var file = vfile(doc);\n    var Compiler;\n    freeze();\n    Compiler = processor.Compiler;\n    assertCompiler('stringify', Compiler);\n    assertNode(node);\n\n    if (newable(Compiler, 'compile')) {\n      return new Compiler(node, file).compile();\n    }\n\n    return Compiler(node, file); // eslint-disable-line new-cap\n  } // Parse a file (in string or vfile representation) into a unist node using\n  // the `Parser` on the processor, then run transforms on that node, and\n  // compile the resulting node using the `Compiler` on the processor, and\n  // store that result on the vfile.\n\n\n  function process(doc, cb) {\n    freeze();\n    assertParser('process', processor.Parser);\n    assertCompiler('process', processor.Compiler);\n\n    if (!cb) {\n      return new Promise(executor);\n    }\n\n    executor(null, cb);\n\n    function executor(resolve, reject) {\n      var file = vfile(doc);\n      pipeline.run(processor, {\n        file: file\n      }, done);\n\n      function done(error) {\n        if (error) {\n          reject(error);\n        } else if (resolve) {\n          resolve(file);\n        } else {\n          cb(null, file);\n        }\n      }\n    }\n  } // Process the given document (in string or vfile representation), sync.\n\n\n  function processSync(doc) {\n    var file;\n    var complete;\n    freeze();\n    assertParser('processSync', processor.Parser);\n    assertCompiler('processSync', processor.Compiler);\n    file = vfile(doc);\n    process(file, done);\n    assertDone('processSync', 'process', complete);\n    return file;\n\n    function done(error) {\n      complete = true;\n      bail(error);\n    }\n  }\n} // Check if `value` is a constructor.\n\n\nfunction newable(value, name) {\n  return typeof value === 'function' && value.prototype && ( // A function with keys in its prototype is probably a constructor.\n  // Classes’ prototype methods are not enumerable, so we check if some value\n  // exists in the prototype.\n  keys(value.prototype) || name in value.prototype);\n} // Check if `value` is an object with keys.\n\n\nfunction keys(value) {\n  var key;\n\n  for (key in value) {\n    return true;\n  }\n\n  return false;\n} // Assert a parser is available.\n\n\nfunction assertParser(name, Parser) {\n  if (typeof Parser !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Parser`');\n  }\n} // Assert a compiler is available.\n\n\nfunction assertCompiler(name, Compiler) {\n  if (typeof Compiler !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Compiler`');\n  }\n} // Assert the processor is not frozen.\n\n\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error('Cannot invoke `' + name + '` on a frozen processor.\\nCreate a new processor first, by invoking it: use `processor()` instead of `processor`.');\n  }\n} // Assert `node` is a unist node.\n\n\nfunction assertNode(node) {\n  if (!node || typeof node.type !== 'string') {\n    throw new Error('Expected node, got `' + node + '`');\n  }\n} // Assert that `complete` is `true`.\n\n\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error('`' + name + '` finished async. Use `' + asyncName + '` instead');\n  }\n}","'use strict';\n\nmodule.exports = convert;\n\nfunction convert(test) {\n  if (test == null) {\n    return ok;\n  }\n\n  if (typeof test === 'string') {\n    return typeFactory(test);\n  }\n\n  if (typeof test === 'object') {\n    return 'length' in test ? anyFactory(test) : allFactory(test);\n  }\n\n  if (typeof test === 'function') {\n    return test;\n  }\n\n  throw new Error('Expected function, string, or object as test');\n} // Utility assert each property in `test` is represented in `node`, and each\n// values are strictly equal.\n\n\nfunction allFactory(test) {\n  return all;\n\n  function all(node) {\n    var key;\n\n    for (key in test) {\n      if (node[key] !== test[key]) return false;\n    }\n\n    return true;\n  }\n}\n\nfunction anyFactory(tests) {\n  var checks = [];\n  var index = -1;\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index]);\n  }\n\n  return any;\n\n  function any() {\n    var index = -1;\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, arguments)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n} // Utility to convert a string into a function which checks a given node’s type\n// for said string.\n\n\nfunction typeFactory(test) {\n  return type;\n\n  function type(node) {\n    return Boolean(node && node.type === test);\n  }\n} // Utility to return true.\n\n\nfunction ok() {\n  return true;\n}","'use strict';\n\nmodule.exports = visit;\n\nvar visitParents = require('unist-util-visit-parents');\n\nvar CONTINUE = visitParents.CONTINUE;\nvar SKIP = visitParents.SKIP;\nvar EXIT = visitParents.EXIT;\nvisit.CONTINUE = CONTINUE;\nvisit.SKIP = SKIP;\nvisit.EXIT = EXIT;\n\nfunction visit(tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n\n  visitParents(tree, test, overload, reverse);\n\n  function overload(node, parents) {\n    var parent = parents[parents.length - 1];\n    var index = parent ? parent.children.indexOf(node) : null;\n    return visitor(node, index, parent);\n  }\n}","'use strict';\n\nvar stringify = require('unist-util-stringify-position');\n\nmodule.exports = VMessage; // Inherit from `Error#`.\n\nfunction VMessagePrototype() {}\n\nVMessagePrototype.prototype = Error.prototype;\nVMessage.prototype = new VMessagePrototype(); // Message properties.\n\nvar proto = VMessage.prototype;\nproto.file = '';\nproto.name = '';\nproto.reason = '';\nproto.message = '';\nproto.stack = '';\nproto.fatal = null;\nproto.column = null;\nproto.line = null; // Construct a new VMessage.\n//\n// Note: We cannot invoke `Error` on the created context, as that adds readonly\n// `line` and `column` attributes on Safari 9, thus throwing and failing the\n// data.\n\nfunction VMessage(reason, position, origin) {\n  var parts;\n  var range;\n  var location;\n\n  if (typeof position === 'string') {\n    origin = position;\n    position = null;\n  }\n\n  parts = parseOrigin(origin);\n  range = stringify(position) || '1:1';\n  location = {\n    start: {\n      line: null,\n      column: null\n    },\n    end: {\n      line: null,\n      column: null\n    }\n  }; // Node.\n\n  if (position && position.position) {\n    position = position.position;\n  }\n\n  if (position) {\n    // Position.\n    if (position.start) {\n      location = position;\n      position = position.start;\n    } else {\n      // Point.\n      location.start = position;\n    }\n  }\n\n  if (reason.stack) {\n    this.stack = reason.stack;\n    reason = reason.message;\n  }\n\n  this.message = reason;\n  this.name = range;\n  this.reason = reason;\n  this.line = position ? position.line : null;\n  this.column = position ? position.column : null;\n  this.location = location;\n  this.source = parts[0];\n  this.ruleId = parts[1];\n}\n\nfunction parseOrigin(origin) {\n  var result = [null, null];\n  var index;\n\n  if (typeof origin === 'string') {\n    index = origin.indexOf(':');\n\n    if (index === -1) {\n      result[1] = origin;\n    } else {\n      result[0] = origin.slice(0, index);\n      result[1] = origin.slice(index + 1);\n    }\n  }\n\n  return result;\n}","\"use strict\";\n/**\n * Naive, simple plugin to match inline nodes without attributes\n * This allows say <strong>foo</strong>, but not <strong class=\"very\">foo</strong>\n * For proper HTML support, you'll want a different plugin\n **/\n\nvar visit = require('unist-util-visit');\n\nvar type = 'virtualHtml';\nvar selfClosingRe = /^<(area|base|br|col|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)\\s*\\/?>$/i;\nvar simpleTagRe = /^<(\\/?)([a-z]+)\\s*>$/;\n\nmodule.exports = function (tree) {\n  var open;\n  var currentParent;\n  visit(tree, 'html', function (node, index, parent) {\n    if (currentParent !== parent) {\n      open = [];\n      currentParent = parent;\n    }\n\n    var selfClosing = getSelfClosing(node);\n\n    if (selfClosing) {\n      parent.children.splice(index, 1, {\n        type: type,\n        tag: selfClosing,\n        position: node.position\n      });\n      return true;\n    }\n\n    var current = getSimpleTag(node, parent);\n\n    if (!current) {\n      return true;\n    }\n\n    var matching = findAndPull(open, current.tag);\n\n    if (matching) {\n      parent.children.splice(index, 0, virtual(current, matching, parent));\n    } else if (!current.opening) {\n      open.push(current);\n    }\n\n    return true;\n  }, true // Iterate in reverse\n  );\n  return tree;\n};\n\nfunction findAndPull(open, matchingTag) {\n  var i = open.length;\n\n  while (i--) {\n    if (open[i].tag === matchingTag) {\n      return open.splice(i, 1)[0];\n    }\n  }\n\n  return false;\n}\n\nfunction getSimpleTag(node, parent) {\n  var match = node.value.match(simpleTagRe);\n  return match ? {\n    tag: match[2],\n    opening: !match[1],\n    node: node\n  } : false;\n}\n\nfunction getSelfClosing(node) {\n  var match = node.value.match(selfClosingRe);\n  return match ? match[1] : false;\n}\n\nfunction virtual(fromNode, toNode, parent) {\n  var fromIndex = parent.children.indexOf(fromNode.node);\n  var toIndex = parent.children.indexOf(toNode.node);\n  var extracted = parent.children.splice(fromIndex, toIndex - fromIndex + 1);\n  var children = extracted.slice(1, -1);\n  return {\n    type: type,\n    children: children,\n    tag: fromNode.tag,\n    position: {\n      start: fromNode.node.position.start,\n      end: toNode.node.position.end,\n      indent: []\n    }\n  };\n}","'use strict';\n\nvar chunkedPush = require('../util/chunked-push.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar classifyCharacter = require('../util/classify-character.js');\n\nvar movePoint = require('../util/move-point.js');\n\nvar resolveAll = require('../util/resolve-all.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n};\n\nfunction resolveAllAttention(events, context) {\n  var index = -1;\n  var open;\n  var group;\n  var text;\n  var openingSequence;\n  var closingSequence;\n  var use;\n  var nextEvents;\n  var offset; // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {\n      open = index; // Now walk back to find an opener.\n\n      while (open--) {\n        // Find a token that can open the closer.\n        if (events[open][0] === 'exit' && events[open][1].type === 'attentionSequence' && events[open][1]._open && // If the markers are the same:\n        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {\n            continue;\n          } // Number of markers to use from the sequence.\n\n\n          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: movePoint(shallow(events[open][1].end), -use),\n            end: shallow(events[open][1].end)\n          };\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: shallow(events[index][1].start),\n            end: movePoint(shallow(events[index][1].start), use)\n          };\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: shallow(events[open][1].end),\n            end: shallow(events[index][1].start)\n          };\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: shallow(openingSequence.start),\n            end: shallow(closingSequence.end)\n          };\n          events[open][1].end = shallow(openingSequence.start);\n          events[index][1].start = shallow(closingSequence.end);\n          nextEvents = []; // If there are more markers in the opening, add them before.\n\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = chunkedPush(nextEvents, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          } // Opening.\n\n\n          nextEvents = chunkedPush(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]); // Between.\n\n          nextEvents = chunkedPush(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context)); // Closing.\n\n          nextEvents = chunkedPush(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]); // If there are more markers in the closing, add them after.\n\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2;\n            nextEvents = chunkedPush(nextEvents, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\n          } else {\n            offset = 0;\n          }\n\n          chunkedSplice(events, open - 1, index - open + 3, nextEvents);\n          index = open + nextEvents.length - offset - 2;\n          break;\n        }\n      }\n    }\n  } // Remove remaining sequences.\n\n\n  index = -1;\n\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n\n  return events;\n}\n\nfunction tokenizeAttention(effects, ok) {\n  var before = classifyCharacter(this.previous);\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('attentionSequence');\n    marker = code;\n    return sequence(code);\n  }\n\n  function sequence(code) {\n    var token;\n    var after;\n    var open;\n    var close;\n\n    if (code === marker) {\n      effects.consume(code);\n      return sequence;\n    }\n\n    token = effects.exit('attentionSequence');\n    after = classifyCharacter(code);\n    open = !after || after === 2 && before;\n    close = !before || before === 2 && after;\n    token._open = marker === 42 ? open : open && (before || !close);\n    token._close = marker === 42 ? close : close && (after || !open);\n    return ok(code);\n  }\n}\n\nmodule.exports = attention;","'use strict';\n\nvar factorySpace = require('./factory-space.js');\n\nvar lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\n\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n\n  function start(code) {\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, ok, 'linePrefix');\n  }\n}\n\nmodule.exports = lineEnding;","'use strict';\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar unicodePunctuation = require('../character/unicode-punctuation.js');\n\nvar unicodeWhitespace = require('../character/unicode-whitespace.js'); // Classify whether a character is unicode whitespace, unicode punctuation, or\n// anything else.\n// Used for attention (emphasis, strong), whose sequences can open or close\n// based on the class of surrounding characters.\n\n\nfunction classifyCharacter(code) {\n  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}\n\nmodule.exports = classifyCharacter;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('hardBreakEscape');\n    effects.enter('escapeMarker');\n    effects.consume(code);\n    return open;\n  }\n\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker');\n      effects.exit('hardBreakEscape');\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = hardBreakEscape;","\"use strict\";\n\nvar HtmlParser = '__RMD_HTML_PARSER__';\n/* istanbul ignore next - Fallback for `Symbol`. */\n\nexports.HtmlParser = typeof Symbol === 'undefined' ? HtmlParser : Symbol(HtmlParser);","'use strict';\n\nvar asciiControl = require('../character/ascii-control.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js'); // eslint-disable-next-line max-params\n\n\nfunction destinationFactory(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) {\n  var limit = max || Infinity;\n  var balance = 0;\n  return start;\n\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type);\n      effects.enter(literalType);\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      return destinationEnclosedBefore;\n    }\n\n    if (asciiControl(code) || code === 41) {\n      return nok(code);\n    }\n\n    effects.enter(type);\n    effects.enter(rawType);\n    effects.enter(stringType);\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return destinationRaw(code);\n  }\n\n  function destinationEnclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      effects.exit(literalType);\n      effects.exit(type);\n      return ok;\n    }\n\n    effects.enter(stringType);\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return destinationEnclosed(code);\n  }\n\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString');\n      effects.exit(stringType);\n      return destinationEnclosedBefore(code);\n    }\n\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    effects.consume(code);\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed;\n  }\n\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code);\n      return destinationEnclosed;\n    }\n\n    return destinationEnclosed(code);\n  }\n\n  function destinationRaw(code) {\n    if (code === 40) {\n      if (++balance > limit) return nok(code);\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    if (code === 41) {\n      if (!balance--) {\n        effects.exit('chunkString');\n        effects.exit(stringType);\n        effects.exit(rawType);\n        effects.exit(type);\n        return ok(code);\n      }\n\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      if (balance) return nok(code);\n      effects.exit('chunkString');\n      effects.exit(stringType);\n      effects.exit(rawType);\n      effects.exit(type);\n      return ok(code);\n    }\n\n    if (asciiControl(code)) return nok(code);\n    effects.consume(code);\n    return code === 92 ? destinationRawEscape : destinationRaw;\n  }\n\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    return destinationRaw(code);\n  }\n}\n\nmodule.exports = destinationFactory;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiAlpha = regexCheck(/[A-Za-z]/);\nmodule.exports = asciiAlpha;","'use strict'; // Counts tabs based on their expanded size, and CR+LF as one character.\n\nfunction sizeChunks(chunks) {\n  var index = -1;\n  var size = 0;\n\n  while (++index < chunks.length) {\n    size += typeof chunks[index] === 'string' ? chunks[index].length : 1;\n  }\n\n  return size;\n}\n\nmodule.exports = sizeChunks;","'use strict';\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit: exit\n};\n\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    if (code === 62) {\n      if (!self.containerState.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        });\n        self.containerState.open = true;\n      }\n\n      effects.enter('blockQuotePrefix');\n      effects.enter('blockQuoteMarker');\n      effects.consume(code);\n      effects.exit('blockQuoteMarker');\n      return after;\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter('blockQuotePrefixWhitespace');\n      effects.consume(code);\n      effects.exit('blockQuotePrefixWhitespace');\n      effects.exit('blockQuotePrefix');\n      return ok;\n    }\n\n    effects.exit('blockQuotePrefix');\n    return ok(code);\n  }\n}\n\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  return factorySpace(effects, effects.attempt(blockQuote, ok, nok), 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n}\n\nfunction exit(effects) {\n  effects.exit('blockQuote');\n}\n\nmodule.exports = blockQuote;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownSpace = require('../character/markdown-space.js'); // eslint-disable-next-line max-params\n\n\nfunction labelFactory(effects, ok, nok, type, markerType, stringType) {\n  var self = this;\n  var size = 0;\n  var data;\n  return start;\n\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    effects.enter(stringType);\n    return atBreak;\n  }\n\n  function atBreak(code) {\n    if (code === null || code === 91 || code === 93 && !data ||\n    /* c8 ignore next */\n    code === 94 &&\n    /* c8 ignore next */\n    !size &&\n    /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs || size > 999) {\n      return nok(code);\n    }\n\n    if (code === 93) {\n      effects.exit(stringType);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return atBreak;\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return label(code);\n  }\n\n  function label(code) {\n    if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {\n      effects.exit('chunkString');\n      return atBreak(code);\n    }\n\n    effects.consume(code);\n    data = data || !markdownSpace(code);\n    return code === 92 ? labelEscape : label;\n  }\n\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return label;\n    }\n\n    return label(code);\n  }\n}\n\nmodule.exports = labelFactory;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiDigit = regexCheck(/\\d/);\nmodule.exports = asciiDigit;","'use strict';\n\nmodule.exports = visitParents;\n\nvar convert = require('unist-util-is/convert');\n\nvar color = require('./color');\n\nvar CONTINUE = true;\nvar SKIP = 'skip';\nvar EXIT = false;\nvisitParents.CONTINUE = CONTINUE;\nvisitParents.SKIP = SKIP;\nvisitParents.EXIT = EXIT;\n\nfunction visitParents(tree, test, visitor, reverse) {\n  var step;\n  var is;\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n\n  is = convert(test);\n  step = reverse ? -1 : 1;\n  factory(tree, null, [])();\n\n  function factory(node, index, parents) {\n    var value = typeof node === 'object' && node !== null ? node : {};\n    var name;\n\n    if (typeof value.type === 'string') {\n      name = typeof value.tagName === 'string' ? value.tagName : typeof value.name === 'string' ? value.name : undefined;\n      visit.displayName = 'node (' + color(value.type + (name ? '<' + name + '>' : '')) + ')';\n    }\n\n    return visit;\n\n    function visit() {\n      var grandparents = parents.concat(node);\n      var result = [];\n      var subresult;\n      var offset;\n\n      if (!test || is(node, index, parents[parents.length - 1] || null)) {\n        result = toResult(visitor(node, parents));\n\n        if (result[0] === EXIT) {\n          return result;\n        }\n      }\n\n      if (node.children && result[0] !== SKIP) {\n        offset = (reverse ? node.children.length : -1) + step;\n\n        while (offset > -1 && offset < node.children.length) {\n          subresult = factory(node.children[offset], offset, grandparents)();\n\n          if (subresult[0] === EXIT) {\n            return subresult;\n          }\n\n          offset = typeof subresult[1] === 'number' ? subresult[1] : offset + step;\n        }\n      }\n\n      return result;\n    }\n  }\n}\n\nfunction toResult(value) {\n  if (value !== null && typeof value === 'object' && 'length' in value) {\n    return value;\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value];\n  }\n\n  return [value];\n}","'use strict';\n\nvar search = /[\\0\\t\\n\\r]/g;\n\nfunction preprocess() {\n  var start = true;\n  var column = 1;\n  var buffer = '';\n  var atCarriageReturn;\n  return preprocessor;\n\n  function preprocessor(value, encoding, end) {\n    var chunks = [];\n    var match;\n    var next;\n    var startPosition;\n    var endPosition;\n    var code;\n    value = buffer + value.toString(encoding);\n    startPosition = 0;\n    buffer = '';\n\n    if (start) {\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n\n      start = undefined;\n    }\n\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition;\n      match = search.exec(value);\n      endPosition = match ? match.index : value.length;\n      code = value.charCodeAt(endPosition);\n\n      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\n      }\n\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3);\n        atCarriageReturn = undefined;\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5);\n          atCarriageReturn = undefined;\n        }\n\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\n        }\n\n        if (code === 0) {\n          chunks.push(65533);\n          column++;\n        } else if (code === 9) {\n          next = Math.ceil(column / 4) * 4;\n          chunks.push(-2);\n\n          while (column++ < next) {\n            chunks.push(-1);\n          }\n        } else if (code === 10) {\n          chunks.push(-4);\n          column = 1;\n        } // Must be carriage return.\n        else {\n            atCarriageReturn = true;\n            column = 1;\n          }\n      }\n\n      startPosition = endPosition + 1;\n    }\n\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n\n    return chunks;\n  }\n}\n\nmodule.exports = preprocess;","'use strict';\n\nvar hasOwnProperty = require('../constant/has-own-property.js');\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nvar miniflat = require('./miniflat.js');\n\nfunction combineExtensions(extensions) {\n  var all = {};\n  var index = -1;\n\n  while (++index < extensions.length) {\n    extension(all, extensions[index]);\n  }\n\n  return all;\n}\n\nfunction extension(all, extension) {\n  var hook;\n  var left;\n  var right;\n  var code;\n\n  for (hook in extension) {\n    left = hasOwnProperty.call(all, hook) ? all[hook] : all[hook] = {};\n    right = extension[hook];\n\n    for (code in right) {\n      left[code] = constructs(miniflat(right[code]), hasOwnProperty.call(left, code) ? left[code] : []);\n    }\n  }\n}\n\nfunction constructs(list, existing) {\n  var index = -1;\n  var before = [];\n\n  while (++index < list.length) {\n    ;\n    (list[index].add === 'after' ? existing : before).push(list[index]);\n  }\n\n  chunkedSplice(existing, 0, 0, before);\n  return existing;\n}\n\nmodule.exports = combineExtensions;","'use strict';\n\nfunction miniflat(value) {\n  return value === null || value === undefined ? [] : 'length' in value ? value : [value];\n}\n\nmodule.exports = miniflat;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\nmodule.exports = asciiPunctuation;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar subtokenize = require('../util/subtokenize.js');\n\nvar factorySpace = require('./factory-space.js'); // No name because it must not be turned off.\n\n\nvar content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent,\n  interruptible: true,\n  lazy: true\n};\nvar continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n}; // Content is transparent: it’s parsed right now. That way, definitions are also\n// parsed right now: before text in paragraphs (specifically, media) are parsed.\n\nfunction resolveContent(events) {\n  subtokenize(events);\n  return events;\n}\n\nfunction tokenizeContent(effects, ok) {\n  var previous;\n  return start;\n\n  function start(code) {\n    effects.enter('content');\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    });\n    return data(code);\n  }\n\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    } // Data.\n\n\n    effects.consume(code);\n    return data;\n  }\n\n  function contentEnd(code) {\n    effects.exit('chunkContent');\n    effects.exit('content');\n    return ok(code);\n  }\n\n  function contentContinue(code) {\n    effects.consume(code);\n    effects.exit('chunkContent');\n    previous = previous.next = effects.enter('chunkContent', {\n      contentType: 'content',\n      previous: previous\n    });\n    return data;\n  }\n}\n\nfunction tokenizeContinuation(effects, ok, nok) {\n  var self = this;\n  return startLookahead;\n\n  function startLookahead(code) {\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, prefixed, 'linePrefix');\n  }\n\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    if (self.parser.constructs.disable.null.indexOf('codeIndented') > -1 || prefixSize(self.events, 'linePrefix') < 4) {\n      return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\n    }\n\n    return ok(code);\n  }\n}\n\nmodule.exports = content;","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nfunction regexCheck(regex) {\n  return check;\n\n  function check(code) {\n    return regex.test(fromCharCode(code));\n  }\n}\n\nmodule.exports = regexCheck;","'use strict';\n\nvar p = require('./minpath');\n\nvar proc = require('./minproc');\n\nvar buffer = require('is-buffer');\n\nmodule.exports = VFile;\nvar own = {}.hasOwnProperty; // Order of setting (least specific to most), we need this because otherwise\n// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n// stem can be set.\n\nvar order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];\nVFile.prototype.toString = toString; // Access full path (`~/index.min.js`).\n\nObject.defineProperty(VFile.prototype, 'path', {\n  get: getPath,\n  set: setPath\n}); // Access parent path (`~`).\n\nObject.defineProperty(VFile.prototype, 'dirname', {\n  get: getDirname,\n  set: setDirname\n}); // Access basename (`index.min.js`).\n\nObject.defineProperty(VFile.prototype, 'basename', {\n  get: getBasename,\n  set: setBasename\n}); // Access extname (`.js`).\n\nObject.defineProperty(VFile.prototype, 'extname', {\n  get: getExtname,\n  set: setExtname\n}); // Access stem (`index.min`).\n\nObject.defineProperty(VFile.prototype, 'stem', {\n  get: getStem,\n  set: setStem\n}); // Construct a new file.\n\nfunction VFile(options) {\n  var prop;\n  var index;\n\n  if (!options) {\n    options = {};\n  } else if (typeof options === 'string' || buffer(options)) {\n    options = {\n      contents: options\n    };\n  } else if ('message' in options && 'messages' in options) {\n    return options;\n  }\n\n  if (!(this instanceof VFile)) {\n    return new VFile(options);\n  }\n\n  this.data = {};\n  this.messages = [];\n  this.history = [];\n  this.cwd = proc.cwd(); // Set path related properties in the correct order.\n\n  index = -1;\n\n  while (++index < order.length) {\n    prop = order[index];\n\n    if (own.call(options, prop)) {\n      this[prop] = options[prop];\n    }\n  } // Set non-path related properties.\n\n\n  for (prop in options) {\n    if (order.indexOf(prop) < 0) {\n      this[prop] = options[prop];\n    }\n  }\n}\n\nfunction getPath() {\n  return this.history[this.history.length - 1];\n}\n\nfunction setPath(path) {\n  assertNonEmpty(path, 'path');\n\n  if (this.path !== path) {\n    this.history.push(path);\n  }\n}\n\nfunction getDirname() {\n  return typeof this.path === 'string' ? p.dirname(this.path) : undefined;\n}\n\nfunction setDirname(dirname) {\n  assertPath(this.path, 'dirname');\n  this.path = p.join(dirname || '', this.basename);\n}\n\nfunction getBasename() {\n  return typeof this.path === 'string' ? p.basename(this.path) : undefined;\n}\n\nfunction setBasename(basename) {\n  assertNonEmpty(basename, 'basename');\n  assertPart(basename, 'basename');\n  this.path = p.join(this.dirname || '', basename);\n}\n\nfunction getExtname() {\n  return typeof this.path === 'string' ? p.extname(this.path) : undefined;\n}\n\nfunction setExtname(extname) {\n  assertPart(extname, 'extname');\n  assertPath(this.path, 'extname');\n\n  if (extname) {\n    if (extname.charCodeAt(0) !== 46\n    /* `.` */\n    ) {\n        throw new Error('`extname` must start with `.`');\n      }\n\n    if (extname.indexOf('.', 1) > -1) {\n      throw new Error('`extname` cannot contain multiple dots');\n    }\n  }\n\n  this.path = p.join(this.dirname, this.stem + (extname || ''));\n}\n\nfunction getStem() {\n  return typeof this.path === 'string' ? p.basename(this.path, this.extname) : undefined;\n}\n\nfunction setStem(stem) {\n  assertNonEmpty(stem, 'stem');\n  assertPart(stem, 'stem');\n  this.path = p.join(this.dirname || '', stem + (this.extname || ''));\n} // Get the value of the file.\n\n\nfunction toString(encoding) {\n  return (this.contents || '').toString(encoding);\n} // Assert that `part` is not a path (i.e., does not contain `p.sep`).\n\n\nfunction assertPart(part, name) {\n  if (part && part.indexOf(p.sep) > -1) {\n    throw new Error('`' + name + '` cannot be a path: did not expect `' + p.sep + '`');\n  }\n} // Assert that `part` is not empty.\n\n\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty');\n  }\n} // Assert `path` exists.\n\n\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too');\n  }\n}","\"use strict\";\n\nvar visit = require('unist-util-visit');\n\nvar splice = [].splice;\n\nexports.ofType = function (types, mode) {\n  return ifNotMatch(allow, mode);\n\n  function allow(node, index, parent) {\n    return !types.includes(node.type);\n  }\n};\n\nexports.ifNotMatch = ifNotMatch;\n\nfunction ifNotMatch(allow, mode) {\n  return transform;\n\n  function transform(tree) {\n    visit(tree, filter);\n    return tree;\n  } // eslint-disable-next-line consistent-return\n\n\n  function filter(node, index, parent) {\n    if (parent && !allow(node, index, parent)) {\n      var parameters = [index, 1];\n\n      if (mode === 'unwrap' && node.children) {\n        parameters = parameters.concat(node.children);\n      }\n\n      splice.apply(parent.children, parameters);\n      return index;\n    }\n  }\n}","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar unicodeWhitespace = regexCheck(/\\s/);\nmodule.exports = unicodeWhitespace;","'use strict'; // A derivative work based on:\n// <https://github.com/browserify/path-browserify>.\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// <https://github.com/nodejs/node/blob/master/lib/path.js>.\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexports.basename = basename;\nexports.dirname = dirname;\nexports.extname = extname;\nexports.join = join;\nexports.sep = '/';\n\nfunction basename(path, ext) {\n  var start = 0;\n  var end = -1;\n  var index;\n  var firstNonSlashEnd;\n  var seenNonSlash;\n  var extIndex;\n\n  if (ext !== undefined && typeof ext !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n\n  assertPath(path);\n  index = path.length;\n\n  if (ext === undefined || !ext.length || ext.length > path.length) {\n    while (index--) {\n      if (path.charCodeAt(index) === 47\n      /* `/` */\n      ) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now.\n          if (seenNonSlash) {\n            start = index + 1;\n            break;\n          }\n        } else if (end < 0) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component.\n        seenNonSlash = true;\n        end = index + 1;\n      }\n    }\n\n    return end < 0 ? '' : path.slice(start, end);\n  }\n\n  if (ext === path) {\n    return '';\n  }\n\n  firstNonSlashEnd = -1;\n  extIndex = ext.length - 1;\n\n  while (index--) {\n    if (path.charCodeAt(index) === 47\n    /* `/` */\n    ) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (seenNonSlash) {\n          start = index + 1;\n          break;\n        }\n      } else {\n      if (firstNonSlashEnd < 0) {\n        // We saw the first non-path separator, remember this index in case\n        // we need it if the extension ends up not matching.\n        seenNonSlash = true;\n        firstNonSlashEnd = index + 1;\n      }\n\n      if (extIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n          if (extIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index;\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extIndex = -1;\n          end = firstNonSlashEnd;\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd;\n  } else if (end < 0) {\n    end = path.length;\n  }\n\n  return path.slice(start, end);\n}\n\nfunction dirname(path) {\n  var end;\n  var unmatchedSlash;\n  var index;\n  assertPath(path);\n\n  if (!path.length) {\n    return '.';\n  }\n\n  end = -1;\n  index = path.length; // Prefix `--` is important to not run on `0`.\n\n  while (--index) {\n    if (path.charCodeAt(index) === 47\n    /* `/` */\n    ) {\n        if (unmatchedSlash) {\n          end = index;\n          break;\n        }\n      } else if (!unmatchedSlash) {\n      // We saw the first non-path separator\n      unmatchedSlash = true;\n    }\n  }\n\n  return end < 0 ? path.charCodeAt(0) === 47\n  /* `/` */\n  ? '/' : '.' : end === 1 && path.charCodeAt(0) === 47\n  /* `/` */\n  ? '//' : path.slice(0, end);\n}\n\nfunction extname(path) {\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1; // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n\n  var preDotState = 0;\n  var unmatchedSlash;\n  var code;\n  var index;\n  assertPath(path);\n  index = path.length;\n\n  while (index--) {\n    code = path.charCodeAt(index);\n\n    if (code === 47\n    /* `/` */\n    ) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (unmatchedSlash) {\n          startPart = index + 1;\n          break;\n        }\n\n        continue;\n      }\n\n    if (end < 0) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension.\n      unmatchedSlash = true;\n      end = index + 1;\n    }\n\n    if (code === 46\n    /* `.` */\n    ) {\n        // If this is our first dot, mark it as the start of our extension.\n        if (startDot < 0) {\n          startDot = index;\n        } else if (preDotState !== 1) {\n          preDotState = 1;\n        }\n      } else if (startDot > -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension.\n      preDotState = -1;\n    }\n  }\n\n  if (startDot < 0 || end < 0 || // We saw a non-dot character immediately before the dot.\n  preDotState === 0 || // The (right-most) trimmed path component is exactly `..`.\n  preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n\n  return path.slice(startDot, end);\n}\n\nfunction join() {\n  var index = -1;\n  var joined;\n\n  while (++index < arguments.length) {\n    assertPath(arguments[index]);\n\n    if (arguments[index]) {\n      joined = joined === undefined ? arguments[index] : joined + '/' + arguments[index];\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined);\n} // Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\n\n\nfunction normalize(path) {\n  var absolute;\n  var value;\n  assertPath(path);\n  absolute = path.charCodeAt(0) === 47;\n  /* `/` */\n  // Normalize the path according to POSIX rules.\n\n  value = normalizeString(path, !absolute);\n\n  if (!value.length && !absolute) {\n    value = '.';\n  }\n\n  if (value.length && path.charCodeAt(path.length - 1) === 47\n  /* / */\n  ) {\n      value += '/';\n    }\n\n  return absolute ? '/' + value : value;\n} // Resolve `.` and `..` elements in a path with directory names.\n\n\nfunction normalizeString(path, allowAboveRoot) {\n  var result = '';\n  var lastSegmentLength = 0;\n  var lastSlash = -1;\n  var dots = 0;\n  var index = -1;\n  var code;\n  var lastSlashIndex;\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.charCodeAt(index);\n    } else if (code === 47\n    /* `/` */\n    ) {\n        break;\n      } else {\n      code = 47;\n      /* `/` */\n    }\n\n    if (code === 47\n    /* `/` */\n    ) {\n        if (lastSlash === index - 1 || dots === 1) {// Empty.\n        } else if (lastSlash !== index - 1 && dots === 2) {\n          if (result.length < 2 || lastSegmentLength !== 2 || result.charCodeAt(result.length - 1) !== 46\n          /* `.` */\n          || result.charCodeAt(result.length - 2) !== 46\n          /* `.` */\n          ) {\n              if (result.length > 2) {\n                lastSlashIndex = result.lastIndexOf('/');\n                /* istanbul ignore else - No clue how to cover it. */\n\n                if (lastSlashIndex !== result.length - 1) {\n                  if (lastSlashIndex < 0) {\n                    result = '';\n                    lastSegmentLength = 0;\n                  } else {\n                    result = result.slice(0, lastSlashIndex);\n                    lastSegmentLength = result.length - 1 - result.lastIndexOf('/');\n                  }\n\n                  lastSlash = index;\n                  dots = 0;\n                  continue;\n                }\n              } else if (result.length) {\n                result = '';\n                lastSegmentLength = 0;\n                lastSlash = index;\n                dots = 0;\n                continue;\n              }\n            }\n\n          if (allowAboveRoot) {\n            result = result.length ? result + '/..' : '..';\n            lastSegmentLength = 2;\n          }\n        } else {\n          if (result.length) {\n            result += '/' + path.slice(lastSlash + 1, index);\n          } else {\n            result = path.slice(lastSlash + 1, index);\n          }\n\n          lastSegmentLength = index - lastSlash - 1;\n        }\n\n        lastSlash = index;\n        dots = 0;\n      } else if (code === 46\n    /* `.` */\n    && dots > -1) {\n      dots++;\n    } else {\n      dots = -1;\n    }\n  }\n\n  return result;\n}\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\n  }\n}","'use strict';\n/* Expose. */\n\nmodule.exports = visitParents;\n/* Visit. */\n\nfunction visitParents(tree, type, visitor) {\n  var stack = [];\n\n  if (typeof type === 'function') {\n    visitor = type;\n    type = null;\n  }\n\n  one(tree);\n  /* Visit a single node. */\n\n  function one(node) {\n    var result;\n\n    if (!type || node.type === type) {\n      result = visitor(node, stack.concat());\n    }\n\n    if (node.children && result !== false) {\n      return all(node.children, node);\n    }\n\n    return result;\n  }\n  /* Visit children in `parent`. */\n\n\n  function all(children, parent) {\n    var length = children.length;\n    var index = -1;\n    var child;\n    stack.push(parent);\n\n    while (++index < length) {\n      child = children[index];\n\n      if (child && one(child) === false) {\n        return false;\n      }\n    }\n\n    stack.pop();\n    return true;\n  }\n}","'use strict';\n\nmodule.exports = parse;\n\nvar fromMarkdown = require('mdast-util-from-markdown');\n\nfunction parse(options) {\n  var self = this;\n  this.Parser = parse;\n\n  function parse(doc) {\n    return fromMarkdown(doc, Object.assign({}, self.data('settings'), options, {\n      // Note: these options are not in the readme.\n      // The goal is for them to be set by plugins on `data` instead of being\n      // passed by users.\n      extensions: self.data('micromarkExtensions') || [],\n      mdastExtensions: self.data('fromMarkdownExtensions') || []\n    }));\n  }\n}","'use strict';\n\nmodule.exports = fromMarkdown; // These three are compiled away in the `dist/`\n\nvar toString = require('mdast-util-to-string');\n\nvar assign = require('micromark/dist/constant/assign');\n\nvar own = require('micromark/dist/constant/has-own-property');\n\nvar normalizeIdentifier = require('micromark/dist/util/normalize-identifier');\n\nvar safeFromInt = require('micromark/dist/util/safe-from-int');\n\nvar parser = require('micromark/dist/parse');\n\nvar preprocessor = require('micromark/dist/preprocess');\n\nvar postprocess = require('micromark/dist/postprocess');\n\nvar decode = require('parse-entities/decode-entity');\n\nvar stringifyPosition = require('unist-util-stringify-position');\n\nfunction fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding;\n    encoding = undefined;\n  }\n\n  return compiler(options)(postprocess(parser(options).document().write(preprocessor()(value, encoding, true))));\n} // Note this compiler only understand complete buffering, not streaming.\n\n\nfunction compiler(options) {\n  var settings = options || {};\n  var config = configure({\n    transforms: [],\n    canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],\n    enter: {\n      autolink: opener(link),\n      autolinkProtocol: onenterdata,\n      autolinkEmail: onenterdata,\n      atxHeading: opener(heading),\n      blockQuote: opener(blockQuote),\n      characterEscape: onenterdata,\n      characterReference: onenterdata,\n      codeFenced: opener(codeFlow),\n      codeFencedFenceInfo: buffer,\n      codeFencedFenceMeta: buffer,\n      codeIndented: opener(codeFlow, buffer),\n      codeText: opener(codeText, buffer),\n      codeTextData: onenterdata,\n      data: onenterdata,\n      codeFlowValue: onenterdata,\n      definition: opener(definition),\n      definitionDestinationString: buffer,\n      definitionLabelString: buffer,\n      definitionTitleString: buffer,\n      emphasis: opener(emphasis),\n      hardBreakEscape: opener(hardBreak),\n      hardBreakTrailing: opener(hardBreak),\n      htmlFlow: opener(html, buffer),\n      htmlFlowData: onenterdata,\n      htmlText: opener(html, buffer),\n      htmlTextData: onenterdata,\n      image: opener(image),\n      label: buffer,\n      link: opener(link),\n      listItem: opener(listItem),\n      listItemValue: onenterlistitemvalue,\n      listOrdered: opener(list, onenterlistordered),\n      listUnordered: opener(list),\n      paragraph: opener(paragraph),\n      reference: onenterreference,\n      referenceString: buffer,\n      resourceDestinationString: buffer,\n      resourceTitleString: buffer,\n      setextHeading: opener(heading),\n      strong: opener(strong),\n      thematicBreak: opener(thematicBreak)\n    },\n    exit: {\n      atxHeading: closer(),\n      atxHeadingSequence: onexitatxheadingsequence,\n      autolink: closer(),\n      autolinkEmail: onexitautolinkemail,\n      autolinkProtocol: onexitautolinkprotocol,\n      blockQuote: closer(),\n      characterEscapeValue: onexitdata,\n      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n      characterReferenceValue: onexitcharacterreferencevalue,\n      codeFenced: closer(onexitcodefenced),\n      codeFencedFence: onexitcodefencedfence,\n      codeFencedFenceInfo: onexitcodefencedfenceinfo,\n      codeFencedFenceMeta: onexitcodefencedfencemeta,\n      codeFlowValue: onexitdata,\n      codeIndented: closer(onexitcodeindented),\n      codeText: closer(onexitcodetext),\n      codeTextData: onexitdata,\n      data: onexitdata,\n      definition: closer(),\n      definitionDestinationString: onexitdefinitiondestinationstring,\n      definitionLabelString: onexitdefinitionlabelstring,\n      definitionTitleString: onexitdefinitiontitlestring,\n      emphasis: closer(),\n      hardBreakEscape: closer(onexithardbreak),\n      hardBreakTrailing: closer(onexithardbreak),\n      htmlFlow: closer(onexithtmlflow),\n      htmlFlowData: onexitdata,\n      htmlText: closer(onexithtmltext),\n      htmlTextData: onexitdata,\n      image: closer(onexitimage),\n      label: onexitlabel,\n      labelText: onexitlabeltext,\n      lineEnding: onexitlineending,\n      link: closer(onexitlink),\n      listItem: closer(),\n      listOrdered: closer(),\n      listUnordered: closer(),\n      paragraph: closer(),\n      referenceString: onexitreferencestring,\n      resourceDestinationString: onexitresourcedestinationstring,\n      resourceTitleString: onexitresourcetitlestring,\n      resource: onexitresource,\n      setextHeading: closer(onexitsetextheading),\n      setextHeadingLineSequence: onexitsetextheadinglinesequence,\n      setextHeadingText: onexitsetextheadingtext,\n      strong: closer(),\n      thematicBreak: closer()\n    }\n  }, settings.mdastExtensions || []);\n  var data = {};\n  return compile;\n\n  function compile(events) {\n    var tree = {\n      type: 'root',\n      children: []\n    };\n    var stack = [tree];\n    var tokenStack = [];\n    var listStack = [];\n    var index = -1;\n    var handler;\n    var listStart;\n    var context = {\n      stack: stack,\n      tokenStack: tokenStack,\n      config: config,\n      enter: enter,\n      exit: exit,\n      buffer: buffer,\n      resume: resume,\n      setData: setData,\n      getData: getData\n    };\n\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (events[index][1].type === 'listOrdered' || events[index][1].type === 'listUnordered') {\n        if (events[index][0] === 'enter') {\n          listStack.push(index);\n        } else {\n          listStart = listStack.pop(index);\n          index = prepareList(events, listStart, index);\n        }\n      }\n    }\n\n    index = -1;\n\n    while (++index < events.length) {\n      handler = config[events[index][0]];\n\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(assign({\n          sliceSerialize: events[index][2].sliceSerialize\n        }, context), events[index][1]);\n      }\n    }\n\n    if (tokenStack.length) {\n      throw new Error('Cannot close document, a token (`' + tokenStack[tokenStack.length - 1].type + '`, ' + stringifyPosition({\n        start: tokenStack[tokenStack.length - 1].start,\n        end: tokenStack[tokenStack.length - 1].end\n      }) + ') is still open');\n    } // Figure out `root` position.\n\n\n    tree.position = {\n      start: point(events.length ? events[0][1].start : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }),\n      end: point(events.length ? events[events.length - 2][1].end : {\n        line: 1,\n        column: 1,\n        offset: 0\n      })\n    };\n    index = -1;\n\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree;\n    }\n\n    return tree;\n  }\n\n  function prepareList(events, start, length) {\n    var index = start - 1;\n    var containerBalance = -1;\n    var listSpread = false;\n    var listItem;\n    var tailIndex;\n    var lineIndex;\n    var tailEvent;\n    var event;\n    var firstBlankLineIndex;\n    var atMarker;\n\n    while (++index <= length) {\n      event = events[index];\n\n      if (event[1].type === 'listUnordered' || event[1].type === 'listOrdered' || event[1].type === 'blockQuote') {\n        if (event[0] === 'enter') {\n          containerBalance++;\n        } else {\n          containerBalance--;\n        }\n\n        atMarker = undefined;\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (listItem && !atMarker && !containerBalance && !firstBlankLineIndex) {\n            firstBlankLineIndex = index;\n          }\n\n          atMarker = undefined;\n        }\n      } else if (event[1].type === 'linePrefix' || event[1].type === 'listItemValue' || event[1].type === 'listItemMarker' || event[1].type === 'listItemPrefix' || event[1].type === 'listItemPrefixWhitespace') {// Empty.\n      } else {\n        atMarker = undefined;\n      }\n\n      if (!containerBalance && event[0] === 'enter' && event[1].type === 'listItemPrefix' || containerBalance === -1 && event[0] === 'exit' && (event[1].type === 'listUnordered' || event[1].type === 'listOrdered')) {\n        if (listItem) {\n          tailIndex = index;\n          lineIndex = undefined;\n\n          while (tailIndex--) {\n            tailEvent = events[tailIndex];\n\n            if (tailEvent[1].type === 'lineEnding' || tailEvent[1].type === 'lineEndingBlank') {\n              if (tailEvent[0] === 'exit') continue;\n\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank';\n                listSpread = true;\n              }\n\n              tailEvent[1].type = 'lineEnding';\n              lineIndex = tailIndex;\n            } else if (tailEvent[1].type === 'linePrefix' || tailEvent[1].type === 'blockQuotePrefix' || tailEvent[1].type === 'blockQuotePrefixWhitespace' || tailEvent[1].type === 'blockQuoteMarker' || tailEvent[1].type === 'listItemIndent') {// Empty\n            } else {\n              break;\n            }\n          }\n\n          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {\n            listItem._spread = true;\n          } // Fix position.\n\n\n          listItem.end = point(lineIndex ? events[lineIndex][1].start : event[1].end);\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]]);\n          index++;\n          length++;\n        } // Create a new list item.\n\n\n        if (event[1].type === 'listItemPrefix') {\n          listItem = {\n            type: 'listItem',\n            _spread: false,\n            start: point(event[1].start)\n          };\n          events.splice(index, 0, ['enter', listItem, event[2]]);\n          index++;\n          length++;\n          firstBlankLineIndex = undefined;\n          atMarker = true;\n        }\n      }\n    }\n\n    events[start][1]._spread = listSpread;\n    return length;\n  }\n\n  function setData(key, value) {\n    data[key] = value;\n  }\n\n  function getData(key) {\n    return data[key];\n  }\n\n  function point(d) {\n    return {\n      line: d.line,\n      column: d.column,\n      offset: d.offset\n    };\n  }\n\n  function opener(create, and) {\n    return open;\n\n    function open(token) {\n      enter.call(this, create(token), token);\n      if (and) and.call(this, token);\n    }\n  }\n\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    });\n  }\n\n  function enter(node, token) {\n    this.stack[this.stack.length - 1].children.push(node);\n    this.stack.push(node);\n    this.tokenStack.push(token);\n    node.position = {\n      start: point(token.start)\n    };\n    return node;\n  }\n\n  function closer(and) {\n    return close;\n\n    function close(token) {\n      if (and) and.call(this, token);\n      exit.call(this, token);\n    }\n  }\n\n  function exit(token) {\n    var node = this.stack.pop();\n    var open = this.tokenStack.pop();\n\n    if (!open) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): it’s not open');\n    } else if (open.type !== token.type) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): a different token (`' + open.type + '`, ' + stringifyPosition({\n        start: open.start,\n        end: open.end\n      }) + ') is open');\n    }\n\n    node.position.end = point(token.end);\n    return node;\n  }\n\n  function resume() {\n    return toString(this.stack.pop());\n  } //\n  // Handlers.\n  //\n\n\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true);\n  }\n\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      this.stack[this.stack.length - 2].start = parseInt(this.sliceSerialize(token), 10);\n      setData('expectingFirstListItemValue');\n    }\n  }\n\n  function onexitcodefencedfenceinfo() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].lang = data;\n  }\n\n  function onexitcodefencedfencemeta() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].meta = data;\n  }\n\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (getData('flowCodeInside')) return;\n    this.buffer();\n    setData('flowCodeInside', true);\n  }\n\n  function onexitcodefenced() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '');\n    setData('flowCodeInside');\n  }\n\n  function onexitcodeindented() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexitdefinitionlabelstring(token) {\n    // Discard label, use the source content instead.\n    var label = this.resume();\n    this.stack[this.stack.length - 1].label = label;\n    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n\n  function onexitdefinitiontitlestring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].title = data;\n  }\n\n  function onexitdefinitiondestinationstring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].url = data;\n  }\n\n  function onexitatxheadingsequence(token) {\n    if (!this.stack[this.stack.length - 1].depth) {\n      this.stack[this.stack.length - 1].depth = this.sliceSerialize(token).length;\n    }\n  }\n\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true);\n  }\n\n  function onexitsetextheadinglinesequence(token) {\n    this.stack[this.stack.length - 1].depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2;\n  }\n\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding');\n  }\n\n  function onenterdata(token) {\n    var siblings = this.stack[this.stack.length - 1].children;\n    var tail = siblings[siblings.length - 1];\n\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text();\n      tail.position = {\n        start: point(token.start)\n      };\n      this.stack[this.stack.length - 1].children.push(tail);\n    }\n\n    this.stack.push(tail);\n  }\n\n  function onexitdata(token) {\n    var tail = this.stack.pop();\n    tail.value += this.sliceSerialize(token);\n    tail.position.end = point(token.end);\n  }\n\n  function onexitlineending(token) {\n    var context = this.stack[this.stack.length - 1]; // If we’re at a hard break, include the line ending in there.\n\n    if (getData('atHardBreak')) {\n      context.children[context.children.length - 1].position.end = point(token.end);\n      setData('atHardBreak');\n      return;\n    }\n\n    if (!getData('setextHeadingSlurpLineEnding') && config.canContainEols.indexOf(context.type) > -1) {\n      onenterdata.call(this, token);\n      onexitdata.call(this, token);\n    }\n  }\n\n  function onexithardbreak() {\n    setData('atHardBreak', true);\n  }\n\n  function onexithtmlflow() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexithtmltext() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexitcodetext() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexitlink() {\n    var context = this.stack[this.stack.length - 1]; // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference';\n      context.referenceType = getData('referenceType') || 'shortcut';\n      delete context.url;\n      delete context.title;\n    } else {\n      delete context.identifier;\n      delete context.label;\n      delete context.referenceType;\n    }\n\n    setData('referenceType');\n  }\n\n  function onexitimage() {\n    var context = this.stack[this.stack.length - 1]; // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference';\n      context.referenceType = getData('referenceType') || 'shortcut';\n      delete context.url;\n      delete context.title;\n    } else {\n      delete context.identifier;\n      delete context.label;\n      delete context.referenceType;\n    }\n\n    setData('referenceType');\n  }\n\n  function onexitlabeltext(token) {\n    this.stack[this.stack.length - 2].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n\n  function onexitlabel() {\n    var fragment = this.stack[this.stack.length - 1];\n    var value = this.resume();\n    this.stack[this.stack.length - 1].label = value; // Assume a reference.\n\n    setData('inReference', true);\n\n    if (this.stack[this.stack.length - 1].type === 'link') {\n      this.stack[this.stack.length - 1].children = fragment.children;\n    } else {\n      this.stack[this.stack.length - 1].alt = value;\n    }\n  }\n\n  function onexitresourcedestinationstring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].url = data;\n  }\n\n  function onexitresourcetitlestring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].title = data;\n  }\n\n  function onexitresource() {\n    setData('inReference');\n  }\n\n  function onenterreference() {\n    setData('referenceType', 'collapsed');\n  }\n\n  function onexitreferencestring(token) {\n    var label = this.resume();\n    this.stack[this.stack.length - 1].label = label;\n    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n    setData('referenceType', 'full');\n  }\n\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type);\n  }\n\n  function onexitcharacterreferencevalue(token) {\n    var data = this.sliceSerialize(token);\n    var type = getData('characterReferenceType');\n    var value;\n    var tail;\n\n    if (type) {\n      value = safeFromInt(data, type === 'characterReferenceMarkerNumeric' ? 10 : 16);\n      setData('characterReferenceType');\n    } else {\n      value = decode(data);\n    }\n\n    tail = this.stack.pop();\n    tail.value += value;\n    tail.position.end = point(token.end);\n  }\n\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token);\n    this.stack[this.stack.length - 1].url = this.sliceSerialize(token);\n  }\n\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token);\n    this.stack[this.stack.length - 1].url = 'mailto:' + this.sliceSerialize(token);\n  } //\n  // Creaters.\n  //\n\n\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    };\n  }\n\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    };\n  }\n\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    };\n  }\n\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    };\n  }\n\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    };\n  }\n\n  function heading() {\n    return {\n      type: 'heading',\n      depth: undefined,\n      children: []\n    };\n  }\n\n  function hardBreak() {\n    return {\n      type: 'break'\n    };\n  }\n\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    };\n  }\n\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    };\n  }\n\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    };\n  }\n\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      spread: token._spread,\n      children: []\n    };\n  }\n\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    };\n  }\n\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    };\n  }\n\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    };\n  }\n\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    };\n  }\n\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    };\n  }\n}\n\nfunction configure(config, extensions) {\n  var index = -1;\n\n  while (++index < extensions.length) {\n    extension(config, extensions[index]);\n  }\n\n  return config;\n}\n\nfunction extension(config, extension) {\n  var key;\n  var left;\n\n  for (key in extension) {\n    left = own.call(config, key) ? config[key] : config[key] = {};\n\n    if (key === 'canContainEols' || key === 'transforms') {\n      config[key] = [].concat(left, extension[key]);\n    } else {\n      Object.assign(left, extension[key]);\n    }\n  }\n}","var visitWithParents = require('unist-util-visit-parents');\n\nfunction addListMetadata() {\n  return function (ast) {\n    visitWithParents(ast, 'list', function (listNode, parents) {\n      var depth = 0,\n          i,\n          n;\n\n      for (i = 0, n = parents.length; i < n; i++) {\n        if (parents[i].type === 'list') depth += 1;\n      }\n\n      for (i = 0, n = listNode.children.length; i < n; i++) {\n        var child = listNode.children[i];\n        child.index = i;\n        child.ordered = listNode.ordered;\n      }\n\n      listNode.depth = depth;\n    });\n    return ast;\n  };\n}\n\nmodule.exports = addListMetadata;","'use strict';\n\nvar wrap = require('./wrap.js');\n\nmodule.exports = trough;\ntrough.wrap = wrap;\nvar slice = [].slice; // Create new middleware.\n\nfunction trough() {\n  var fns = [];\n  var middleware = {};\n  middleware.run = run;\n  middleware.use = use;\n  return middleware; // Run `fns`.  Last argument must be a completion handler.\n\n  function run() {\n    var index = -1;\n    var input = slice.call(arguments, 0, -1);\n    var done = arguments[arguments.length - 1];\n\n    if (typeof done !== 'function') {\n      throw new Error('Expected function as last argument, not ' + done);\n    }\n\n    next.apply(null, [null].concat(input)); // Run the next `fn`, if any.\n\n    function next(err) {\n      var fn = fns[++index];\n      var params = slice.call(arguments, 0);\n      var values = params.slice(1);\n      var length = input.length;\n      var pos = -1;\n\n      if (err) {\n        done(err);\n        return;\n      } // Copy non-nully input into values.\n\n\n      while (++pos < length) {\n        if (values[pos] === null || values[pos] === undefined) {\n          values[pos] = input[pos];\n        }\n      }\n\n      input = values; // Next or done.\n\n      if (fn) {\n        wrap(fn, next).apply(null, input);\n      } else {\n        done.apply(null, [null].concat(input));\n      }\n    }\n  } // Add `fn` to the list.\n\n\n  function use(fn) {\n    if (typeof fn !== 'function') {\n      throw new Error('Expected `fn` to be a function, not ' + fn);\n    }\n\n    fns.push(fn);\n    return middleware;\n  }\n}","'use strict';\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nfunction spaceFactory(effects, ok, type, max) {\n  var limit = max ? max - 1 : Infinity;\n  var size = 0;\n  return start;\n\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n\n    return ok(code);\n  }\n\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n\n    effects.exit(type);\n    return ok(code);\n  }\n}\n\nmodule.exports = spaceFactory;"],"sourceRoot":""}