{"version":3,"sources":["webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/move-point.js","webpack:///./node_modules/vfile/lib/minproc.browser.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/character/markdown-space.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/character/ascii-control.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/character-reference.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/constant/html-block-names.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/subtokenize.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/line-ending.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/label-start-image.js","webpack:///./node_modules/vfile/node_modules/unist-util-stringify-position/index.js","webpack:///./node_modules/react-markdown/lib/renderers.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/resolve-all.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/factory-title.js","webpack:///./node_modules/extend/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/preprocess.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/content.js","webpack:///./node_modules/react-markdown/lib/wrap-table-rows.js","webpack:///./node_modules/react-markdown/node_modules/mdast-util-to-string/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/factory-space.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/code-indented.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/factory-label.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/attention.js","webpack:///./node_modules/is-buffer/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/factory-destination.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/character-escape.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/thematic-break.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/parse.js","webpack:///./node_modules/trough/wrap.js","webpack:///./node_modules/vfile/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/block-quote.js","webpack:///./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/color.browser.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/initialize/text.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/chunked-splice.js","webpack:///./node_modules/bail/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/slice-chunks.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/character/ascii-digit.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/serialize-chunks.js","webpack:///./node_modules/react-markdown/lib/get-definitions.js","webpack:///./node_modules/react-markdown/lib/react-markdown.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/hard-break-escape.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/normalize-identifier.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/constant/splice.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/initialize/flow.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/character/ascii-hex-digit.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/create-tokenizer.js","webpack:///./node_modules/react-markdown/node_modules/unist-util-stringify-position/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/postprocess.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/constant/assign.js","webpack:///./node_modules/is-plain-obj/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/code-text.js","webpack:///./node_modules/react-markdown/lib/uri-transformer.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/label-start-link.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/combine-extensions.js","webpack:///./node_modules/unist-util-visit/node_modules/unist-util-is/convert.js","webpack:///./node_modules/vfile/lib/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/partial-blank-line.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/character/markdown-line-ending.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/constant/from-char-code.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/character/unicode-punctuation.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/classify-character.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/autolink.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/constant/unicode-punctuation-regex.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/heading-atx.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/size-chunks.js","webpack:///./node_modules/xtend/immutable.js","webpack:///./node_modules/react-markdown/lib/ast-to-react.js","webpack:///./node_modules/mdast-add-list-metadata/node_modules/unist-util-visit-parents/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/constant/html-raw-names.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/html-flow.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/character/ascii-alpha.js","webpack:///./node_modules/react-markdown/node_modules/unified/index.js","webpack:///./node_modules/unist-util-visit/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/shallow.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/constructs.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/code-fenced.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/constant/has-own-property.js","webpack:///./node_modules/react-markdown/lib/plugins/naive-html.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/prefix-size.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/initialize/content.js","webpack:///./node_modules/vfile/node_modules/vfile-message/index.js","webpack:///./node_modules/react-markdown/node_modules/mdast-util-from-markdown/index.js","webpack:///./node_modules/react-markdown/lib/symbols.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/initialize/document.js","webpack:///./node_modules/react-markdown/node_modules/parse-entities/decode-entity.browser.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/list.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/character/unicode-whitespace.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/character/ascii-alphanumeric.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/factory-whitespace.js","webpack:///./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/character/ascii-punctuation.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/safe-from-int.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/regex-check.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/html-text.js","webpack:///./node_modules/react-markdown/node_modules/mdast-util-from-markdown/dist/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/definition.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/miniflat.js","webpack:///./node_modules/vfile/lib/core.js","webpack:///./node_modules/react-markdown/lib/plugins/disallow-node.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/character/ascii-atext.js","webpack:///./node_modules/vfile/lib/minpath.browser.js","webpack:///./node_modules/react-markdown/node_modules/remark-parse/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/label-end.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/util/chunked-push.js","webpack:///./node_modules/mdast-add-list-metadata/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/character/markdown-line-ending-or-space.js","webpack:///./node_modules/trough/index.js","webpack:///./node_modules/react-markdown/node_modules/micromark/dist/tokenize/setext-underline.js"],"names":["module","exports","point","offset","column","_bufferIndex","cwd","code","decodeEntity","asciiAlphanumeric","asciiDigit","asciiHexDigit","_interopDefaultLegacy","e","default","decodeEntity__default","characterReference","name","tokenize","effects","ok","nok","max","test","self","this","size","enter","consume","exit","open","numeric","value","token","sliceSerialize","assign","chunkedSplice","shallow","subcontent","events","eventIndex","stream","previous","index","entered","end","adjust","context","startPosition","startPositions","tokenizer","_tokenizer","parser","contentType","start","childEvents","jumps","gaps","push","sliceStream","next","defineSkip","isInFirstContentOfListItem","_gfmTasklistFirstContentOfListItem","write","undefined","length","type","line","add","slice","pop","unshift","event","lineIndex","otherIndex","otherEvent","parameters","subevents","more","_container","_movePreviousLineEndings","factorySpace","lineEnding","labelStartImage","after","constructs","resolveAll","own","hasOwnProperty","position","pos","call","xtend","React","supportsStringRender","parseInt","version","createElement","SimpleRenderer","tag","props","getCoreProps","children","source","break","paragraph","emphasis","strong","thematicBreak","blockquote","delete","link","image","linkReference","imageReference","table","bind","tableHead","tableBody","tableRow","tableCell","style","align","textAlign","coreProps","isHeader","root","className","Fragment","text","list","attrs","toString","ordered","listItem","checkbox","checked","readOnly","definition","heading","concat","level","inlineCode","language","html","skipHtml","dangerous","allowDangerousHtml","escapeHtml","isBlock","nodeProps","dangerouslySetInnerHTML","__html","virtualHtml","parsedHtml","cloneElement","element","resolve","called","indexOf","markdownLineEnding","markerType","stringType","marker","atFirstTitleBreak","atTitleBreak","title","titleEscape","hasOwn","Object","prototype","toStr","defineProperty","gOPD","getOwnPropertyDescriptor","isArray","arr","Array","isPlainObject","obj","key","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","options","enumerable","configurable","newValue","writable","getProperty","extend","src","copy","copyIsArray","clone","arguments","i","deep","search","atCarriageReturn","buffer","encoding","match","endPosition","chunks","charCodeAt","lastIndex","exec","Math","ceil","prefixSize","subtokenize","content","data","contentEnd","check","continuationConstruct","contentContinue","interruptible","lazy","prefixed","disable","null","interrupt","flow","partial","visit","wrap","node","alt","all","values","result","join","markdownSpace","limit","Infinity","prefix","codeIndented","attempt","indentedContentConstruct","afterPrefix","atBreak","label","labelEscape","chunkedPush","classifyCharacter","movePoint","attention","before","sequence","close","_open","_close","group","openingSequence","closingSequence","use","nextEvents","insideSpan","isBuffer","asciiControl","markdownLineEndingOrSpace","literalType","literalMarkerType","rawType","balance","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","asciiPunctuation","characterEscape","document","combineExtensions","createTokenizer","miniflat","defined","extensions","create","string","initializer","from","fn","callback","invoked","params","done","apply","error","then","Error","blockQuote","containerState","continuation","d","initializeFactory","resolver","createResolver","field","notText","resolveAllLineSuffixes","extraResolver","splice","chunk","bufferIndex","tabs","_index","remove","items","chunkStart","err","view","startIndex","startBufferIndex","endIndex","endBufferIndex","regexCheck","fromCharCode","atTab","tree","definitions","identifier","toUpperCase","href","url","unified","parse","PropTypes","addListMetadata","naiveHtml","disallowNode","astToReact","wrapTableRows","getDefinitions","uriTransformer","defaultRenderers","symbols","allTypes","keys","ReactMarkdown","allowedTypes","disallowedTypes","renderers","processor","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","hardBreakEscape","replace","toLowerCase","partialBlankLine","initial","currentConstruct","flowInitial","afterConstruct","serializeChunks","sliceChunks","initialize","columnStart","resolveAllConstructs","stack","accountForPotentialSkip","fields","now","constructFactory","construct","info","addResult","onsuccessfulcheck","main","state","chunkIndex","go","restore","onreturn","returnState","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","resolveTo","getPrototypeOf","codeText","sizeOpen","gap","tailExitIndex","headEnterIndex","protocols","uri","trim","first","charAt","colon","protocol","labelStartLink","extension","hook","left","right","existing","convert","Boolean","typeFactory","tests","checks","anyFactory","allFactory","VMessage","VFile","message","reason","origin","path","file","fatal","messages","fail","String","unicodePunctuationRegex","unicodePunctuation","unicodeWhitespace","asciiAlpha","asciiAtext","autolink","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","headingAtx","fenceOpenInside","headingBreak","contentStart","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","visitor","one","htmlBlockNames","htmlRawNames","htmlFlow","kind","startTag","declarationStart","tagCloseStart","continuationDeclarationInside","tagName","commentOpenInside","cdataOpenInside","basicSelfClosing","completeAttributeNameBefore","completeClosingTagAfter","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCharacterDataInside","continuationAtLineEnding","nextBlankConstruct","htmlContinueStart","continuationRawEndTag","concrete","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","cb","Promise","executor","reject","pipeline","p","ctx","contents","asyncName","visitParents","CONTINUE","SKIP","EXIT","reverse","parents","text$1","codeFenced","htmlText","labelEnd","setextUnderline","42","43","45","48","49","50","51","52","53","54","55","56","57","62","contentInitial","91","32","35","60","61","95","96","126","38","92","33","93","closingFenceConstruct","closingSequenceEnd","initialPrefix","sequenceOpen","infoOpen","openAfter","infoAfter","meta","selfClosingRe","simpleTagRe","currentParent","selfClosing","getSelfClosing","current","opening","getSimpleTag","matching","matchingTag","findAndPull","fromNode","toNode","fromIndex","toIndex","indent","virtual","sizeChunks","tail","lineStart","VMessagePrototype","proto","parts","range","location","parseOrigin","ruleId","Symbol","inspectResult","childFlow","childToken","continued","inspectConstruct","subcontinued","inspectStart","inspectContinue","inspectLess","flowContinue","inspectDone","containerConstruct","inspectFlowEnd","_closeFlow","lazyFlowConstruct","inspectLazy","flowEnd","documentContinue","documentContinued","flowStart","containerContinue","exitContainers","continueFlow","documentAfterPeek","characters","char","entity","innerHTML","textContent","initialSize","atMarker","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","furtherBlankLines","notInCurrentItem","indentConstruct","seen","color","step","is","factory","displayName","subresult","grandparents","toResult","base","regex","declarationOpen","instruction","tagOpen","commentOpen","cdataOpen","declaration","commentStart","commentStartDash","comment","commentClose","atLineEnding","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","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","normalizeIdentifier","onexithardbreak","referenceType","fragment","labelText","resource","setextHeadingLineSequence","setextHeadingText","mdastExtensions","handler","listStart","tokenStack","listStack","prepareList","stringifyPosition","tailIndex","tailEvent","firstBlankLineIndex","containerBalance","listSpread","and","siblings","compiler","postprocess","preprocessor","factoryDestination","factoryLabel","factoryWhitespace","factoryTitle","labelAfter","titleConstruct","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","fromMarkdown","labelStart","_balanced","_inactive","balanced","afterLabelEnd","resourceConstruct","fullReferenceConstruct","collapsedReferenceConstruct","media","_used","destinationAfter","between","afterLabel","visitWithParents","ast","listNode","n","fns","middleware","input"],"mappings":"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","file":"10825f697f4514eefd16dfcb24d70e0e27db0ace-7789506b8becf4ac9041.js","sourcesContent":["'use strict';\n\n// chunks (replacement characters, tabs, or line endings).\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n  return point;\n}\nmodule.exports = movePoint;","'use strict';\n\n// 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. 😅\nexports.cwd = cwd;\nfunction cwd() {\n  return '/';\n}","'use strict';\n\nfunction markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\nmodule.exports = markdownSpace;","'use strict';\n\n// Note: EOF is seen as ASCII control here, because `null < 32 == true`.\nfunction asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code < 32 || code === 127\n  );\n}\nmodule.exports = asciiControl;","'use strict';\n\nvar decodeEntity = require('parse-entities/decode-entity.js');\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\nvar asciiDigit = require('../character/ascii-digit.js');\nvar asciiHexDigit = require('../character/ascii-hex-digit.js');\nfunction _interopDefaultLegacy(e) {\n  return e && typeof e === 'object' && 'default' in e ? e : {\n    default: e\n  };\n}\nvar decodeEntity__default = /*#__PURE__*/_interopDefaultLegacy(decodeEntity);\nvar characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  var self = this;\n  var size = 0;\n  var max;\n  var test;\n  return start;\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  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric');\n      effects.consume(code);\n      effects.exit('characterReferenceMarkerNumeric');\n      return numeric;\n    }\n    effects.enter('characterReferenceValue');\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\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    effects.enter('characterReferenceValue');\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n  function value(code) {\n    var token;\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue');\n      if (test === asciiAlphanumeric && !decodeEntity__default['default'](self.sliceSerialize(token))) {\n        return nok(code);\n      }\n      effects.enter('characterReferenceMarker');\n      effects.consume(code);\n      effects.exit('characterReferenceMarker');\n      effects.exit('characterReference');\n      return ok;\n    }\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n    return nok(code);\n  }\n}\nmodule.exports = characterReference;","'use strict';\n\n// This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\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\nvar assign = require('../constant/assign.js');\nvar chunkedSplice = require('./chunked-splice.js');\nvar shallow = require('./shallow.js');\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  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\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      if (otherIndex < subevents.length && subevents[otherIndex][1].type === 'lineEndingBlank') {\n        otherIndex += 2;\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          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1].isInFirstContentOfListItem = true;\n            otherIndex++;\n          }\n        }\n      }\n    } // Enter.\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      while (otherIndex--) {\n        otherEvent = events[otherIndex];\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            otherEvent[1].type = 'lineEnding';\n            lineIndex = otherIndex;\n          }\n        } else {\n          break;\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  return !more;\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) {\n      // Empty.\n    }\n    startPositions.push(startPosition);\n    if (!token._tokenizer) {\n      stream = context.sliceStream(token);\n      if (!token.next) {\n        stream.push(null);\n      }\n      if (previous) {\n        tokenizer.defineSkip(token.start);\n      }\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n      tokenizer.write(stream);\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined;\n      }\n    } // Unravel the next token.\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  token = previous;\n  index = childEvents.length;\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 (\n    // 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));\n      // Help GC.\n      token._tokenizer = token.next = undefined;\n      token = token.previous;\n      end = index + 1;\n    }\n  }\n\n  // Help GC.\n  tokenizer.events = token._tokenizer = token.next = undefined; // Do head:\n\n  add(childEvents.slice(0, end));\n  index = -1;\n  adjust = 0;\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  return gaps;\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}\nmodule.exports = subtokenize;","'use strict';\n\nvar factorySpace = require('./factory-space.js');\nvar lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n  function start(code) {\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, ok, 'linePrefix');\n  }\n}\nmodule.exports = lineEnding;","'use strict';\n\nvar labelEnd = require('./label-end.js');\nvar labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n};\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  var self = this;\n  return start;\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  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    return nok(code);\n  }\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 && /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs ? /* c8 ignore next */\n    nok(code) : ok(code);\n  }\n}\nmodule.exports = labelStartImage;","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = stringify;\nfunction stringify(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return '';\n  }\n\n  // Node.\n  if (own.call(value, 'position') || own.call(value, 'type')) {\n    return position(value.position);\n  }\n\n  // Position.\n  if (own.call(value, 'start') || own.call(value, 'end')) {\n    return position(value);\n  }\n\n  // Point.\n  if (own.call(value, 'line') || own.call(value, 'column')) {\n    return point(value);\n  }\n\n  // ?\n  return '';\n}\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {};\n  }\n  return index(point.line) + ':' + index(point.column);\n}\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {};\n  }\n  return point(pos.start) + '-' + point(pos.end);\n}\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1;\n}","/* eslint-disable react/prop-types, react/no-multi-comp */\n'use strict';\n\nvar xtend = require('xtend');\nvar React = require('react');\n/* istanbul ignore next - Don’t crash on old React. */\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};\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}\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}\nfunction SimpleRenderer(tag, props) {\n  return createElement(tag, getCoreProps(props), props.children);\n}\nfunction TableCell(props) {\n  var style = props.align ? {\n    textAlign: props.align\n  } : undefined;\n  var coreProps = getCoreProps(props);\n  return createElement(props.isHeader ? 'th' : 'td', style ? xtend({\n    style: style\n  }, coreProps) : coreProps, props.children);\n}\nfunction Heading(props) {\n  return createElement(\"h\".concat(props.level), getCoreProps(props), props.children);\n}\nfunction List(props) {\n  var attrs = getCoreProps(props);\n  if (props.start !== null && props.start !== 1 && props.start !== undefined) {\n    attrs.start = props.start.toString();\n  }\n  return createElement(props.ordered ? 'ol' : 'ul', attrs, props.children);\n}\nfunction ListItem(props) {\n  var checkbox = null;\n  if (props.checked !== null && props.checked !== undefined) {\n    var checked = props.checked;\n    checkbox = createElement('input', {\n      type: 'checkbox',\n      checked: checked,\n      readOnly: true\n    });\n  }\n  return createElement('li', getCoreProps(props), checkbox, props.children);\n}\nfunction CodeBlock(props) {\n  var className = props.language && \"language-\".concat(props.language);\n  var code = createElement('code', className ? {\n    className: className\n  } : null, props.value);\n  return createElement('pre', getCoreProps(props), code);\n}\nfunction InlineCode(props) {\n  return createElement('code', getCoreProps(props), props.children);\n}\nfunction Html(props) {\n  if (props.skipHtml) {\n    return null;\n  }\n  var dangerous = props.allowDangerousHtml || props.escapeHtml === false;\n  var tag = props.isBlock ? 'div' : 'span';\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  var nodeProps = {\n    dangerouslySetInnerHTML: {\n      __html: props.value\n    }\n  };\n  return createElement(tag, nodeProps);\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}\nfunction VirtualHtml(props) {\n  return createElement(props.tag, getCoreProps(props), props.children);\n}\nfunction NullRenderer() {\n  return null;\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\nfunction resolveAll(constructs, events, context) {\n  var called = [];\n  var index = -1;\n  var resolve;\n  while (++index < constructs.length) {\n    resolve = constructs[index].resolveAll;\n    if (resolve && called.indexOf(resolve) < 0) {\n      events = resolve(events, context);\n      called.push(resolve);\n    }\n  }\n  return events;\n}\nmodule.exports = resolveAll;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar factorySpace = require('./factory-space.js');\nfunction titleFactory(effects, ok, nok, type, markerType, stringType) {\n  var marker;\n  return start;\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  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    effects.enter(stringType);\n    return atTitleBreak(code);\n  }\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType);\n      return atFirstTitleBreak(marker);\n    }\n    if (code === null) {\n      return nok(code);\n    } // Note: blank lines can’t exist in content.\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    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return title(code);\n  }\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString');\n      return atTitleBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? titleEscape : title;\n  }\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code);\n      return title;\n    }\n    return title(code);\n  }\n}\nmodule.exports = titleFactory;","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\nvar isArray = function isArray(arr) {\n  if (typeof Array.isArray === 'function') {\n    return Array.isArray(arr);\n  }\n  return toStr.call(arr) === '[object Array]';\n};\nvar isPlainObject = function isPlainObject(obj) {\n  if (!obj || toStr.call(obj) !== '[object Object]') {\n    return false;\n  }\n  var hasOwnConstructor = hasOwn.call(obj, 'constructor');\n  var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n  // Not own constructor property must be Object\n  if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n    return false;\n  }\n\n  // Own properties are enumerated firstly, so to speed up,\n  // if last one is own, then all properties are own.\n  var key;\n  for (key in obj) {/**/}\n  return typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n  if (defineProperty && options.name === '__proto__') {\n    defineProperty(target, options.name, {\n      enumerable: true,\n      configurable: true,\n      value: options.newValue,\n      writable: true\n    });\n  } else {\n    target[options.name] = options.newValue;\n  }\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n  if (name === '__proto__') {\n    if (!hasOwn.call(obj, name)) {\n      return void 0;\n    } else if (gOPD) {\n      // In early versions of node, obj['__proto__'] is buggy when obj has\n      // __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n      return gOPD(obj, name).value;\n    }\n  }\n  return obj[name];\n};\nmodule.exports = function extend() {\n  var options, name, src, copy, copyIsArray, clone;\n  var target = arguments[0];\n  var i = 1;\n  var length = arguments.length;\n  var deep = false;\n\n  // Handle a deep copy situation\n  if (typeof target === 'boolean') {\n    deep = target;\n    target = arguments[1] || {};\n    // skip the boolean and the target\n    i = 2;\n  }\n  if (target == null || typeof target !== 'object' && typeof target !== 'function') {\n    target = {};\n  }\n  for (; i < length; ++i) {\n    options = arguments[i];\n    // Only deal with non-null/undefined values\n    if (options != null) {\n      // Extend the base object\n      for (name in options) {\n        src = getProperty(target, name);\n        copy = getProperty(options, name);\n\n        // Prevent never-ending loop\n        if (target !== copy) {\n          // Recurse if we're merging plain objects or arrays\n          if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n            if (copyIsArray) {\n              copyIsArray = false;\n              clone = src && isArray(src) ? src : [];\n            } else {\n              clone = src && isPlainObject(src) ? src : {};\n            }\n\n            // Never move original objects, clone them\n            setProperty(target, {\n              name: name,\n              newValue: extend(deep, clone, copy)\n            });\n\n            // Don't bring in undefined values\n          } else if (typeof copy !== 'undefined') {\n            setProperty(target, {\n              name: name,\n              newValue: copy\n            });\n          }\n        }\n      }\n    }\n  }\n\n  // Return the modified object\n  return target;\n};","'use strict';\n\nvar search = /[\\0\\t\\n\\r]/g;\nfunction preprocess() {\n  var start = true;\n  var column = 1;\n  var buffer = '';\n  var atCarriageReturn;\n  return preprocessor;\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    if (start) {\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n      start = undefined;\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      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\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        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\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          while (column++ < next) chunks.push(-1);\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      startPosition = endPosition + 1;\n    }\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n    return chunks;\n  }\n}\nmodule.exports = preprocess;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar prefixSize = require('../util/prefix-size.js');\nvar subtokenize = require('../util/subtokenize.js');\nvar factorySpace = require('./factory-space.js');\n\n// No name because it must not be turned off.\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}\nfunction tokenizeContent(effects, ok) {\n  var previous;\n  return start;\n  function start(code) {\n    effects.enter('content');\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    });\n    return data(code);\n  }\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    } // Data.\n\n    effects.consume(code);\n    return data;\n  }\n  function contentEnd(code) {\n    effects.exit('chunkContent');\n    effects.exit('content');\n    return ok(code);\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}\nfunction tokenizeContinuation(effects, ok, nok) {\n  var self = this;\n  return startLookahead;\n  function startLookahead(code) {\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, prefixed, 'linePrefix');\n  }\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\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    return ok(code);\n  }\n}\nmodule.exports = content;","'use strict';\n\nvar visit = require('unist-util-visit');\nmodule.exports = function (node) {\n  visit(node, 'table', wrap);\n  return node;\n};\nfunction wrap(table) {\n  var children = table.children;\n  table.children = [{\n    type: 'tableHead',\n    align: table.align,\n    children: [children[0]],\n    position: children[0].position\n  }];\n  if (children.length > 1) {\n    table.children.push({\n      type: 'tableBody',\n      align: table.align,\n      children: children.slice(1),\n      position: {\n        start: children[1].position.start,\n        end: children[children.length - 1].position.end\n      }\n    });\n  }\n}","'use strict';\n\nmodule.exports = toString;\n\n// 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.\nfunction toString(node) {\n  return node && (node.value || node.alt || node.title || 'children' in node && all(node.children) || 'length' in node && all(node)) || '';\n}\nfunction all(values) {\n  var result = [];\n  var index = -1;\n  while (++index < values.length) {\n    result[index] = toString(values[index]);\n  }\n  return result.join('');\n}","'use strict';\n\nvar markdownSpace = require('../character/markdown-space.js');\nfunction spaceFactory(effects, ok, type, max) {\n  var limit = max ? max - 1 : Infinity;\n  var size = 0;\n  return start;\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n    return ok(code);\n  }\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n    effects.exit(type);\n    return ok(code);\n  }\n}\nmodule.exports = spaceFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar chunkedSplice = require('../util/chunked-splice.js');\nvar prefixSize = require('../util/prefix-size.js');\nvar factorySpace = require('./factory-space.js');\nvar codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented,\n  resolve: resolveCodeIndented\n};\nvar indentedContentConstruct = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\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}\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  return effects.attempt(indentedContentConstruct, afterPrefix, nok);\n  function afterPrefix(code) {\n    if (code === null) {\n      return ok(code);\n    }\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContentConstruct, afterPrefix, ok)(code);\n    }\n    effects.enter('codeFlowValue');\n    return content(code);\n  }\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue');\n      return afterPrefix(code);\n    }\n    effects.consume(code);\n    return content;\n  }\n}\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1);\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    return prefixSize(self.events, 'linePrefix') < 4 ? nok(code) : ok(code);\n  }\n}\nmodule.exports = codeIndented;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar markdownSpace = require('../character/markdown-space.js');\n\n// eslint-disable-next-line max-params\nfunction labelFactory(effects, ok, nok, type, markerType, stringType) {\n  var self = this;\n  var size = 0;\n  var data;\n  return start;\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  function atBreak(code) {\n    if (code === null || code === 91 || code === 93 && !data || (/* c8 ignore next */\n    code === 94 && /* c8 ignore next */\n    !size && /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs) || size > 999) {\n      return nok(code);\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    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return atBreak;\n    }\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return label(code);\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    effects.consume(code);\n    data = data || !markdownSpace(code);\n    return code === 92 ? labelEscape : label;\n  }\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return label;\n    }\n    return label(code);\n  }\n}\nmodule.exports = labelFactory;","'use strict';\n\nvar chunkedPush = require('../util/chunked-push.js');\nvar chunkedSplice = require('../util/chunked-splice.js');\nvar classifyCharacter = require('../util/classify-character.js');\nvar movePoint = require('../util/move-point.js');\nvar resolveAll = require('../util/resolve-all.js');\nvar shallow = require('../util/shallow.js');\nvar attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\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 &&\n        // 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          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          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          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  index = -1;\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n  return events;\n}\nfunction tokenizeAttention(effects, ok) {\n  var before = classifyCharacter(this.previous);\n  var marker;\n  return start;\n  function start(code) {\n    effects.enter('attentionSequence');\n    marker = code;\n    return sequence(code);\n  }\n  function sequence(code) {\n    var token;\n    var after;\n    var open;\n    var close;\n    if (code === marker) {\n      effects.consume(code);\n      return sequence;\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}\nmodule.exports = attention;","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\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\nvar asciiControl = require('../character/ascii-control.js');\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\n// eslint-disable-next-line max-params\nfunction destinationFactory(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) {\n  var limit = max || Infinity;\n  var balance = 0;\n  return start;\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    if (asciiControl(code) || code === 41) {\n      return nok(code);\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  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    effects.enter(stringType);\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return destinationEnclosed(code);\n  }\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString');\n      effects.exit(stringType);\n      return destinationEnclosedBefore(code);\n    }\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed;\n  }\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code);\n      return destinationEnclosed;\n    }\n    return destinationEnclosed(code);\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    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      effects.consume(code);\n      return destinationRaw;\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    if (asciiControl(code)) return nok(code);\n    effects.consume(code);\n    return code === 92 ? destinationRawEscape : destinationRaw;\n  }\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code);\n      return destinationRaw;\n    }\n    return destinationRaw(code);\n  }\n}\nmodule.exports = destinationFactory;","'use strict';\n\nvar asciiPunctuation = require('../character/ascii-punctuation.js');\nvar characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\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  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    return nok(code);\n  }\n}\nmodule.exports = characterEscape;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar markdownSpace = require('../character/markdown-space.js');\nvar factorySpace = require('./factory-space.js');\nvar thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  var size = 0;\n  var marker;\n  return start;\n  function start(code) {\n    effects.enter('thematicBreak');\n    marker = code;\n    return atBreak(code);\n  }\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence');\n      return sequence(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code);\n    }\n    if (size < 3 || code !== null && !markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.exit('thematicBreak');\n    return ok(code);\n  }\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n    effects.exit('thematicBreakSequence');\n    return atBreak(code);\n  }\n}\nmodule.exports = thematicBreak;","'use strict';\n\nvar content = require('./initialize/content.js');\nvar document = require('./initialize/document.js');\nvar flow = require('./initialize/flow.js');\nvar text = require('./initialize/text.js');\nvar combineExtensions = require('./util/combine-extensions.js');\nvar createTokenizer = require('./util/create-tokenizer.js');\nvar miniflat = require('./util/miniflat.js');\nvar constructs = require('./constructs.js');\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  function create(initializer) {\n    return creator;\n    function creator(from) {\n      return createTokenizer(parser, initializer, from);\n    }\n  }\n}\nmodule.exports = parse;","'use strict';\n\nvar slice = [].slice;\nmodule.exports = wrap;\n\n// Wrap `fn`.\n// Can be sync or async; return a promise, receive a completion handler, return\n// new values and errors.\nfunction wrap(fn, callback) {\n  var invoked;\n  return wrapped;\n  function wrapped() {\n    var params = slice.call(arguments, 0);\n    var callback = fn.length > params.length;\n    var result;\n    if (callback) {\n      params.push(done);\n    }\n    try {\n      result = fn.apply(null, params);\n    } catch (error) {\n      // Well, this is quite the pickle.\n      // `fn` received a callback and invoked it (thus continuing the pipeline),\n      // but later also threw an error.\n      // We’re not about to restart the pipeline again, so the only thing left\n      // to do is to throw the thing instead.\n      if (callback && invoked) {\n        throw error;\n      }\n      return done(error);\n    }\n    if (!callback) {\n      if (result && typeof result.then === 'function') {\n        result.then(then, done);\n      } else if (result instanceof Error) {\n        done(result);\n      } else {\n        then(result);\n      }\n    }\n  }\n\n  // Invoke `next`, only once.\n  function done() {\n    if (!invoked) {\n      invoked = true;\n      callback.apply(null, arguments);\n    }\n  }\n\n  // Invoke `done` with one value.\n  // Tracks if an error is passed, too.\n  function then(value) {\n    done(null, value);\n  }\n}","'use strict';\n\nmodule.exports = require('./lib');","'use strict';\n\nvar markdownSpace = require('../character/markdown-space.js');\nvar factorySpace = require('./factory-space.js');\nvar blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit: exit\n};\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  var self = this;\n  return start;\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      effects.enter('blockQuotePrefix');\n      effects.enter('blockQuoteMarker');\n      effects.consume(code);\n      effects.exit('blockQuoteMarker');\n      return after;\n    }\n    return nok(code);\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    effects.exit('blockQuotePrefix');\n    return ok(code);\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}\nfunction exit(effects) {\n  effects.exit('blockQuote');\n}\nmodule.exports = blockQuote;","module.exports = identity;\nfunction identity(d) {\n  return d;\n}","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nvar assign = require('../constant/assign.js');\nvar shallow = require('../util/shallow.js');\nvar text = initializeFactory('text');\nvar string = initializeFactory('string');\nvar resolver = {\n  resolveAll: createResolver()\n};\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined)\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    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n      effects.enter('data');\n      effects.consume(code);\n      return data;\n    }\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data');\n        return text(code);\n      } // Data.\n\n      effects.consume(code);\n      return data;\n    }\n    function atBreak(code) {\n      var list = constructs[code];\n      var index = -1;\n      if (code === null) {\n        return true;\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}\nfunction createResolver(extraResolver) {\n  return resolveAllText;\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        enter = undefined;\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\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  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      while (index--) {\n        chunk = chunks[index];\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\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      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        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      eventIndex++;\n    }\n  }\n  return events;\n}\nexports.resolver = resolver;\nexports.string = string;\nexports.text = text;","'use strict';\n\nvar splice = require('../constant/splice.js');\n\n// causes a stack overflow in V8 when trying to insert 100k items for instance.\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  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}\nmodule.exports = chunkedSplice;","'use strict';\n\nmodule.exports = bail;\nfunction bail(err) {\n  if (err) {\n    throw err;\n  }\n}","'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  if (startIndex === endIndex) {\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n    if (startBufferIndex > -1) {\n      view[0] = view[0].slice(startBufferIndex);\n    }\n    if (endBufferIndex > 0) {\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n  return view;\n}\nmodule.exports = sliceChunks;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\nvar asciiDigit = regexCheck(/\\d/);\nmodule.exports = asciiDigit;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\nfunction serializeChunks(chunks) {\n  var index = -1;\n  var result = [];\n  var chunk;\n  var value;\n  var atTab;\n  while (++index < chunks.length) {\n    chunk = chunks[index];\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    atTab = chunk === -2;\n    result.push(value);\n  }\n  return result.join('');\n}\nmodule.exports = serializeChunks;","'use strict';\n\nvar visit = require('unist-util-visit');\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');\nvar unified = require('unified');\nvar parse = require('remark-parse');\nvar PropTypes = require('prop-types');\nvar addListMetadata = require('mdast-add-list-metadata');\nvar naiveHtml = require('./plugins/naive-html');\nvar disallowNode = require('./plugins/disallow-node');\nvar astToReact = require('./ast-to-react');\nvar wrapTableRows = require('./wrap-table-rows');\nvar getDefinitions = require('./get-definitions');\nvar uriTransformer = require('./uri-transformer');\nvar defaultRenderers = require('./renderers');\nvar symbols = require('./symbols');\nvar allTypes = Object.keys(defaultRenderers);\nvar ReactMarkdown = function ReactMarkdown(props) {\n  // To do in next major: remove `source`.\n  var src = props.source || props.children || '';\n  if (props.allowedTypes && props.disallowedTypes) {\n    throw new Error('Only one of `allowedTypes` and `disallowedTypes` should be defined');\n  }\n  var renderers = xtend(defaultRenderers, props.renderers);\n  var 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};\nfunction determineAstToReactTransforms(props) {\n  var transforms = [wrapTableRows, addListMetadata()];\n  var disallowedTypes = props.disallowedTypes;\n  if (props.allowedTypes) {\n    disallowedTypes = allTypes.filter(function (type) {\n      return type !== 'root' && props.allowedTypes.indexOf(type) === -1;\n    });\n  }\n  var removalMethod = props.unwrapDisallowed ? 'unwrap' : 'remove';\n  if (disallowedTypes && disallowedTypes.length > 0) {\n    transforms.push(disallowNode.ofType(disallowedTypes, removalMethod));\n  }\n  if (props.allowNode) {\n    transforms.push(disallowNode.ifNotMatch(props.allowNode, removalMethod));\n  } // To do in next major: remove `escapeHtml`.\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  if (renderHtml && !hasHtmlParser) {\n    transforms.push(naiveHtml);\n  }\n  if (props.astPlugins) {\n    transforms = transforms.concat(props.astPlugins);\n  } // Add the final transform to turn everything into React.\n\n  transforms.push(astToReact);\n  return transforms;\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');\nvar hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n  function start(code) {\n    effects.enter('hardBreakEscape');\n    effects.enter('escapeMarker');\n    effects.consume(code);\n    return open;\n  }\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker');\n      effects.exit('hardBreakEscape');\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\nmodule.exports = hardBreakEscape;","'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}\nmodule.exports = normalizeIdentifier;","'use strict';\n\nvar splice = [].splice;\nmodule.exports = splice;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nvar content = require('../tokenize/content.js');\nvar factorySpace = require('../tokenize/factory-space.js');\nvar partialBlankLine = require('../tokenize/partial-blank-line.js');\nvar tokenize = initializeFlow;\nfunction initializeFlow(effects) {\n  var self = this;\n  var initial = effects.attempt(\n  // Try to parse a blank line.\n  partialBlankLine, atBlankEnding,\n  // 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  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter('lineEndingBlank');\n    effects.consume(code);\n    effects.exit('lineEndingBlank');\n    self.currentConstruct = undefined;\n    return initial;\n  }\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    self.currentConstruct = undefined;\n    return initial;\n  }\n}\nexports.tokenize = tokenize;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\nvar asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\nmodule.exports = asciiHexDigit;","'use strict';\n\nvar assign = require('../constant/assign.js');\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar chunkedPush = require('./chunked-push.js');\nvar chunkedSplice = require('./chunked-splice.js');\nvar miniflat = require('./miniflat.js');\nvar resolveAll = require('./resolve-all.js');\nvar serializeChunks = require('./serialize-chunks.js');\nvar shallow = require('./shallow.js');\nvar sliceChunks = require('./slice-chunks.js');\n\n// 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`.\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  point._index = 0;\n  point._bufferIndex = -1;\n  return context;\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    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  function sliceSerialize(token) {\n    return serializeChunks(sliceStream(token));\n  }\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n  function now() {\n    return shallow(point);\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  function main() {\n    var chunkIndex;\n    var chunk;\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        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\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  function go(code) {\n    state = state(code);\n  } // Move a character forward.\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    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    context.previous = code; // Mark as consumed.\n  } // Start a token.\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  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  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  } // Discard results.\n\n  function onsuccessfulcheck(construct, info) {\n    info.restore();\n  } // Factory to attempt/check/interrupt.\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      function handleMapOfConstructs(code) {\n        if (code in constructs || null in constructs) {\n          return handleListOfConstructs(constructs.null ? /* c8 ignore next */\n          miniflat(constructs[code]).concat(miniflat(constructs.null)) : constructs[code])(code);\n        }\n        return bogusState(code);\n      }\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        return handleConstruct(list[constructIndex]);\n      }\n      function handleConstruct(construct) {\n        return start;\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          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n          if (construct.name && context.parser.constructs.disable.null.indexOf(construct.name) > -1) {\n            return nok();\n          }\n          return construct.tokenize.call(fields ? assign({}, context, fields) : context, effects, ok, nok)(code);\n        }\n      }\n      function ok(code) {\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n      function nok(code) {\n        info.restore();\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n        return bogusState;\n      }\n    }\n  }\n  function addResult(construct, from) {\n    if (construct.resolveAll && resolveAllConstructs.indexOf(construct) < 0) {\n      resolveAllConstructs.push(construct);\n    }\n    if (construct.resolve) {\n      chunkedSplice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\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    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  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}\nmodule.exports = createTokenizer;","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = stringify;\nfunction stringify(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return '';\n  }\n\n  // Node.\n  if (own.call(value, 'position') || own.call(value, 'type')) {\n    return position(value.position);\n  }\n\n  // Position.\n  if (own.call(value, 'start') || own.call(value, 'end')) {\n    return position(value);\n  }\n\n  // Point.\n  if (own.call(value, 'line') || own.call(value, 'column')) {\n    return point(value);\n  }\n\n  // ?\n  return '';\n}\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {};\n  }\n  return index(point.line) + ':' + index(point.column);\n}\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {};\n  }\n  return point(pos.start) + '-' + point(pos.end);\n}\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1;\n}","'use strict';\n\nvar subtokenize = require('./util/subtokenize.js');\nfunction postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events;\n}\nmodule.exports = postprocess;","'use strict';\n\nvar assign = Object.assign;\nmodule.exports = assign;","'use strict';\n\nmodule.exports = value => {\n  if (Object.prototype.toString.call(value) !== '[object Object]') {\n    return false;\n  }\n  const prototype = Object.getPrototypeOf(value);\n  return prototype === null || prototype === Object.prototype;\n};","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous: previous\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  index = headEnterIndex - 1;\n  tailExitIndex++;\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      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      enter = undefined;\n    }\n  }\n  return events;\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}\nfunction tokenizeCodeText(effects, ok, nok) {\n  var sizeOpen = 0;\n  var size;\n  var token;\n  return start;\n  function start(code) {\n    effects.enter('codeText');\n    effects.enter('codeTextSequence');\n    return openingSequence(code);\n  }\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return openingSequence;\n    }\n    effects.exit('codeTextSequence');\n    return gap(code);\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    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    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return gap;\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return gap;\n    } // Data.\n\n    effects.enter('codeTextData');\n    return data(code);\n  } // In code.\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    effects.consume(code);\n    return data;\n  } // Closing fence.\n\n  function closingSequence(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return closingSequence;\n    } // Done!\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    token.type = 'codeTextData';\n    return data(code);\n  }\n}\nmodule.exports = codeText;","\"use strict\";\n\nvar protocols = ['http', 'https', 'mailto', 'tel'];\nmodule.exports = function uriTransformer(uri) {\n  var url = (uri || '').trim();\n  var first = url.charAt(0);\n  if (first === '#' || first === '/') {\n    return url;\n  }\n  var colon = url.indexOf(':');\n  if (colon === -1) {\n    return url;\n  }\n  var length = protocols.length;\n  var index = -1;\n  while (++index < length) {\n    var protocol = protocols[index];\n    if (colon === protocol.length && url.slice(0, protocol.length).toLowerCase() === protocol) {\n      return url;\n    }\n  }\n  index = url.indexOf('?');\n  if (index !== -1 && colon > index) {\n    return url;\n  }\n  index = url.indexOf('#');\n  if (index !== -1 && colon > index) {\n    return url;\n  } // eslint-disable-next-line no-script-url\n\n  return 'javascript:void(0)';\n};","'use strict';\n\nvar labelEnd = require('./label-end.js');\nvar labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n};\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  var self = this;\n  return start;\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  function after(code) {\n    /* c8 ignore next */\n    return code === 94 && /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs ? /* c8 ignore next */\n    nok(code) : ok(code);\n  }\n}\nmodule.exports = labelStartLink;","'use strict';\n\nvar hasOwnProperty = require('../constant/has-own-property.js');\nvar chunkedSplice = require('./chunked-splice.js');\nvar miniflat = require('./miniflat.js');\nfunction combineExtensions(extensions) {\n  var all = {};\n  var index = -1;\n  while (++index < extensions.length) {\n    extension(all, extensions[index]);\n  }\n  return all;\n}\nfunction extension(all, extension) {\n  var hook;\n  var left;\n  var right;\n  var code;\n  for (hook in extension) {\n    left = hasOwnProperty.call(all, hook) ? all[hook] : all[hook] = {};\n    right = extension[hook];\n    for (code in right) {\n      left[code] = constructs(miniflat(right[code]), hasOwnProperty.call(left, code) ? left[code] : []);\n    }\n  }\n}\nfunction constructs(list, existing) {\n  var index = -1;\n  var before = [];\n  while (++index < list.length) {\n    ;\n    (list[index].add === 'after' ? existing : before).push(list[index]);\n  }\n  chunkedSplice(existing, 0, 0, before);\n  return existing;\n}\nmodule.exports = combineExtensions;","'use strict';\n\nmodule.exports = convert;\nfunction convert(test) {\n  if (test == null) {\n    return ok;\n  }\n  if (typeof test === 'string') {\n    return typeFactory(test);\n  }\n  if (typeof test === 'object') {\n    return 'length' in test ? anyFactory(test) : allFactory(test);\n  }\n  if (typeof test === 'function') {\n    return test;\n  }\n  throw new Error('Expected function, string, or object as test');\n}\n\n// Utility assert each property in `test` is represented in `node`, and each\n// values are strictly equal.\nfunction allFactory(test) {\n  return all;\n  function all(node) {\n    var key;\n    for (key in test) {\n      if (node[key] !== test[key]) return false;\n    }\n    return true;\n  }\n}\nfunction anyFactory(tests) {\n  var checks = [];\n  var index = -1;\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index]);\n  }\n  return any;\n  function any() {\n    var index = -1;\n    while (++index < checks.length) {\n      if (checks[index].apply(this, arguments)) {\n        return true;\n      }\n    }\n    return false;\n  }\n}\n\n// Utility to convert a string into a function which checks a given node’s type\n// for said string.\nfunction typeFactory(test) {\n  return type;\n  function type(node) {\n    return Boolean(node && node.type === test);\n  }\n}\n\n// Utility to return true.\nfunction ok() {\n  return true;\n}","'use strict';\n\nvar VMessage = require('vfile-message');\nvar VFile = require('./core.js');\nmodule.exports = VFile;\nVFile.prototype.message = message;\nVFile.prototype.info = info;\nVFile.prototype.fail = fail;\n\n// Create a message with `reason` at `position`.\n// When an error is passed in as `reason`, copies the stack.\nfunction message(reason, position, origin) {\n  var message = new VMessage(reason, position, origin);\n  if (this.path) {\n    message.name = this.path + ':' + message.name;\n    message.file = this.path;\n  }\n  message.fatal = false;\n  this.messages.push(message);\n  return message;\n}\n\n// Fail: creates a vmessage, associates it with the file, and throws it.\nfunction fail() {\n  var message = this.message.apply(this, arguments);\n  message.fatal = true;\n  throw message;\n}\n\n// Info: creates a vmessage, associates it with the file, and marks the fatality\n// as null.\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');\nvar factorySpace = require('./factory-space.js');\nvar partialBlankLine = {\n  tokenize: tokenizePartialBlankLine,\n  partial: true\n};\nfunction tokenizePartialBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix');\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}\nmodule.exports = partialBlankLine;","'use strict';\n\nfunction markdownLineEnding(code) {\n  return code < -2;\n}\nmodule.exports = markdownLineEnding;","'use strict';\n\nvar fromCharCode = String.fromCharCode;\nmodule.exports = fromCharCode;","'use strict';\n\nvar unicodePunctuationRegex = require('../constant/unicode-punctuation-regex.js');\nvar regexCheck = require('../util/regex-check.js');\n\n// In fact adds to the bundle size.\n\nvar unicodePunctuation = regexCheck(unicodePunctuationRegex);\nmodule.exports = unicodePunctuation;","'use strict';\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\nvar unicodePunctuation = require('../character/unicode-punctuation.js');\nvar unicodeWhitespace = require('../character/unicode-whitespace.js');\n\n// 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.\nfunction classifyCharacter(code) {\n  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}\nmodule.exports = classifyCharacter;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\nvar asciiAtext = require('../character/ascii-atext.js');\nvar asciiControl = require('../character/ascii-control.js');\nvar autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\nfunction tokenizeAutolink(effects, ok, nok) {\n  var size = 1;\n  return start;\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  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n    return asciiAtext(code) ? emailAtext(code) : nok(code);\n  }\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code) ? schemeInsideOrEmailAtext(code) : emailAtext(code);\n  }\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      return urlInside;\n    }\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n    return emailAtext(code);\n  }\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol');\n      return end(code);\n    }\n    if (code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return urlInside;\n  }\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n    return nok(code);\n  }\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail';\n      return end(code);\n    }\n    return emailValue(code);\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    return nok(code);\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}\nmodule.exports = autolink;","'use strict';\n\n// 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.\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 markdownLineEnding = require('../character/markdown-line-ending.js');\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\nvar markdownSpace = require('../character/markdown-space.js');\nvar chunkedSplice = require('../util/chunked-splice.js');\nvar factorySpace = require('./factory-space.js');\nvar headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\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  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === 'whitespace') {\n    contentEnd -= 2;\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  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  return events;\n}\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  var self = this;\n  var size = 0;\n  return start;\n  function start(code) {\n    effects.enter('atxHeading');\n    effects.enter('atxHeadingSequence');\n    return fenceOpenInside(code);\n  }\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return fenceOpenInside;\n    }\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence');\n      return self.interrupt ? ok(code) : headingBreak(code);\n    }\n    return nok(code);\n  }\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence');\n      return sequence(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading');\n      return ok(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code);\n    }\n    effects.enter('atxHeadingText');\n    return data(code);\n  }\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequence;\n    }\n    effects.exit('atxHeadingSequence');\n    return headingBreak(code);\n  }\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText');\n      return headingBreak(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n}\nmodule.exports = headingAtx;","'use strict';\n\n// Counts tabs based on their expanded size, and CR+LF as one character.\nfunction sizeChunks(chunks) {\n  var index = -1;\n  var size = 0;\n  while (++index < chunks.length) {\n    size += typeof chunks[index] === 'string' ? chunks[index].length : 1;\n  }\n  return size;\n}\nmodule.exports = sizeChunks;","module.exports = extend;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction extend() {\n  var target = {};\n  for (var i = 0; i < arguments.length; i++) {\n    var source = arguments[i];\n    for (var key in source) {\n      if (hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n  return target;\n}","'use strict';\n\nvar React = require('react');\nvar xtend = require('xtend');\nvar ReactIs = require('react-is');\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  var pos = node.position.start;\n  var key = [node.type, pos.line, pos.column, index].join('-');\n  if (!ReactIs.isValidElementType(renderer)) {\n    throw new Error(\"Renderer for type `\".concat(node.type, \"` not defined or is not renderable\"));\n  }\n  var nodeProps = getNodeProps(node, key, options, renderer, parent, index);\n  return React.createElement(renderer, nodeProps, nodeProps.children || resolveChildren() || undefined);\n  function resolveChildren() {\n    return node.children && node.children.map(function (childNode, i) {\n      return astToReact(childNode, options, {\n        node: node,\n        props: nodeProps\n      }, i);\n    });\n  }\n} // eslint-disable-next-line max-params, complexity\n\nfunction getNodeProps(node, key, opts, renderer, parent, index) {\n  var props = {\n    key: key\n  };\n  var 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  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  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  var ref = node.identifier !== null && node.identifier !== undefined ? /* istanbul ignore next - plugins could inject an undefined reference. */\n  opts.definitions[node.identifier.toUpperCase()] || {} : null;\n  switch (node.type) {\n    case 'root':\n      assignDefined(props, {\n        className: opts.className\n      });\n      break;\n    case 'text':\n      props.nodeKey = key;\n      props.children = node.value;\n      break;\n    case 'heading':\n      props.level = node.depth;\n      break;\n    case 'list':\n      props.start = node.start;\n      props.ordered = node.ordered;\n      props.spread = node.spread;\n      props.depth = node.depth;\n      break;\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    case 'definition':\n      assignDefined(props, {\n        identifier: node.identifier,\n        title: node.title,\n        url: node.url\n      });\n      break;\n    case 'code':\n      assignDefined(props, {\n        language: node.lang && node.lang.split(/\\s/, 1)[0]\n      });\n      break;\n    case 'inlineCode':\n      props.children = node.value;\n      props.inline = true;\n      break;\n    case 'link':\n      assignDefined(props, {\n        title: node.title || undefined,\n        target: typeof opts.linkTarget === 'function' ? opts.linkTarget(node.url, node.children, node.title) : opts.linkTarget,\n        href: opts.transformLinkUri ? opts.transformLinkUri(node.url, node.children, node.title) : node.url\n      });\n      break;\n    case 'image':\n      assignDefined(props, {\n        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    case 'linkReference':\n      assignDefined(props, xtend(ref, {\n        href: opts.transformLinkUri ? opts.transformLinkUri(ref.href) : ref.href\n      }));\n      break;\n    case 'imageReference':\n      assignDefined(props, {\n        src: opts.transformImageUri && ref.href ? opts.transformImageUri(ref.href, node.children, ref.title, node.alt) : ref.href,\n        alt: node.alt || '',\n        title: ref.title || undefined\n      });\n      break;\n    case 'table':\n    case 'tableHead':\n    case 'tableBody':\n      props.columnAlignment = node.align;\n      break;\n    case 'tableRow':\n      props.isHeader = parent.node.type === 'tableHead';\n      props.columnAlignment = parent.props.columnAlignment;\n      break;\n    case 'tableCell':\n      assignDefined(props, {\n        isHeader: parent.props.isHeader,\n        align: parent.props.columnAlignment[index]\n      });\n      break;\n    case 'virtualHtml':\n      props.tag = node.tag;\n      break;\n    case 'html':\n      // @todo find a better way than this\n      props.isBlock = node.position.start.line !== node.position.end.line;\n      props.allowDangerousHtml = opts.allowDangerousHtml;\n      props.escapeHtml = opts.escapeHtml;\n      props.skipHtml = opts.skipHtml;\n      break;\n    case 'parsedHtml':\n      {\n        var parsedChildren;\n        if (node.children) {\n          parsedChildren = node.children.map(function (child, i) {\n            return astToReact(child, opts, {\n              node: node,\n              props: props\n            }, i);\n          });\n        }\n        props.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    default:\n      assignDefined(props, xtend(node, {\n        type: undefined,\n        position: undefined,\n        children: undefined\n      }));\n  }\n  if (!isSimpleRenderer && node.value) {\n    props.value = node.value;\n  }\n  if (!isSimpleRenderer) {\n    props.node = node;\n  }\n  return props;\n}\nfunction assignDefined(target, attrs) {\n  for (var key in attrs) {\n    if (typeof attrs[key] !== 'undefined') {\n      target[key] = attrs[key];\n    }\n  }\n}\nfunction mergeNodeChildren(node, parsedChildren) {\n  var el = node.element;\n  if (Array.isArray(el)) {\n    /* istanbul ignore next - `div` fallback for old React. */\n    var Fragment = React.Fragment || 'div';\n    return React.createElement(Fragment, null, el);\n  }\n  if (el.props.children || parsedChildren) {\n    var children = React.Children.toArray(el.props.children).concat(parsedChildren);\n    return React.cloneElement(el, null, children);\n  }\n  return React.cloneElement(el, null);\n}\nfunction flattenPosition(pos) {\n  return [pos.start.line, ':', pos.start.column, '-', pos.end.line, ':', pos.end.column].map(String).join('');\n}\nfunction getListItemChildren(node, parent) {\n  /* 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}\nfunction unwrapParagraphs(node) {\n  return node.children.reduce(function (array, child) {\n    return array.concat(child.type === 'paragraph' ? child.children : [child]);\n  }, []);\n}\nfunction listLoose(node) {\n  var children = node.children;\n  var loose = node.spread;\n  var index = -1;\n  while (!loose && ++index < children.length) {\n    loose = listItemLoose(children[index]);\n  }\n  return loose;\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}\nmodule.exports = astToReact;","'use strict';\n\n/* Expose. */\nmodule.exports = visitParents;\n\n/* Visit. */\nfunction visitParents(tree, type, visitor) {\n  var stack = [];\n  if (typeof type === 'function') {\n    visitor = type;\n    type = null;\n  }\n  one(tree);\n\n  /* Visit a single node. */\n  function one(node) {\n    var result;\n    if (!type || node.type === type) {\n      result = visitor(node, stack.concat());\n    }\n    if (node.children && result !== false) {\n      return all(node.children, node);\n    }\n    return result;\n  }\n\n  /* Visit children in `parent`. */\n  function all(children, parent) {\n    var length = children.length;\n    var index = -1;\n    var child;\n    stack.push(parent);\n    while (++index < length) {\n      child = children[index];\n      if (child && one(child) === false) {\n        return false;\n      }\n    }\n    stack.pop();\n    return true;\n  }\n}","'use strict';\n\n// This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\nvar raws = ['pre', 'script', 'style', 'textarea'];\nmodule.exports = raws;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\nvar markdownSpace = require('../character/markdown-space.js');\nvar fromCharCode = require('../constant/from-char-code.js');\nvar htmlBlockNames = require('../constant/html-block-names.js');\nvar htmlRawNames = require('../constant/html-raw-names.js');\nvar partialBlankLine = require('./partial-blank-line.js');\nvar htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n};\nvar nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n};\nfunction resolveToHtmlFlow(events) {\n  var index = events.length;\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break;\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  return events;\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  function start(code) {\n    effects.enter('htmlFlow');\n    effects.enter('htmlFlowData');\n    effects.consume(code);\n    return open;\n  }\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationStart;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\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    if (asciiAlpha(code)) {\n      effects.consume(code);\n      buffer = fromCharCode(code);\n      startTag = true;\n      return tagName;\n    }\n    return nok(code);\n  }\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code);\n      kind = 2;\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      kind = 5;\n      buffer = 'CDATA[';\n      index = 0;\n      return cdataOpenInside;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      kind = 4;\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\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    return nok(code);\n  }\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      buffer = fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\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      if (htmlBlockNames.indexOf(buffer.toLowerCase()) > -1) {\n        kind = 6;\n        if (code === 47) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n        return self.interrupt ? ok(code) : continuation(code);\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    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return self.interrupt ? ok : continuation;\n    }\n    return nok(code);\n  }\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n    return completeEnd(code);\n  }\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n    return completeEnd(code);\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    return completeAttributeNameAfter(code);\n  }\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n    return completeAttributeNameBefore(code);\n  }\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return completeAttributeValueQuoted;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    marker = undefined;\n    return completeAttributeValueUnquoted(code);\n  }\n  function completeAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return completeAttributeValueQuotedAfter;\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueQuoted;\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    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n    return nok(code);\n  }\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return code === null || markdownLineEnding(code) ? continuation(code) : nok(code);\n  }\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n    if (code === 60 && kind === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n    if (code === 62 && kind === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n    if (code === 63 && kind === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    if (code === 93 && kind === 5) {\n      effects.consume(code);\n      return continuationCharacterDataInside;\n    }\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(nextBlankConstruct, continuationClose, continuationAtLineEnding)(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code);\n    }\n    effects.consume(code);\n    return continuation;\n  }\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData');\n    return htmlContinueStart(code);\n  }\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return htmlContinueStart;\n    }\n    effects.enter('htmlFlowData');\n    return continuation(code);\n  }\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {\n      effects.consume(code);\n      return continuationClose;\n    }\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code);\n      buffer += fromCharCode(code);\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    }\n    return continuation(code);\n  }\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData');\n      return done(code);\n    }\n    effects.consume(code);\n    return continuationClose;\n  }\n  function done(code) {\n    effects.exit('htmlFlow');\n    return ok(code);\n  }\n}\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start;\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}\nmodule.exports = htmlFlow;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\nvar asciiAlpha = regexCheck(/[A-Za-z]/);\nmodule.exports = asciiAlpha;","'use strict';\n\nvar bail = require('bail');\nvar buffer = require('is-buffer');\nvar extend = require('extend');\nvar plain = require('is-plain-obj');\nvar trough = require('trough');\nvar vfile = require('vfile');\n\n// Expose a frozen processor.\nmodule.exports = unified().freeze();\nvar slice = [].slice;\nvar own = {}.hasOwnProperty;\n\n// Process pipeline.\nvar pipeline = trough().use(pipelineParse).use(pipelineRun).use(pipelineStringify);\nfunction pipelineParse(p, ctx) {\n  ctx.tree = p.parse(ctx.file);\n}\nfunction pipelineRun(p, ctx, next) {\n  p.run(ctx.tree, ctx.file, done);\n  function done(error, tree, file) {\n    if (error) {\n      next(error);\n    } else {\n      ctx.tree = tree;\n      ctx.file = file;\n      next();\n    }\n  }\n}\nfunction pipelineStringify(p, ctx) {\n  var result = p.stringify(ctx.tree, ctx.file);\n  if (result === undefined || result === null) {\n    // Empty.\n  } else if (typeof result === 'string' || buffer(result)) {\n    if ('value' in ctx.file) {\n      ctx.file.value = result;\n    }\n    ctx.file.contents = result;\n  } else {\n    ctx.file.result = result;\n  }\n}\n\n// Function to create the first processor.\nfunction unified() {\n  var attachers = [];\n  var transformers = trough();\n  var namespace = {};\n  var freezeIndex = -1;\n  var frozen;\n\n  // Data management.\n  processor.data = data;\n\n  // Lock.\n  processor.freeze = freeze;\n\n  // Plugins.\n  processor.attachers = attachers;\n  processor.use = use;\n\n  // API.\n  processor.parse = parse;\n  processor.stringify = stringify;\n  processor.run = run;\n  processor.runSync = runSync;\n  processor.process = process;\n  processor.processSync = processSync;\n\n  // Expose.\n  return processor;\n\n  // Create a new processor based on the processor in the current scope.\n  function processor() {\n    var destination = unified();\n    var index = -1;\n    while (++index < attachers.length) {\n      destination.use.apply(null, attachers[index]);\n    }\n    destination.data(extend(true, {}, namespace));\n    return destination;\n  }\n\n  // Freeze: used to signal a processor that has finished 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  function freeze() {\n    var values;\n    var transformer;\n    if (frozen) {\n      return processor;\n    }\n    while (++freezeIndex < attachers.length) {\n      values = attachers[freezeIndex];\n      if (values[1] === false) {\n        continue;\n      }\n      if (values[1] === true) {\n        values[1] = undefined;\n      }\n      transformer = values[0].apply(processor, values.slice(1));\n      if (typeof transformer === 'function') {\n        transformers.use(transformer);\n      }\n    }\n    frozen = true;\n    freezeIndex = Infinity;\n    return processor;\n  }\n\n  // Data management.\n  // Getter / setter for processor-specific informtion.\n  function data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen);\n        namespace[key] = value;\n        return processor;\n      }\n\n      // Get `key`.\n      return own.call(namespace, key) && namespace[key] || null;\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', frozen);\n      namespace = key;\n      return processor;\n    }\n\n    // Get space.\n    return namespace;\n  }\n\n  // 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  function use(value) {\n    var settings;\n    assertUnfrozen('use', frozen);\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin.apply(null, arguments);\n    } else if (typeof value === 'object') {\n      if ('length' in value) {\n        addList(value);\n      } else {\n        addPreset(value);\n      }\n    } else {\n      throw new Error('Expected usable value, not `' + value + '`');\n    }\n    if (settings) {\n      namespace.settings = extend(namespace.settings || {}, settings);\n    }\n    return processor;\n    function addPreset(result) {\n      addList(result.plugins);\n      if (result.settings) {\n        settings = extend(settings || {}, result.settings);\n      }\n    }\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value);\n      } else if (typeof value === 'object') {\n        if ('length' in value) {\n          addPlugin.apply(null, value);\n        } else {\n          addPreset(value);\n        }\n      } else {\n        throw new Error('Expected usable value, not `' + value + '`');\n      }\n    }\n    function addList(plugins) {\n      var index = -1;\n      if (plugins === null || plugins === undefined) {\n        // 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    function addPlugin(plugin, value) {\n      var entry = find(plugin);\n      if (entry) {\n        if (plain(entry[1]) && plain(value)) {\n          value = extend(true, entry[1], value);\n        }\n        entry[1] = value;\n      } else {\n        attachers.push(slice.call(arguments));\n      }\n    }\n  }\n  function find(plugin) {\n    var index = -1;\n    while (++index < attachers.length) {\n      if (attachers[index][0] === plugin) {\n        return attachers[index];\n      }\n    }\n  }\n\n  // Parse a file (in string or vfile representation) into a unist node using\n  // the `Parser` on the processor.\n  function parse(doc) {\n    var file = vfile(doc);\n    var Parser;\n    freeze();\n    Parser = processor.Parser;\n    assertParser('parse', Parser);\n    if (newable(Parser, 'parse')) {\n      return new Parser(String(file), file).parse();\n    }\n    return Parser(String(file), file); // eslint-disable-line new-cap\n  }\n\n  // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), async.\n  function run(node, file, cb) {\n    assertNode(node);\n    freeze();\n    if (!cb && typeof file === 'function') {\n      cb = file;\n      file = null;\n    }\n    if (!cb) {\n      return new Promise(executor);\n    }\n    executor(null, cb);\n    function executor(resolve, reject) {\n      transformers.run(node, vfile(file), done);\n      function done(error, tree, file) {\n        tree = tree || node;\n        if (error) {\n          reject(error);\n        } else if (resolve) {\n          resolve(tree);\n        } else {\n          cb(null, tree, file);\n        }\n      }\n    }\n  }\n\n  // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), sync.\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    function done(error, tree) {\n      complete = true;\n      result = tree;\n      bail(error);\n    }\n  }\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  function stringify(node, doc) {\n    var file = vfile(doc);\n    var Compiler;\n    freeze();\n    Compiler = processor.Compiler;\n    assertCompiler('stringify', Compiler);\n    assertNode(node);\n    if (newable(Compiler, 'compile')) {\n      return new Compiler(node, file).compile();\n    }\n    return Compiler(node, file); // eslint-disable-line new-cap\n  }\n\n  // Parse a file (in string or vfile representation) 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  function process(doc, cb) {\n    freeze();\n    assertParser('process', processor.Parser);\n    assertCompiler('process', processor.Compiler);\n    if (!cb) {\n      return new Promise(executor);\n    }\n    executor(null, cb);\n    function executor(resolve, reject) {\n      var file = vfile(doc);\n      pipeline.run(processor, {\n        file: file\n      }, done);\n      function done(error) {\n        if (error) {\n          reject(error);\n        } else if (resolve) {\n          resolve(file);\n        } else {\n          cb(null, file);\n        }\n      }\n    }\n  }\n\n  // Process the given document (in string or vfile representation), sync.\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    function done(error) {\n      complete = true;\n      bail(error);\n    }\n  }\n}\n\n// Check if `value` is a constructor.\nfunction newable(value, name) {\n  return typeof value === 'function' && value.prototype && (\n  // 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}\n\n// Check if `value` is an object with keys.\nfunction keys(value) {\n  var key;\n  for (key in value) {\n    return true;\n  }\n  return false;\n}\n\n// Assert a parser is available.\nfunction assertParser(name, Parser) {\n  if (typeof Parser !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Parser`');\n  }\n}\n\n// Assert a compiler is available.\nfunction assertCompiler(name, Compiler) {\n  if (typeof Compiler !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Compiler`');\n  }\n}\n\n// Assert the processor is not frozen.\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error('Cannot invoke `' + name + '` on a frozen processor.\\nCreate a new processor first, by invoking it: use `processor()` instead of `processor`.');\n  }\n}\n\n// Assert `node` is a unist node.\nfunction assertNode(node) {\n  if (!node || typeof node.type !== 'string') {\n    throw new Error('Expected node, got `' + node + '`');\n  }\n}\n\n// Assert that `complete` is `true`.\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error('`' + name + '` finished async. Use `' + asyncName + '` instead');\n  }\n}","'use strict';\n\nmodule.exports = visit;\nvar visitParents = require('unist-util-visit-parents');\nvar CONTINUE = visitParents.CONTINUE;\nvar SKIP = visitParents.SKIP;\nvar EXIT = visitParents.EXIT;\nvisit.CONTINUE = CONTINUE;\nvisit.SKIP = SKIP;\nvisit.EXIT = EXIT;\nfunction visit(tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n  visitParents(tree, test, overload, reverse);\n  function overload(node, parents) {\n    var parent = parents[parents.length - 1];\n    var index = parent ? parent.children.indexOf(node) : null;\n    return visitor(node, index, parent);\n  }\n}","'use strict';\n\nvar assign = require('../constant/assign.js');\nfunction shallow(object) {\n  return assign({}, object);\n}\nmodule.exports = shallow;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nvar text$1 = require('./initialize/text.js');\nvar attention = require('./tokenize/attention.js');\nvar autolink = require('./tokenize/autolink.js');\nvar blockQuote = require('./tokenize/block-quote.js');\nvar characterEscape = require('./tokenize/character-escape.js');\nvar characterReference = require('./tokenize/character-reference.js');\nvar codeFenced = require('./tokenize/code-fenced.js');\nvar codeIndented = require('./tokenize/code-indented.js');\nvar codeText = require('./tokenize/code-text.js');\nvar definition = require('./tokenize/definition.js');\nvar hardBreakEscape = require('./tokenize/hard-break-escape.js');\nvar headingAtx = require('./tokenize/heading-atx.js');\nvar htmlFlow = require('./tokenize/html-flow.js');\nvar htmlText = require('./tokenize/html-text.js');\nvar labelEnd = require('./tokenize/label-end.js');\nvar labelStartImage = require('./tokenize/label-start-image.js');\nvar labelStartLink = require('./tokenize/label-start-link.js');\nvar lineEnding = require('./tokenize/line-ending.js');\nvar list = require('./tokenize/list.js');\nvar setextUnderline = require('./tokenize/setext-underline.js');\nvar thematicBreak = require('./tokenize/thematic-break.js');\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};\nvar contentInitial = {\n  91: definition // Left square bracket\n};\nvar flowInitial = {\n  '-2': codeIndented,\n  // Horizontal tab\n  '-1': codeIndented,\n  // Virtual space\n  32: codeIndented // Space\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};\nvar string = {\n  38: characterReference,\n  // Ampersand\n  92: characterEscape // Backslash\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};\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 markdownLineEnding = require('../character/markdown-line-ending.js');\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\nvar prefixSize = require('../util/prefix-size.js');\nvar factorySpace = require('./factory-space.js');\nvar codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\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  function start(code) {\n    effects.enter('codeFenced');\n    effects.enter('codeFencedFence');\n    effects.enter('codeFencedFenceSequence');\n    marker = code;\n    return sequenceOpen(code);\n  }\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n    effects.exit('codeFencedFenceSequence');\n    return sizeOpen < 3 ? nok(code) : factorySpace(effects, infoOpen, 'whitespace')(code);\n  }\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code);\n    }\n    effects.enter('codeFencedFenceInfo');\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return info(code);\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    if (code === 96 && code === marker) return nok(code);\n    effects.consume(code);\n    return info;\n  }\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code);\n    }\n    effects.enter('codeFencedFenceMeta');\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return meta(code);\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    if (code === 96 && code === marker) return nok(code);\n    effects.consume(code);\n    return meta;\n  }\n  function openAfter(code) {\n    effects.exit('codeFencedFence');\n    return self.interrupt ? ok(code) : content(code);\n  }\n  function content(code) {\n    if (code === null) {\n      return after(code);\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    effects.enter('codeFlowValue');\n    return contentContinue(code);\n  }\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue');\n      return content(code);\n    }\n    effects.consume(code);\n    return contentContinue;\n  }\n  function after(code) {\n    effects.exit('codeFenced');\n    return ok(code);\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    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence');\n      effects.enter('codeFencedFenceSequence');\n      return closingSequence(code);\n    }\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code);\n        size++;\n        return closingSequence;\n      }\n      if (size < sizeOpen) return nok(code);\n      effects.exit('codeFencedFenceSequence');\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code);\n    }\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence');\n        return ok(code);\n      }\n      return nok(code);\n    }\n  }\n}\nmodule.exports = codeFenced;","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = own;","\"use strict\";\n\n/**\n * Naive, simple plugin to match inline nodes without attributes\n * This allows say <strong>foo</strong>, but not <strong class=\"very\">foo</strong>\n * For proper HTML support, you'll want a different plugin\n **/\nvar visit = require('unist-util-visit');\nvar type = 'virtualHtml';\nvar selfClosingRe = /^<(area|base|br|col|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)\\s*\\/?>$/i;\nvar simpleTagRe = /^<(\\/?)([a-z]+)\\s*>$/;\nmodule.exports = function (tree) {\n  var open;\n  var currentParent;\n  visit(tree, 'html', function (node, index, parent) {\n    if (currentParent !== parent) {\n      open = [];\n      currentParent = parent;\n    }\n    var selfClosing = getSelfClosing(node);\n    if (selfClosing) {\n      parent.children.splice(index, 1, {\n        type: type,\n        tag: selfClosing,\n        position: node.position\n      });\n      return true;\n    }\n    var current = getSimpleTag(node, parent);\n    if (!current) {\n      return true;\n    }\n    var matching = findAndPull(open, current.tag);\n    if (matching) {\n      parent.children.splice(index, 0, virtual(current, matching, parent));\n    } else if (!current.opening) {\n      open.push(current);\n    }\n    return true;\n  }, true // Iterate in reverse\n  );\n  return tree;\n};\nfunction findAndPull(open, matchingTag) {\n  var i = open.length;\n  while (i--) {\n    if (open[i].tag === matchingTag) {\n      return open.splice(i, 1)[0];\n    }\n  }\n  return false;\n}\nfunction getSimpleTag(node, parent) {\n  var match = node.value.match(simpleTagRe);\n  return match ? {\n    tag: match[2],\n    opening: !match[1],\n    node: node\n  } : false;\n}\nfunction getSelfClosing(node) {\n  var match = node.value.match(selfClosingRe);\n  return match ? match[1] : false;\n}\nfunction virtual(fromNode, toNode, parent) {\n  var fromIndex = parent.children.indexOf(fromNode.node);\n  var toIndex = parent.children.indexOf(toNode.node);\n  var extracted = parent.children.splice(fromIndex, toIndex - fromIndex + 1);\n  var children = extracted.slice(1, -1);\n  return {\n    type: type,\n    children: children,\n    tag: fromNode.tag,\n    position: {\n      start: fromNode.node.position.start,\n      end: toNode.node.position.end,\n      indent: []\n    }\n  };\n}","'use strict';\n\nvar sizeChunks = require('./size-chunks.js');\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}\nmodule.exports = prefixSize;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar factorySpace = require('../tokenize/factory-space.js');\nvar tokenize = initializeContent;\nfunction initializeContent(effects) {\n  var contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\n  var previous;\n  return contentStart;\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, contentStart, 'linePrefix');\n  }\n  function paragraphInitial(code) {\n    effects.enter('paragraph');\n    return lineStart(code);\n  }\n  function lineStart(code) {\n    var token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous: previous\n    });\n    if (previous) {\n      previous.next = token;\n    }\n    previous = token;\n    return data(code);\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    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      effects.exit('chunkText');\n      return lineStart;\n    } // Data.\n\n    effects.consume(code);\n    return data;\n  }\n}\nexports.tokenize = tokenize;","'use strict';\n\nvar stringify = require('unist-util-stringify-position');\nmodule.exports = VMessage;\n\n// Inherit from `Error#`.\nfunction VMessagePrototype() {}\nVMessagePrototype.prototype = Error.prototype;\nVMessage.prototype = new VMessagePrototype();\n\n// Message properties.\nvar proto = VMessage.prototype;\nproto.file = '';\nproto.name = '';\nproto.reason = '';\nproto.message = '';\nproto.stack = '';\nproto.fatal = null;\nproto.column = null;\nproto.line = null;\n\n// Construct a new VMessage.\n//\n// Note: We cannot invoke `Error` on the created context, as that adds readonly\n// `line` and `column` attributes on Safari 9, thus throwing and failing the\n// data.\nfunction VMessage(reason, position, origin) {\n  var parts;\n  var range;\n  var location;\n  if (typeof position === 'string') {\n    origin = position;\n    position = null;\n  }\n  parts = parseOrigin(origin);\n  range = stringify(position) || '1:1';\n  location = {\n    start: {\n      line: null,\n      column: null\n    },\n    end: {\n      line: null,\n      column: null\n    }\n  };\n\n  // Node.\n  if (position && position.position) {\n    position = position.position;\n  }\n  if (position) {\n    // Position.\n    if (position.start) {\n      location = position;\n      position = position.start;\n    } else {\n      // Point.\n      location.start = position;\n    }\n  }\n  if (reason.stack) {\n    this.stack = reason.stack;\n    reason = reason.message;\n  }\n  this.message = reason;\n  this.name = range;\n  this.reason = reason;\n  this.line = position ? position.line : null;\n  this.column = position ? position.column : null;\n  this.location = location;\n  this.source = parts[0];\n  this.ruleId = parts[1];\n}\nfunction parseOrigin(origin) {\n  var result = [null, null];\n  var index;\n  if (typeof origin === 'string') {\n    index = origin.indexOf(':');\n    if (index === -1) {\n      result[1] = origin;\n    } else {\n      result[0] = origin.slice(0, index);\n      result[1] = origin.slice(index + 1);\n    }\n  }\n  return result;\n}","'use strict';\n\nmodule.exports = require('./dist');","\"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\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar factorySpace = require('../tokenize/factory-space.js');\nvar partialBlankLine = require('../tokenize/partial-blank-line.js');\nvar tokenize = initializeDocument;\nvar containerConstruct = {\n  tokenize: tokenizeContainer\n};\nvar lazyFlowConstruct = {\n  tokenize: tokenizeLazyFlow\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  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    return documentContinued(code);\n  }\n  function documentContinue(code) {\n    continued++;\n    return start(code);\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    self.interrupt = childFlow && childFlow.currentConstruct && childFlow.currentConstruct.interruptible;\n    self.containerState = {};\n    return effects.attempt(containerConstruct, containerContinue, flowStart)(code);\n  }\n  function containerContinue(code) {\n    stack.push([self.currentConstruct, self.containerState]);\n    self.containerState = undefined;\n    return documentContinued(code);\n  }\n  function flowStart(code) {\n    if (code === null) {\n      exitContainers(0, true);\n      effects.consume(code);\n      return;\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  function flowContinue(code) {\n    if (code === null) {\n      continueFlow(effects.exit('chunkFlow'));\n      return flowStart(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      continueFlow(effects.exit('chunkFlow'));\n      return effects.check(inspectConstruct, documentAfterPeek);\n    }\n    effects.consume(code);\n    return flowContinue;\n  }\n  function documentAfterPeek(code) {\n    exitContainers(inspectResult.continued, inspectResult && inspectResult.flowEnd);\n    continued = 0;\n    return start(code);\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  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    while (index-- > size) {\n      self.containerState = stack[index][1];\n      stack[index][0].exit.call(self, effects);\n    }\n    stack.length = size;\n  }\n  function tokenizeInspect(effects, ok) {\n    var subcontinued = 0;\n    inspectResult = {};\n    return inspectStart;\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      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        inspectResult.flowContinue = true;\n        return inspectDone(code);\n      }\n      self.interrupt = childFlow.currentConstruct && childFlow.currentConstruct.interruptible;\n      self.containerState = {};\n      return effects.attempt(containerConstruct, inspectFlowEnd, inspectDone)(code);\n    }\n    function inspectContinue(code) {\n      subcontinued++;\n      return self.containerState._closeFlow ? inspectFlowEnd(code) : inspectStart(code);\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,\n        // Maybe flow, or a blank line?\n        effects.attempt(lazyFlowConstruct, inspectFlowEnd, effects.check(partialBlankLine, inspectFlowEnd, inspectLazy)))(code);\n      } // Otherwise we’re interrupting.\n\n      return inspectFlowEnd(code);\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    function inspectFlowEnd(code) {\n      inspectResult.flowEnd = true;\n      return inspectDone(code);\n    }\n    function inspectDone(code) {\n      inspectResult.continued = subcontinued;\n      self.interrupt = self.containerState = undefined;\n      return ok(code);\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}\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}\nexports.tokenize = tokenize;","'use strict';\n\n/* eslint-env browser */\nvar el;\nvar semicolon = 59; //  ';'\n\nmodule.exports = decodeEntity;\nfunction decodeEntity(characters) {\n  var entity = '&' + characters + ';';\n  var char;\n  el = el || document.createElement('i');\n  el.innerHTML = entity;\n  char = el.textContent;\n\n  // Some entities do not require the closing semicolon (`&not` - for instance),\n  // which leads to situations where parsing the assumed entity of &notit; will\n  // result in the string `¬it;`.  When we encounter a trailing semicolon after\n  // parsing and the entity to decode was not a semicolon (`&semi;`), we can\n  // assume that the matching was incomplete\n  if (char.charCodeAt(char.length - 1) === semicolon && characters !== 'semi') {\n    return false;\n  }\n\n  // If the decoded string is equal to the input, the entity was not valid\n  return char === entity ? false : char;\n}","'use strict';\n\nvar asciiDigit = require('../character/ascii-digit.js');\nvar markdownSpace = require('../character/markdown-space.js');\nvar prefixSize = require('../util/prefix-size.js');\nvar sizeChunks = require('../util/size-chunks.js');\nvar factorySpace = require('./factory-space.js');\nvar partialBlankLine = require('./partial-blank-line.js');\nvar thematicBreak = require('./thematic-break.js');\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};\nfunction tokenizeListStart(effects, ok, nok) {\n  var self = this;\n  var initialSize = prefixSize(self.events, 'linePrefix');\n  var size = 0;\n  return start;\n  function start(code) {\n    var kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? 'listUnordered' : 'listOrdered');\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      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix');\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix');\n        effects.enter('listItemValue');\n        return inside(code);\n      }\n    }\n    return nok(code);\n  }\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\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    return nok(code);\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,\n    // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\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    return nok(code);\n  }\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + sizeChunks(self.sliceStream(effects.exit('listItemPrefix')));\n    return ok(code);\n  }\n}\nfunction tokenizeListContinuation(effects, ok, nok) {\n  var self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(partialBlankLine, onBlank, notBlank);\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  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;\n      return notInCurrentItem(code);\n    }\n    self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\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}\nfunction tokenizeIndent(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'listItemIndent', self.containerState.size + 1);\n  function afterPrefix(code) {\n    return prefixSize(self.events, 'listItemIndent') === self.containerState.size ? ok(code) : nok(code);\n  }\n}\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\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  function afterPrefix(code) {\n    return markdownSpace(code) || !prefixSize(self.events, 'listItemPrefixWhitespace') ? nok(code) : ok(code);\n  }\n}\nmodule.exports = list;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\nvar unicodeWhitespace = regexCheck(/\\s/);\nmodule.exports = unicodeWhitespace;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\nvar asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\nmodule.exports = asciiAlphanumeric;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar markdownSpace = require('../character/markdown-space.js');\nvar factorySpace = require('./factory-space.js');\nfunction whitespaceFactory(effects, ok) {\n  var seen;\n  return start;\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    if (markdownSpace(code)) {\n      return factorySpace(effects, start, seen ? 'linePrefix' : 'lineSuffix')(code);\n    }\n    return ok(code);\n  }\n}\nmodule.exports = whitespaceFactory;","'use strict';\n\nmodule.exports = visitParents;\nvar convert = require('unist-util-is/convert');\nvar color = require('./color');\nvar CONTINUE = true;\nvar SKIP = 'skip';\nvar EXIT = false;\nvisitParents.CONTINUE = CONTINUE;\nvisitParents.SKIP = SKIP;\nvisitParents.EXIT = EXIT;\nfunction visitParents(tree, test, visitor, reverse) {\n  var step;\n  var is;\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n  is = convert(test);\n  step = reverse ? -1 : 1;\n  factory(tree, null, [])();\n  function factory(node, index, parents) {\n    var value = typeof node === 'object' && node !== null ? node : {};\n    var name;\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    return visit;\n    function visit() {\n      var grandparents = parents.concat(node);\n      var result = [];\n      var subresult;\n      var offset;\n      if (!test || is(node, index, parents[parents.length - 1] || null)) {\n        result = toResult(visitor(node, parents));\n        if (result[0] === EXIT) {\n          return result;\n        }\n      }\n      if (node.children && result[0] !== SKIP) {\n        offset = (reverse ? node.children.length : -1) + step;\n        while (offset > -1 && offset < node.children.length) {\n          subresult = factory(node.children[offset], offset, grandparents)();\n          if (subresult[0] === EXIT) {\n            return subresult;\n          }\n          offset = typeof subresult[1] === 'number' ? subresult[1] : offset + step;\n        }\n      }\n      return result;\n    }\n  }\n}\nfunction toResult(value) {\n  if (value !== null && typeof value === 'object' && 'length' in value) {\n    return value;\n  }\n  if (typeof value === 'number') {\n    return [CONTINUE, value];\n  }\n  return [value];\n}","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\nvar asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\nmodule.exports = asciiPunctuation;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\nfunction safeFromInt(value, base) {\n  var code = parseInt(value, base);\n  if (\n  // C0 except for HT, LF, FF, CR, space\n  code < 9 || code === 11 || code > 13 && code < 32 ||\n  // Control character (DEL) of the basic block and C1 controls.\n  code > 126 && code < 160 ||\n  // Lone high surrogates and low surrogates.\n  code > 55295 && code < 57344 ||\n  // Noncharacters.\n  code > 64975 && code < 65008 || (code & 65535) === 65535 || (code & 65535) === 65534 ||\n  // Out of range\n  code > 1114111) {\n    return '\\uFFFD';\n  }\n  return fromCharCode(code);\n}\nmodule.exports = safeFromInt;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\nfunction regexCheck(regex) {\n  return check;\n  function check(code) {\n    return regex.test(fromCharCode(code));\n  }\n}\nmodule.exports = regexCheck;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\nvar markdownSpace = require('../character/markdown-space.js');\nvar factorySpace = require('./factory-space.js');\nvar htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\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  function start(code) {\n    effects.enter('htmlText');\n    effects.enter('htmlTextData');\n    effects.consume(code);\n    return open;\n  }\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    return nok(code);\n  }\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpen;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      buffer = 'CDATA[';\n      index = 0;\n      return cdataOpen;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n    return nok(code);\n  }\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentStart;\n    }\n    return nok(code);\n  }\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code);\n    }\n    if (code === 45) {\n      effects.consume(code);\n      return commentStartDash;\n    }\n    return comment(code);\n  }\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code);\n    }\n    return comment(code);\n  }\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return atLineEnding(code);\n    }\n    effects.consume(code);\n    return comment;\n  }\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return end;\n    }\n    return comment(code);\n  }\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === buffer.length ? cdata : cdataOpen;\n    }\n    return nok(code);\n  }\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return atLineEnding(code);\n    }\n    effects.consume(code);\n    return cdata;\n  }\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return atLineEnding(code);\n    }\n    effects.consume(code);\n    return declaration;\n  }\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return atLineEnding(code);\n    }\n    effects.consume(code);\n    return instruction;\n  }\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return nok(code);\n  }\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return tagCloseBetween(code);\n  }\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return atLineEnding(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n    return end(code);\n  }\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return atLineEnding(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n    return end(code);\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    return tagOpenAttributeNameAfter(code);\n  }\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return atLineEnding(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n    return tagOpenBetween(code);\n  }\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return atLineEnding(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    effects.consume(code);\n    marker = undefined;\n    return tagOpenAttributeValueUnquoted;\n  }\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return tagOpenAttributeValueQuotedAfter;\n    }\n    if (code === null) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return atLineEnding(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\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    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\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  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  function afterPrefix(code) {\n    effects.enter('htmlTextData');\n    return returnState(code);\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    return nok(code);\n  }\n}\nmodule.exports = htmlText;","'use strict';\n\nmodule.exports = fromMarkdown;\n\n// These three are compiled away in the `dist/`\n\nvar toString = require('mdast-util-to-string');\nvar assign = require('micromark/dist/constant/assign');\nvar own = require('micromark/dist/constant/has-own-property');\nvar normalizeIdentifier = require('micromark/dist/util/normalize-identifier');\nvar safeFromInt = require('micromark/dist/util/safe-from-int');\nvar parser = require('micromark/dist/parse');\nvar preprocessor = require('micromark/dist/preprocess');\nvar postprocess = require('micromark/dist/postprocess');\nvar decode = require('parse-entities/decode-entity');\nvar stringifyPosition = require('unist-util-stringify-position');\nfunction fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding;\n    encoding = undefined;\n  }\n  return compiler(options)(postprocess(parser(options).document().write(preprocessor()(value, encoding, true))));\n}\n\n// Note this compiler only understand complete buffering, not streaming.\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  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    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    index = -1;\n    while (++index < events.length) {\n      handler = config[events[index][0]];\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    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    }\n\n    // Figure out `root` position.\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    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree;\n    }\n    return tree;\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    while (++index <= length) {\n      event = events[index];\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        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          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') {\n        // Empty.\n      } else {\n        atMarker = undefined;\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          while (tailIndex--) {\n            tailEvent = events[tailIndex];\n            if (tailEvent[1].type === 'lineEnding' || tailEvent[1].type === 'lineEndingBlank') {\n              if (tailEvent[0] === 'exit') continue;\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank';\n                listSpread = true;\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') {\n              // Empty\n            } else {\n              break;\n            }\n          }\n          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {\n            listItem._spread = true;\n          }\n\n          // Fix position.\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        }\n\n        // Create a new list item.\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    events[start][1]._spread = listSpread;\n    return length;\n  }\n  function setData(key, value) {\n    data[key] = value;\n  }\n  function getData(key) {\n    return data[key];\n  }\n  function point(d) {\n    return {\n      line: d.line,\n      column: d.column,\n      offset: d.offset\n    };\n  }\n  function opener(create, and) {\n    return open;\n    function open(token) {\n      enter.call(this, create(token), token);\n      if (and) and.call(this, token);\n    }\n  }\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\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  function closer(and) {\n    return close;\n    function close(token) {\n      if (and) and.call(this, token);\n      exit.call(this, token);\n    }\n  }\n  function exit(token) {\n    var node = this.stack.pop();\n    var open = this.tokenStack.pop();\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    node.position.end = point(token.end);\n    return node;\n  }\n  function resume() {\n    return toString(this.stack.pop());\n  }\n\n  //\n  // Handlers.\n  //\n\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true);\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  function onexitcodefencedfenceinfo() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].lang = data;\n  }\n  function onexitcodefencedfencemeta() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].meta = data;\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  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  function onexitcodeindented() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\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  function onexitdefinitiontitlestring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].title = data;\n  }\n  function onexitdefinitiondestinationstring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].url = data;\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  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true);\n  }\n  function onexitsetextheadinglinesequence(token) {\n    this.stack[this.stack.length - 1].depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2;\n  }\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding');\n  }\n  function onenterdata(token) {\n    var siblings = this.stack[this.stack.length - 1].children;\n    var tail = siblings[siblings.length - 1];\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    this.stack.push(tail);\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  function onexitlineending(token) {\n    var context = this.stack[this.stack.length - 1];\n\n    // If we’re at a hard break, include the line ending in there.\n    if (getData('atHardBreak')) {\n      context.children[context.children.length - 1].position.end = point(token.end);\n      setData('atHardBreak');\n      return;\n    }\n    if (!getData('setextHeadingSlurpLineEnding') && config.canContainEols.indexOf(context.type) > -1) {\n      onenterdata.call(this, token);\n      onexitdata.call(this, token);\n    }\n  }\n  function onexithardbreak() {\n    setData('atHardBreak', true);\n  }\n  function onexithtmlflow() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n  function onexithtmltext() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n  function onexitcodetext() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n  function onexitlink() {\n    var context = this.stack[this.stack.length - 1];\n\n    // To do: clean.\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    setData('referenceType');\n  }\n  function onexitimage() {\n    var context = this.stack[this.stack.length - 1];\n\n    // To do: clean.\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    setData('referenceType');\n  }\n  function onexitlabeltext(token) {\n    this.stack[this.stack.length - 2].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\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;\n\n    // Assume a reference.\n    setData('inReference', true);\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  function onexitresourcedestinationstring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].url = data;\n  }\n  function onexitresourcetitlestring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].title = data;\n  }\n  function onexitresource() {\n    setData('inReference');\n  }\n  function onenterreference() {\n    setData('referenceType', 'collapsed');\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  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type);\n  }\n  function onexitcharacterreferencevalue(token) {\n    var data = this.sliceSerialize(token);\n    var type = getData('characterReferenceType');\n    var value;\n    var tail;\n    if (type) {\n      value = safeFromInt(data, type === 'characterReferenceMarkerNumeric' ? 10 : 16);\n      setData('characterReferenceType');\n    } else {\n      value = decode(data);\n    }\n    tail = this.stack.pop();\n    tail.value += value;\n    tail.position.end = point(token.end);\n  }\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token);\n    this.stack[this.stack.length - 1].url = this.sliceSerialize(token);\n  }\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token);\n    this.stack[this.stack.length - 1].url = 'mailto:' + this.sliceSerialize(token);\n  }\n\n  //\n  // Creaters.\n  //\n\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    };\n  }\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    };\n  }\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    };\n  }\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    };\n  }\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    };\n  }\n  function heading() {\n    return {\n      type: 'heading',\n      depth: undefined,\n      children: []\n    };\n  }\n  function hardBreak() {\n    return {\n      type: 'break'\n    };\n  }\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    };\n  }\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    };\n  }\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\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  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    };\n  }\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    };\n  }\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    };\n  }\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    };\n  }\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    };\n  }\n}\nfunction configure(config, extensions) {\n  var index = -1;\n  while (++index < extensions.length) {\n    extension(config, extensions[index]);\n  }\n  return config;\n}\nfunction extension(config, extension) {\n  var key;\n  var left;\n  for (key in extension) {\n    left = own.call(config, key) ? config[key] : config[key] = {};\n    if (key === 'canContainEols' || key === 'transforms') {\n      config[key] = [].concat(left, extension[key]);\n    } else {\n      Object.assign(left, extension[key]);\n    }\n  }\n}","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\nvar normalizeIdentifier = require('../util/normalize-identifier.js');\nvar factoryDestination = require('./factory-destination.js');\nvar factoryLabel = require('./factory-label.js');\nvar factorySpace = require('./factory-space.js');\nvar factoryWhitespace = require('./factory-whitespace.js');\nvar factoryTitle = require('./factory-title.js');\nvar definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\nvar titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n};\nfunction tokenizeDefinition(effects, ok, nok) {\n  var self = this;\n  var identifier;\n  return start;\n  function start(code) {\n    effects.enter('definition');\n    return factoryLabel.call(self, effects, labelAfter, nok, 'definitionLabel', 'definitionLabelMarker', 'definitionLabelString')(code);\n  }\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\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    return nok(code);\n  }\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition');\n      if (self.parser.defined.indexOf(identifier) < 0) {\n        self.parser.defined.push(identifier);\n      }\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\nfunction tokenizeTitle(effects, ok, nok) {\n  return start;\n  function start(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, before)(code) : nok(code);\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    return nok(code);\n  }\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}\nmodule.exports = definition;","'use strict';\n\nfunction miniflat(value) {\n  return value === null || value === undefined ? [] : 'length' in value ? value : [value];\n}\nmodule.exports = miniflat;","'use strict';\n\nvar p = require('./minpath');\nvar proc = require('./minproc');\nvar buffer = require('is-buffer');\nmodule.exports = VFile;\nvar own = {}.hasOwnProperty;\n\n// 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.\nvar order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];\nVFile.prototype.toString = toString;\n\n// Access full path (`~/index.min.js`).\nObject.defineProperty(VFile.prototype, 'path', {\n  get: getPath,\n  set: setPath\n});\n\n// Access parent path (`~`).\nObject.defineProperty(VFile.prototype, 'dirname', {\n  get: getDirname,\n  set: setDirname\n});\n\n// Access basename (`index.min.js`).\nObject.defineProperty(VFile.prototype, 'basename', {\n  get: getBasename,\n  set: setBasename\n});\n\n// Access extname (`.js`).\nObject.defineProperty(VFile.prototype, 'extname', {\n  get: getExtname,\n  set: setExtname\n});\n\n// Access stem (`index.min`).\nObject.defineProperty(VFile.prototype, 'stem', {\n  get: getStem,\n  set: setStem\n});\n\n// Construct a new file.\nfunction VFile(options) {\n  var prop;\n  var index;\n  if (!options) {\n    options = {};\n  } else if (typeof options === 'string' || buffer(options)) {\n    options = {\n      contents: options\n    };\n  } else if ('message' in options && 'messages' in options) {\n    return options;\n  }\n  if (!(this instanceof VFile)) {\n    return new VFile(options);\n  }\n  this.data = {};\n  this.messages = [];\n  this.history = [];\n  this.cwd = proc.cwd();\n\n  // Set path related properties in the correct order.\n  index = -1;\n  while (++index < order.length) {\n    prop = order[index];\n    if (own.call(options, prop)) {\n      this[prop] = options[prop];\n    }\n  }\n\n  // Set non-path related properties.\n  for (prop in options) {\n    if (order.indexOf(prop) < 0) {\n      this[prop] = options[prop];\n    }\n  }\n}\nfunction getPath() {\n  return this.history[this.history.length - 1];\n}\nfunction setPath(path) {\n  assertNonEmpty(path, 'path');\n  if (this.path !== path) {\n    this.history.push(path);\n  }\n}\nfunction getDirname() {\n  return typeof this.path === 'string' ? p.dirname(this.path) : undefined;\n}\nfunction setDirname(dirname) {\n  assertPath(this.path, 'dirname');\n  this.path = p.join(dirname || '', this.basename);\n}\nfunction getBasename() {\n  return typeof this.path === 'string' ? p.basename(this.path) : undefined;\n}\nfunction setBasename(basename) {\n  assertNonEmpty(basename, 'basename');\n  assertPart(basename, 'basename');\n  this.path = p.join(this.dirname || '', basename);\n}\nfunction getExtname() {\n  return typeof this.path === 'string' ? p.extname(this.path) : undefined;\n}\nfunction setExtname(extname) {\n  assertPart(extname, 'extname');\n  assertPath(this.path, 'extname');\n  if (extname) {\n    if (extname.charCodeAt(0) !== 46 /* `.` */) {\n      throw new Error('`extname` must start with `.`');\n    }\n    if (extname.indexOf('.', 1) > -1) {\n      throw new Error('`extname` cannot contain multiple dots');\n    }\n  }\n  this.path = p.join(this.dirname, this.stem + (extname || ''));\n}\nfunction getStem() {\n  return typeof this.path === 'string' ? p.basename(this.path, this.extname) : undefined;\n}\nfunction setStem(stem) {\n  assertNonEmpty(stem, 'stem');\n  assertPart(stem, 'stem');\n  this.path = p.join(this.dirname || '', stem + (this.extname || ''));\n}\n\n// Get the value of the file.\nfunction toString(encoding) {\n  return (this.contents || '').toString(encoding);\n}\n\n// Assert that `part` is not a path (i.e., does not contain `p.sep`).\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}\n\n// Assert that `part` is not empty.\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty');\n  }\n}\n\n// Assert `path` exists.\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too');\n  }\n}","\"use strict\";\n\nvar visit = require('unist-util-visit');\nvar splice = [].splice;\nexports.ofType = function (types, mode) {\n  return ifNotMatch(allow, mode);\n  function allow(node, index, parent) {\n    return !types.includes(node.type);\n  }\n};\nexports.ifNotMatch = ifNotMatch;\nfunction ifNotMatch(allow, mode) {\n  return transform;\n  function transform(tree) {\n    visit(tree, filter);\n    return tree;\n  } // eslint-disable-next-line consistent-return\n\n  function filter(node, index, parent) {\n    if (parent && !allow(node, index, parent)) {\n      var parameters = [index, 1];\n      if (mode === 'unwrap' && node.children) {\n        parameters = parameters.concat(node.children);\n      }\n      splice.apply(parent.children, parameters);\n      return index;\n    }\n  }\n}","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\nvar asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\nmodule.exports = asciiAtext;","'use strict';\n\n// 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.\nexports.basename = basename;\nexports.dirname = dirname;\nexports.extname = extname;\nexports.join = join;\nexports.sep = '/';\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  if (ext !== undefined && typeof ext !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n  assertPath(path);\n  index = path.length;\n  if (ext === undefined || !ext.length || ext.length > path.length) {\n    while (index--) {\n      if (path.charCodeAt(index) === 47 /* `/` */) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (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    return end < 0 ? '' : path.slice(start, end);\n  }\n  if (ext === path) {\n    return '';\n  }\n  firstNonSlashEnd = -1;\n  extIndex = ext.length - 1;\n  while (index--) {\n    if (path.charCodeAt(index) === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (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      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  if (start === end) {\n    end = firstNonSlashEnd;\n  } else if (end < 0) {\n    end = path.length;\n  }\n  return path.slice(start, end);\n}\nfunction dirname(path) {\n  var end;\n  var unmatchedSlash;\n  var index;\n  assertPath(path);\n  if (!path.length) {\n    return '.';\n  }\n  end = -1;\n  index = path.length;\n\n  // Prefix `--` is important to not run on `0`.\n  while (--index) {\n    if (path.charCodeAt(index) === 47 /* `/` */) {\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  return end < 0 ? path.charCodeAt(0) === 47 /* `/` */ ? '/' : '.' : end === 1 && path.charCodeAt(0) === 47 /* `/` */ ? '//' : path.slice(0, end);\n}\nfunction extname(path) {\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n  var preDotState = 0;\n  var unmatchedSlash;\n  var code;\n  var index;\n  assertPath(path);\n  index = path.length;\n  while (index--) {\n    code = path.charCodeAt(index);\n    if (code === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (unmatchedSlash) {\n        startPart = index + 1;\n        break;\n      }\n      continue;\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    if (code === 46 /* `.` */) {\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  if (startDot < 0 || end < 0 ||\n  // We saw a non-dot character immediately before the dot.\n  preDotState === 0 ||\n  // The (right-most) trimmed path component is exactly `..`.\n  preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n  return path.slice(startDot, end);\n}\nfunction join() {\n  var index = -1;\n  var joined;\n  while (++index < arguments.length) {\n    assertPath(arguments[index]);\n    if (arguments[index]) {\n      joined = joined === undefined ? arguments[index] : joined + '/' + arguments[index];\n    }\n  }\n  return joined === undefined ? '.' : normalize(joined);\n}\n\n// Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\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  value = normalizeString(path, !absolute);\n  if (!value.length && !absolute) {\n    value = '.';\n  }\n  if (value.length && path.charCodeAt(path.length - 1) === 47 /* / */) {\n    value += '/';\n  }\n  return absolute ? '/' + value : value;\n}\n\n// Resolve `.` and `..` elements in a path with directory names.\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  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.charCodeAt(index);\n    } else if (code === 47 /* `/` */) {\n      break;\n    } else {\n      code = 47; /* `/` */\n    }\n    if (code === 47 /* `/` */) {\n      if (lastSlash === index - 1 || dots === 1) {\n        // Empty.\n      } else if (lastSlash !== index - 1 && dots === 2) {\n        if (result.length < 2 || lastSegmentLength !== 2 || result.charCodeAt(result.length - 1) !== 46 /* `.` */ || result.charCodeAt(result.length - 2) !== 46 /* `.` */) {\n          if (result.length > 2) {\n            lastSlashIndex = result.lastIndexOf('/');\n\n            /* istanbul ignore else - No clue how to cover it. */\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              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        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        lastSegmentLength = index - lastSlash - 1;\n      }\n      lastSlash = index;\n      dots = 0;\n    } else if (code === 46 /* `.` */ && dots > -1) {\n      dots++;\n    } else {\n      dots = -1;\n    }\n  }\n  return result;\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\nmodule.exports = parse;\nvar fromMarkdown = require('mdast-util-from-markdown');\nfunction parse(options) {\n  var self = this;\n  this.Parser = parse;\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\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\nvar chunkedPush = require('../util/chunked-push.js');\nvar chunkedSplice = require('../util/chunked-splice.js');\nvar normalizeIdentifier = require('../util/normalize-identifier.js');\nvar resolveAll = require('../util/resolve-all.js');\nvar shallow = require('../util/shallow.js');\nvar factoryDestination = require('./factory-destination.js');\nvar factoryLabel = require('./factory-label.js');\nvar factoryTitle = require('./factory-title.js');\nvar factoryWhitespace = require('./factory-whitespace.js');\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};\nfunction resolveAllLabelEnd(events) {\n  var index = -1;\n  var token;\n  while (++index < events.length) {\n    token = events[index][1];\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  return events;\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    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      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        if (token.type !== 'labelLink') {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index;\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}\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  return start;\n  function start(code) {\n    if (!labelStart) {\n      return nok(code);\n    } // It’s a balanced bracket, but contains a link.\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  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    if (code === 91) {\n      return effects.attempt(fullReferenceConstruct, ok, defined ? effects.attempt(collapsedReferenceConstruct, ok, balanced) : balanced)(code);\n    } // Shortcut reference: `[asd]`?\n\n    return defined ? ok(code) : balanced(code);\n  }\n  function balanced(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\nfunction tokenizeResource(effects, ok, nok) {\n  return start;\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  function open(code) {\n    if (code === 41) {\n      return end(code);\n    }\n    return factoryDestination(effects, destinationAfter, nok, 'resourceDestination', 'resourceDestinationLiteral', 'resourceDestinationLiteralMarker', 'resourceDestinationRaw', 'resourceDestinationString', 3)(code);\n  }\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, between)(code) : end(code);\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    return end(code);\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    return nok(code);\n  }\n}\nfunction tokenizeFullReference(effects, ok, nok) {\n  var self = this;\n  return start;\n  function start(code) {\n    return factoryLabel.call(self, effects, afterLabel, nok, 'reference', 'referenceMarker', 'referenceString')(code);\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}\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start;\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  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    return nok(code);\n  }\n}\nmodule.exports = labelEnd;","'use strict';\n\nvar chunkedSplice = require('./chunked-splice.js');\nfunction chunkedPush(list, items) {\n  if (list.length) {\n    chunkedSplice(list, list.length, 0, items);\n    return list;\n  }\n  return items;\n}\nmodule.exports = chunkedPush;","var visitWithParents = require('unist-util-visit-parents');\nfunction addListMetadata() {\n  return function (ast) {\n    visitWithParents(ast, 'list', function (listNode, parents) {\n      var depth = 0,\n        i,\n        n;\n      for (i = 0, n = parents.length; i < n; i++) {\n        if (parents[i].type === 'list') depth += 1;\n      }\n      for (i = 0, n = listNode.children.length; i < n; i++) {\n        var child = listNode.children[i];\n        child.index = i;\n        child.ordered = listNode.ordered;\n      }\n      listNode.depth = depth;\n    });\n    return ast;\n  };\n}\nmodule.exports = addListMetadata;","'use strict';\n\nfunction markdownLineEndingOrSpace(code) {\n  return code < 0 || code === 32;\n}\nmodule.exports = markdownLineEndingOrSpace;","'use strict';\n\nvar wrap = require('./wrap.js');\nmodule.exports = trough;\ntrough.wrap = wrap;\nvar slice = [].slice;\n\n// Create new middleware.\nfunction trough() {\n  var fns = [];\n  var middleware = {};\n  middleware.run = run;\n  middleware.use = use;\n  return middleware;\n\n  // Run `fns`.  Last argument must be a completion handler.\n  function run() {\n    var index = -1;\n    var input = slice.call(arguments, 0, -1);\n    var done = arguments[arguments.length - 1];\n    if (typeof done !== 'function') {\n      throw new Error('Expected function as last argument, not ' + done);\n    }\n    next.apply(null, [null].concat(input));\n\n    // Run the next `fn`, if any.\n    function next(err) {\n      var fn = fns[++index];\n      var params = slice.call(arguments, 0);\n      var values = params.slice(1);\n      var length = input.length;\n      var pos = -1;\n      if (err) {\n        done(err);\n        return;\n      }\n\n      // Copy non-nully input into values.\n      while (++pos < length) {\n        if (values[pos] === null || values[pos] === undefined) {\n          values[pos] = input[pos];\n        }\n      }\n      input = values;\n\n      // Next or done.\n      if (fn) {\n        wrap(fn, next).apply(null, input);\n      } else {\n        done.apply(null, [null].concat(input));\n      }\n    }\n  }\n\n  // Add `fn` to the list.\n  function use(fn) {\n    if (typeof fn !== 'function') {\n      throw new Error('Expected `fn` to be a function, not ' + fn);\n    }\n    fns.push(fn);\n    return middleware;\n  }\n}","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\nvar shallow = require('../util/shallow.js');\nvar factorySpace = require('./factory-space.js');\nvar setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\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      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      if (!definition && events[index][1].type === 'definition') {\n        definition = index;\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  events.push(['exit', heading, context]);\n  return events;\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  return start;\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    return nok(code);\n  }\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return closingSequence;\n    }\n    effects.exit('setextHeadingLineSequence');\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code);\n  }\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine');\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\nmodule.exports = setextUnderline;"],"sourceRoot":""}