{"version":3,"sources":["webpack:///./node_modules/mdast-util-to-markdown/lib/unsafe.js","webpack:///./node_modules/micromark/dist/tokenize/autolink.js","webpack:///./node_modules/micromark/dist/util/normalize-identifier.js","webpack:///./node_modules/micromark/dist/character/unicode-punctuation.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/code.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/container-flow.js","webpack:///./node_modules/micromark/dist/tokenize/heading-atx.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/strong.js","webpack:///./node_modules/property-information/lib/util/create.js","webpack:///./node_modules/mdast-util-to-hast/lib/wrap.js","webpack:///./node_modules/micromark/dist/constant/from-char-code.js","webpack:///./node_modules/micromark/dist/character/markdown-line-ending.js","webpack:///./node_modules/micromark/dist/util/serialize-chunks.js","webpack:///./node_modules/property-information/lib/util/types.js","webpack:///./node_modules/mdast-util-to-hast/lib/index.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/index.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/safe.js","webpack:///./node_modules/property-information/find.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/code.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/image.js","webpack:///./node_modules/micromark/dist/util/chunked-push.js","webpack:///./node_modules/micromark/dist/tokenize/definition.js","webpack:///./node_modules/property-information/svg.js","webpack:///./node_modules/mdast-util-to-string/index.js","webpack:///./node_modules/micromark/dist/tokenize/label-start-link.js","webpack:///./node_modules/micromark/dist/util/resolve-all.js","webpack:///./node_modules/micromark/dist/tokenize/setext-underline.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/image.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/text.js","webpack:///./node_modules/micromark/dist/tokenize/html-flow.js","webpack:///./node_modules/micromark/dist/constant/html-raw-names.js","webpack:///./node_modules/longest-streak/index.js","webpack:///./node_modules/mdast-util-from-markdown/index.js","webpack:///./node_modules/micromark/dist/initialize/flow.js","webpack:///./node_modules/micromark/dist/util/subtokenize.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","webpack:///./node_modules/micromark/dist/constant/unicode-punctuation-regex.js","webpack:///./node_modules/micromark/dist/tokenize/code-indented.js","webpack:///./node_modules/micromark/dist/constant/assign.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js","webpack:///./node_modules/micromark/dist/character/ascii-alphanumeric.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/root.js","webpack:///./node_modules/mdast-util-to-markdown/lib/join.js","webpack:///./node_modules/micromark/dist/tokenize/label-end.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/strong.js","webpack:///./node_modules/micromark/dist/util/prefix-size.js","webpack:///./node_modules/micromark/dist/tokenize/code-fenced.js","webpack:///./node_modules/micromark/dist/character/ascii-hex-digit.js","webpack:///./node_modules/micromark/dist/character/markdown-line-ending-or-space.js","webpack:///./node_modules/property-information/lib/html.js","webpack:///./node_modules/repeat-string/index.js","webpack:///./node_modules/micromark/dist/constructs.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/table.js","webpack:///./node_modules/micromark/dist/constant/html-block-names.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/link.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/list-item.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.js","webpack:///./node_modules/micromark/dist/constant/has-own-property.js","webpack:///./node_modules/micromark/dist/util/shallow.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/check-rule.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js","webpack:///./node_modules/micromark/dist/tokenize/character-escape.js","webpack:///./node_modules/mdast-util-to-markdown/lib/configure.js","webpack:///./node_modules/mdast-util-to-hast/lib/footer.js","webpack:///./node_modules/property-information/lib/util/info.js","webpack:///./node_modules/micromark/dist/tokenize/partial-blank-line.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js","webpack:///./node_modules/micromark/dist/util/chunked-splice.js","webpack:///./node_modules/mdast-util-to-hast/lib/all.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","webpack:///./node_modules/mdast-util-to-hast/lib/revert.js","webpack:///./node_modules/parse-entities/decode-entity.browser.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","webpack:///./node_modules/remark/index.js","webpack:///./node_modules/micromark/dist/initialize/document.js","webpack:///./node_modules/remark-stringify/index.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/index.js","webpack:///./node_modules/micromark/dist/util/safe-from-int.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/emphasis.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/break.js","webpack:///./node_modules/property-information/normalize.js","webpack:///./node_modules/property-information/lib/aria.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/list-item.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/html.js","webpack:///./node_modules/micromark/dist/tokenize/attention.js","webpack:///./node_modules/property-information/lib/util/schema.js","webpack:///./node_modules/property-information/lib/xmlns.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/indent-lines.js","webpack:///./node_modules/property-information/lib/xlink.js","webpack:///./node_modules/property-information/lib/xml.js","webpack:///./node_modules/mdast-util-to-hast/index.js","webpack:///./node_modules/micromark/dist/tokenize/line-ending.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/html.js","webpack:///./node_modules/remark-parse/index.js","webpack:///./node_modules/micromark/dist/util/classify-character.js","webpack:///./node_modules/mdast-util-to-markdown/lib/index.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/inline-code.js","webpack:///./node_modules/micromark/dist/tokenize/hard-break-escape.js","webpack:///./node_modules/micromark/dist/tokenize/factory-destination.js","webpack:///./node_modules/micromark/dist/character/ascii-alpha.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/check-fence.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/check-rule-repeat.js","webpack:///./node_modules/mdast-util-to-hast/lib/one.js","webpack:///./node_modules/micromark/dist/util/size-chunks.js","webpack:///./node_modules/micromark/dist/tokenize/block-quote.js","webpack:///./node_modules/micromark/dist/tokenize/factory-label.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/heading.js","webpack:///./node_modules/micromark/dist/character/ascii-digit.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/root.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/association.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/footnote.js","webpack:///./node_modules/micromark/dist/util/combine-extensions.js","webpack:///./node_modules/micromark/dist/preprocess.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/list.js","webpack:///./node_modules/micromark/dist/util/miniflat.js","webpack:///./node_modules/micromark/dist/character/ascii-punctuation.js","webpack:///./node_modules/property-information/lib/util/defined-info.js","webpack:///./node_modules/micromark/dist/tokenize/content.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","webpack:///./node_modules/micromark/dist/util/regex-check.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/check-emphasis.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/text.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/list.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/check-quote.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/image-reference.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/paragraph.js","webpack:///./node_modules/micromark/dist/character/unicode-whitespace.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js","webpack:///./node_modules/property-information/lib/util/case-sensitive-transform.js","webpack:///./node_modules/remark-html/index.js","webpack:///./node_modules/mdast-util-from-markdown/dist/index.js","webpack:///./node_modules/mdurl/encode.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/blockquote.js","webpack:///./node_modules/micromark/dist/tokenize/factory-space.js","webpack:///./node_modules/property-information/lib/util/case-insensitive-transform.js","webpack:///./node_modules/property-information/lib/svg.js","webpack:///./node_modules/mdast-util-to-markdown/index.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/link-reference.js","webpack:///./node_modules/property-information/lib/util/merge.js","webpack:///./node_modules/micromark/dist/parse.js","webpack:///./node_modules/micromark/dist/constant/splice.js","webpack:///./node_modules/micromark/dist/initialize/content.js","webpack:///./node_modules/micromark/dist/tokenize/factory-whitespace.js","webpack:///./node_modules/micromark/dist/postprocess.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","webpack:///./node_modules/micromark/dist/character/markdown-space.js","webpack:///./node_modules/micromark/dist/util/slice-chunks.js","webpack:///./node_modules/mdast-util-definitions/index.js","webpack:///./node_modules/micromark/dist/tokenize/html-text.js","webpack:///./node_modules/micromark/dist/tokenize/thematic-break.js","webpack:///./node_modules/micromark/dist/tokenize/character-reference.js","webpack:///./node_modules/micromark/dist/tokenize/list.js","webpack:///./node_modules/micromark/dist/util/create-tokenizer.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/heading.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/break.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/pattern-compile.js","webpack:///./node_modules/micromark/dist/tokenize/label-start-image.js","webpack:///./node_modules/property-information/html.js","webpack:///./node_modules/micromark/dist/character/ascii-atext.js","webpack:///./node_modules/micromark/dist/character/ascii-control.js","webpack:///./node_modules/micromark/dist/tokenize/factory-title.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/check-strong.js","webpack:///./node_modules/micromark/dist/initialize/text.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/thematic-break.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/delete.js","webpack:///./node_modules/mdast-util-to-markdown/lib/handle/definition.js","webpack:///./node_modules/micromark/dist/tokenize/code-text.js","webpack:///./node_modules/mdast-util-to-markdown/lib/util/check-bullet.js","webpack:///./node_modules/mdast-util-to-hast/lib/handlers/link.js","webpack:///./node_modules/micromark/dist/util/move-point.js"],"names":["module","exports","character","inConstruct","after","atBreak","before","asciiAlpha","asciiAlphanumeric","asciiAtext","asciiControl","autolink","name","tokenize","tokenizeAutolink","effects","ok","nok","size","start","code","enter","consume","exit","open","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","end","emailAtSignOrDot","emailLabel","type","emailValue","normalizeIdentifier","value","replace","toLowerCase","toUpperCase","unicodePunctuationRegex","regexCheck","unicodePunctuation","repeat","streak","formatCodeAsIndented","checkFence","indentLines","safe","node","_","context","sequence","subexit","marker","raw","suffix","map","Math","max","lang","encode","meta","line","blank","flow","parent","child","children","results","index","length","push","handle","between","join","left","right","result","Number","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","chunkedSplice","factorySpace","headingAtx","tokenizeHeadingAtx","resolve","resolveHeadingAtx","events","content","text","contentEnd","contentStart","contentType","self","this","fenceOpenInside","interrupt","headingBreak","data","strong","all","h","normalize","Schema","DefinedInfo","create","definition","prop","info","space","mustUseProperty","attributes","props","properties","transform","property","normal","indexOf","attribute","wrap","u","nodes","loose","fromCharCode","String","serializeChunks","chunks","chunk","atTab","powers","increment","pow","boolean","booleanish","overloadedBoolean","number","spaceSeparated","commaSeparated","commaOrSpaceSeparated","toHast","visit","position","generated","definitions","one","footer","handlers","own","hasOwnProperty","deprecationWarningIssued","factory","tree","options","settings","undefined","allowDangerousHTML","console","warn","dangerous","allowDangerousHtml","footnoteById","footnoteOrder","augment","Object","assign","unknownHandler","passThrough","onfootnotedefinition","ctx","hName","tagName","hProperties","hChildren","id","identifier","call","foot","concat","blockquote","break","emphasis","hardBreak","heading","html","image","imageReference","inlineCode","link","linkReference","list","listItem","paragraph","root","thematicBreak","patternCompile","patternInScope","input","config","pattern","expression","match","positions","infos","unsafe","stack","exec","sort","numerical","escapeBackslashes","slice","test","charAt","charCodeAt","toString","a","b","whole","Info","find","valid","dash","cap","schema","Type","datasetToProperty","datasetToAttribute","camelcase","kebab","$0","className","peek","imagePeek","checkQuote","quote","alt","url","title","chunkedPush","items","factoryDestination","factoryLabel","factoryWhitespace","factoryTitle","tokenizeDefinition","titleConstruct","tokenizeTitle","partial","labelAfter","sliceSerialize","attempt","parser","defined","merge","xlink","xml","xmlns","aria","svg","values","labelEnd","labelStartLink","tokenizeLabelStartLink","resolveAll","constructs","called","shallow","setextUnderline","tokenizeSetextUnderline","resolveTo","resolveToSetextUnderline","splice","lazy","closingSequence","closingSequenceEnd","src","htmlBlockNames","htmlRawNames","partialBlankLine","htmlFlow","tokenizeHtmlFlow","resolveToHtmlFlow","concrete","nextBlankConstruct","tokenizeNextBlank","kind","startTag","buffer","declarationStart","tagCloseStart","continuationDeclarationInside","commentOpenInside","cdataOpenInside","continuation","basicSelfClosing","completeAttributeNameBefore","completeClosingTagAfter","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCharacterDataInside","continuationAtLineEnding","check","htmlContinueStart","done","continuationRawEndTag","raws","longestStreak","expected","count","maximum","Error","defineProperty","initializeFlow","initial","atBlankEnding","flowInitial","afterConstruct","currentConstruct","subtokenize","event","lineIndex","otherIndex","otherEvent","parameters","subevents","more","jumps","_tokenizer","isInFirstContentOfListItem","subcontent","_container","_movePreviousLineEndings","unshift","eventIndex","stream","previous","entered","adjust","token","startPosition","startPositions","tokenizer","childEvents","gaps","sliceStream","next","defineSkip","_gfmTasklistFirstContentOfListItem","write","add","pop","prefixSize","codeIndented","tokenizeCodeIndented","resolveCodeIndented","indentedContentConstruct","tokenizeIndentedContent","afterPrefix","checkListItemIndent","style","listItemIndent","joinDefaults","formatHeadingAsSetext","Boolean","ordered","spread","tokenizeLabelEnd","resolveToLabelEnd","resolveAllLabelEnd","resourceConstruct","tokenizeResource","fullReferenceConstruct","tokenizeFullReference","collapsedReferenceConstruct","tokenizeCollapsedReference","_used","group","label","close","media","offset","_inactive","_balanced","insideSpan","null","labelStart","balanced","now","afterLabelEnd","destinationAfter","afterLabel","strongPeek","checkStrong","phrasing","sizeChunks","tail","codeFenced","tokenizeCodeFenced","closingFenceConstruct","tokenizeClosingFence","initialPrefix","sizeOpen","sequenceOpen","infoOpen","openAfter","infoAfter","contentContinue","closingSequenceStart","disable","asciiHexDigit","types","caseInsensitiveTransform","acceptcharset","classname","htmlfor","httpequiv","abbr","accept","acceptCharset","accessKey","action","allow","allowFullScreen","allowPaymentRequest","allowUserMedia","as","async","autoCapitalize","autoComplete","autoFocus","autoPlay","capture","charSet","checked","cite","cols","colSpan","contentEditable","controls","controlsList","coords","crossOrigin","dateTime","decoding","default","defer","dir","dirName","disabled","download","draggable","encType","enterKeyHint","form","formAction","formEncType","formMethod","formNoValidate","formTarget","headers","height","hidden","high","href","hrefLang","htmlFor","httpEquiv","imageSizes","imageSrcSet","inputMode","integrity","is","isMap","itemId","itemProp","itemRef","itemScope","itemType","language","loading","loop","low","manifest","maxLength","method","min","minLength","multiple","muted","nonce","noModule","noValidate","onAbort","onAfterPrint","onAuxClick","onBeforePrint","onBeforeUnload","onBlur","onCancel","onCanPlay","onCanPlayThrough","onChange","onClick","onClose","onContextMenu","onCopy","onCueChange","onCut","onDblClick","onDrag","onDragEnd","onDragEnter","onDragExit","onDragLeave","onDragOver","onDragStart","onDrop","onDurationChange","onEmptied","onEnded","onError","onFocus","onFormData","onHashChange","onInput","onInvalid","onKeyDown","onKeyPress","onKeyUp","onLanguageChange","onLoad","onLoadedData","onLoadedMetadata","onLoadEnd","onLoadStart","onMessage","onMessageError","onMouseDown","onMouseEnter","onMouseLeave","onMouseMove","onMouseOut","onMouseOver","onMouseUp","onOffline","onOnline","onPageHide","onPageShow","onPaste","onPause","onPlay","onPlaying","onPopState","onProgress","onRateChange","onRejectionHandled","onReset","onResize","onScroll","onSecurityPolicyViolation","onSeeked","onSeeking","onSelect","onSlotChange","onStalled","onStorage","onSubmit","onSuspend","onTimeUpdate","onToggle","onUnhandledRejection","onUnload","onVolumeChange","onWaiting","onWheel","optimum","ping","placeholder","playsInline","poster","preload","readOnly","referrerPolicy","rel","required","reversed","rows","rowSpan","sandbox","scope","scoped","seamless","selected","shape","sizes","slot","span","spellCheck","srcDoc","srcLang","srcSet","step","tabIndex","target","translate","typeMustMatch","useMap","width","align","aLink","archive","axis","background","bgColor","border","borderColor","bottomMargin","cellPadding","cellSpacing","char","charOff","classId","clear","codeBase","codeType","color","compact","declare","face","frame","frameBorder","hSpace","leftMargin","longDesc","lowSrc","marginHeight","marginWidth","noResize","noHref","noShade","noWrap","object","profile","prompt","rev","rightMargin","rules","scheme","scrolling","standby","summary","topMargin","valueType","version","vAlign","vLink","vSpace","allowTransparency","autoCorrect","autoSave","disablePictureInPicture","disableRemotePlayback","prefix","security","unselectable","cache","res","str","num","TypeError","substr","text$1","attention","blockQuote","characterEscape","characterReference","codeText","hardBreakEscape","htmlText","labelStartImage","lineEnding","document","42","43","45","48","49","50","51","52","53","54","55","56","57","62","contentInitial","91","32","35","60","61","95","96","126","string","38","92","33","93","resolver","table","pos","row","out","cell","alignLength","basics","linkPeek","formatLinkAsAutolink","checkBullet","bullet","incrementListMarker","ceil","fences","checkRule","rule","resourceLink","listInScope","notInConstruct","none","asciiPunctuation","tokenizeCharacterEscape","configure","base","extension","key","extensions","generateFootnotes","def","backReference","listItems","proto","prototype","tokenizePartialBlankLine","afterWhitespace","setext","depth","remove","chunkStart","Array","from","apply","head","revert","contents","subtype","referenceType","el","semicolon","decodeEntity","characters","entity","createElement","innerHTML","textContent","unified","parse","stringify","use","freeze","initializeDocument","containerConstruct","tokenizeContainer","lazyFlowConstruct","tokenizeLazyFlow","inspectResult","childFlow","childToken","continued","inspectConstruct","tokenizeInspect","containerState","documentContinue","documentContinued","flowContinue","flowStart","interruptible","containerContinue","exitContainers","continueFlow","documentAfterPeek","flowEnd","subcontinued","inspectStart","inspectContinue","inspectLess","inspectDone","inspectFlowEnd","_closeFlow","inspectLazy","toMarkdown","compile","Compiler","ignore","delete","footnoteReference","footnote","toml","yaml","footnoteDefinition","safeFromInt","parseInt","emphasisPeek","checkEmphasis","ariaTransform","ariaActiveDescendant","ariaAtomic","ariaAutoComplete","ariaBusy","ariaChecked","ariaColCount","ariaColIndex","ariaColSpan","ariaControls","ariaCurrent","ariaDescribedBy","ariaDetails","ariaDisabled","ariaDropEffect","ariaErrorMessage","ariaExpanded","ariaFlowTo","ariaGrabbed","ariaHasPopup","ariaHidden","ariaInvalid","ariaKeyShortcuts","ariaLabel","ariaLabelledBy","ariaLevel","ariaLive","ariaModal","ariaMultiLine","ariaMultiSelectable","ariaOrientation","ariaOwns","ariaPlaceholder","ariaPosInSet","ariaPressed","ariaReadOnly","ariaRelevant","ariaRequired","ariaRoleDescription","ariaRowCount","ariaRowIndex","ariaRowSpan","ariaSelected","ariaSetSize","ariaSort","ariaValueMax","ariaValueMin","ariaValueNow","ariaValueText","role","listLoose","listItemLoose","wrapped","htmlPeek","classifyCharacter","movePoint","tokenizeAttention","resolveAllAttention","openingSequence","nextEvents","_close","_open","xmlnsxlink","xmlnsXLink","eol","xlinkTransform","xLinkActuate","xLinkArcRole","xLinkHref","xLinkRole","xLinkShow","xLinkTitle","xLinkType","xmlTransform","xmlLang","xmlBase","xmlSpace","tokenizeLineEnding","fromMarkdown","doc","mdastExtensions","Parser","unicodeWhitespace","zwitch","defaultHandlers","defaultJoin","defaultUnsafe","tightDefinitions","joinDefinition","invalid","unknown","inlineCodePeek","RegExp","tokenizeHardBreakEscape","destinationFactory","literalType","literalMarkerType","rawType","stringType","limit","Infinity","balance","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","fence","repetition","ruleRepetition","fn","returnNode","clone","tokenizeBlockQuoteStart","tokenizeBlockQuoteContinuation","labelFactory","markerType","labelEscape","asciiDigit","association","decode","decodeIfPossible","$1","miniflat","combineExtensions","hook","existing","search","preprocess","atCarriageReturn","column","preprocessor","encoding","endPosition","lastIndex","checks","checksLength","mask","mark","tokenizeContent","resolveContent","continuationConstruct","tokenizeContinuation","startLookahead","prefixed","regex","safeOptions","imageReferencePeek","reference","caseSensitiveTransform","toHtml","sanitize","plugin","clean","compiler","file","hast","extname","postprocess","stringifyPosition","transforms","canContainEols","opener","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","hardBreakTrailing","htmlFlowData","htmlTextData","listItemValue","onenterlistitemvalue","listOrdered","onenterlistordered","listUnordered","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","closer","atxHeadingSequence","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","characterEscapeValue","onexitdata","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","onexitcharacterreferencevalue","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","resource","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","handler","listStart","tokenStack","listStack","resume","setData","getData","prepareList","point","tailIndex","tailEvent","firstBlankLineIndex","atMarker","containerBalance","listSpread","_spread","d","and","siblings","fragment","encodeCache","getEncodeCache","exclude","i","ch","keepEscaped","l","nextCode","defaultChars","encodeURIComponent","componentChars","spaceFactory","accentHeight","alignmentBaseline","arabicForm","baselineShift","capHeight","clipPath","clipRule","colorInterpolation","colorInterpolationFilters","colorProfile","colorRendering","dataType","dominantBaseline","enableBackground","fillOpacity","fillRule","floodColor","floodOpacity","fontFamily","fontSize","fontSizeAdjust","fontStretch","fontStyle","fontVariant","fontWeight","glyphName","glyphOrientationHorizontal","glyphOrientationVertical","horizAdvX","horizOriginX","horizOriginY","imageRendering","letterSpacing","lightingColor","markerEnd","markerMid","markerStart","navDown","navDownLeft","navDownRight","navLeft","navNext","navPrev","navRight","navUp","navUpLeft","navUpRight","onActivate","onBegin","onEnd","onFocusIn","onFocusOut","onMouseWheel","onRepeat","onShow","onZoom","overlinePosition","overlineThickness","paintOrder","panose1","pointerEvents","renderingIntent","shapeRendering","stopColor","stopOpacity","strikethroughPosition","strikethroughThickness","strokeDashArray","strokeDashOffset","strokeLineCap","strokeLineJoin","strokeMiterLimit","strokeOpacity","strokeWidth","textAnchor","textDecoration","textRendering","typeOf","underlinePosition","underlineThickness","unicodeBidi","unicodeRange","unitsPerEm","vAlphabetic","vHanging","vIdeographic","vMathematical","vectorEffect","vertAdvY","vertOriginX","vertOriginY","wordSpacing","writingMode","xHeight","playbackOrder","timelineBegin","about","accumulate","additive","alphabetic","amplitude","ascent","attributeName","attributeType","azimuth","bandwidth","baseFrequency","baseProfile","bbox","begin","bias","by","calcMode","clip","clipPathUnits","contentScriptType","contentStyleType","cursor","cx","cy","defaultAction","descent","diffuseConstant","direction","display","dur","divisor","dx","dy","edgeMode","editable","elevation","exponent","externalResourcesRequired","fill","filter","filterRes","filterUnits","focusable","focusHighlight","format","fr","fx","fy","g1","g2","glyphRef","gradientTransform","gradientUnits","hanging","hatchContentUnits","hatchUnits","ideographic","initialVisibility","in","in2","intercept","k","k1","k2","k3","k4","kernelMatrix","kernelUnitLength","keyPoints","keySplines","keyTimes","kerning","lengthAdjust","limitingConeAngle","local","markerHeight","markerUnits","markerWidth","maskContentUnits","maskUnits","mathematical","mediaCharacterEncoding","mediaContentEncodings","mediaSize","mediaTime","mode","numOctaves","observer","opacity","operator","order","orient","orientation","origin","overflow","overlay","path","pathLength","patternContentUnits","patternTransform","patternUnits","phase","pitch","points","pointsAtX","pointsAtY","pointsAtZ","preserveAlpha","preserveAspectRatio","primitiveUnits","propagate","r","radius","refX","refY","repeatCount","repeatDur","requiredExtensions","requiredFeatures","requiredFonts","requiredFormats","restart","rotate","rx","ry","scale","seed","side","slope","snapshotTime","specularConstant","specularExponent","spreadMethod","spacing","startOffset","stdDeviation","stemh","stemv","stitchTiles","stroke","surfaceScale","syncBehavior","syncBehaviorDefault","syncMaster","syncTolerance","syncToleranceDefault","systemLanguage","tableValues","targetX","targetY","textLength","transformBehavior","to","u1","u2","unicode","viewBox","viewTarget","visibility","widths","x","x1","x2","xChannelSelector","y","y1","y2","yChannelSelector","z","zoomAndPan","linkReferencePeek","xtend","createTokenizer","initializer","creator","initializeContent","afterContentStartConstruct","paragraphInitial","lineStart","whitespaceFactory","seen","sliceChunks","view","startIndex","_index","startBufferIndex","_bufferIndex","endIndex","endBufferIndex","getDefinitionFactory","getterFactory","gather","ondefinition","normalise","getter","tokenizeHtmlText","returnState","declarationOpen","instruction","tagOpen","commentOpen","cdataOpen","declaration","commentStart","commentStartDash","comment","commentClose","atLineEnding","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","tokenizeThematicBreak","_interopDefaultLegacy","e","decodeEntity__default","tokenizeCharacterReference","numeric","tokenizeListStart","tokenizeListContinuation","tokenizeListEnd","listItemPrefixWhitespaceConstruct","tokenizeListItemPrefixWhitespace","indentConstruct","tokenizeIndent","initialSize","inside","onBlank","endOfPrefix","otherPrefix","initialBlankLine","notBlank","furtherBlankLines","notInCurrentItem","initialize","columnStart","resolveAllConstructs","constructFactory","onsuccessfulconstruct","onsuccessfulcheck","skip","state","main","addResult","accountForPotentialSkip","chunkIndex","go","fields","construct","restore","onreturn","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","handleMapOfConstructs","handleConstruct","store","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","rank","lastIndexOf","closeAtx","_compiled","tokenizeLabelStartImage","titleFactory","atFirstTitleBreak","atTitleBreak","titleEscape","initializeFactory","createResolver","field","initializeText","resolveAllLineSuffixes","notText","extraResolver","resolveAllText","bufferIndex","tabs","checkRepeat","ruleSpaces","strikethrough","tokenizeCodeText","resolveCodeText","tailExitIndex","headEnterIndex","gap"],"mappings":"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","file":"static/js/about~690b702c.e55560c9.js","sourcesContent":["module.exports = [\n  {\n    character: '\\t',\n    inConstruct: ['codeFencedLangGraveAccent', 'codeFencedLangTilde']\n  },\n  {\n    character: '\\r',\n    inConstruct: [\n      'codeFencedLangGraveAccent',\n      'codeFencedLangTilde',\n      'codeFencedMetaGraveAccent',\n      'codeFencedMetaTilde',\n      'destinationLiteral',\n      'headingAtx'\n    ]\n  },\n  {\n    character: '\\n',\n    inConstruct: [\n      'codeFencedLangGraveAccent',\n      'codeFencedLangTilde',\n      'codeFencedMetaGraveAccent',\n      'codeFencedMetaTilde',\n      'destinationLiteral',\n      'headingAtx'\n    ]\n  },\n  {\n    character: ' ',\n    inConstruct: ['codeFencedLangGraveAccent', 'codeFencedLangTilde']\n  },\n  // An exclamation mark can start an image, if it is followed by a link or\n  // a link reference.\n  {character: '!', after: '\\\\[', inConstruct: 'phrasing'},\n  // A quote can break out of a title.\n  {character: '\"', inConstruct: 'titleQuote'},\n  // A number sign could start an ATX heading if it starts a line.\n  {atBreak: true, character: '#'},\n  {character: '#', inConstruct: 'headingAtx', after: '(?:[\\r\\n]|$)'},\n  // Dollar sign and percentage are not used in markdown.\n  // An ampersand could start a character reference.\n  {character: '&', after: '[#A-Za-z]', inConstruct: 'phrasing'},\n  // An apostrophe can break out of a title.\n  {character: \"'\", inConstruct: 'titleApostrophe'},\n  // A left paren could break out of a destination raw.\n  {character: '(', inConstruct: 'destinationRaw'},\n  {before: '\\\\]', character: '(', inConstruct: 'phrasing'},\n  // A right paren could start a list item or break out of a destination\n  // raw.\n  {atBreak: true, before: '\\\\d+', character: ')'},\n  {character: ')', inConstruct: 'destinationRaw'},\n  // An asterisk can start thematic breaks, list items, emphasis, strong.\n  {atBreak: true, character: '*'},\n  {character: '*', inConstruct: 'phrasing'},\n  // A plus sign could start a list item.\n  {atBreak: true, character: '+'},\n  // A dash can start thematic breaks, list items, and setext heading\n  // underlines.\n  {atBreak: true, character: '-'},\n  // A dot could start a list item.\n  {atBreak: true, before: '\\\\d+', character: '.', after: '(?:[ \\t\\r\\n]|$)'},\n  // Slash, colon, and semicolon are not used in markdown for constructs.\n  // A less than can start html (flow or text) or an autolink.\n  // HTML could start with an exclamation mark (declaration, cdata, comment),\n  // slash (closing tag), question mark (instruction), or a letter (tag).\n  // An autolink also starts with a letter.\n  // Finally, it could break out of a destination literal.\n  {atBreak: true, character: '<', after: '[!/?A-Za-z]'},\n  {character: '<', after: '[!/?A-Za-z]', inConstruct: 'phrasing'},\n  {character: '<', inConstruct: 'destinationLiteral'},\n  // An equals to can start setext heading underlines.\n  {atBreak: true, character: '='},\n  // A greater than can start block quotes and it can break out of a\n  // destination literal.\n  {atBreak: true, character: '>'},\n  {character: '>', inConstruct: 'destinationLiteral'},\n  // Question mark and at sign are not used in markdown for constructs.\n  // A left bracket can start definitions, references, labels,\n  {atBreak: true, character: '['},\n  {character: '[', inConstruct: ['phrasing', 'label', 'reference']},\n  // A backslash can start an escape (when followed by punctuation) or a\n  // hard break (when followed by an eol).\n  // Note: typical escapes are handled in `safe`!\n  {character: '\\\\', after: '[\\\\r\\\\n]', inConstruct: 'phrasing'},\n  // A right bracket can exit labels.\n  {\n    character: ']',\n    inConstruct: ['label', 'reference']\n  },\n  // Caret is not used in markdown for constructs.\n  // An underscore can start emphasis, strong, or a thematic break.\n  {atBreak: true, character: '_'},\n  {before: '[^A-Za-z]', character: '_', inConstruct: 'phrasing'},\n  {character: '_', after: '[^A-Za-z]', inConstruct: 'phrasing'},\n  // A grave accent can start code (fenced or text), or it can break out of\n  // a grave accent code fence.\n  {atBreak: true, character: '`'},\n  {\n    character: '`',\n    inConstruct: [\n      'codeFencedLangGraveAccent',\n      'codeFencedMetaGraveAccent',\n      'phrasing'\n    ]\n  },\n  // Left brace, vertical bar, right brace are not used in markdown for\n  // constructs.\n  // A tilde can start code (fenced).\n  {atBreak: true, character: '~'}\n]\n","'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')\n\nvar autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n}\n\nfunction tokenizeAutolink(effects, ok, nok) {\n  var size = 1\n  return start\n\n  function start(code) {\n    effects.enter('autolink')\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.enter('autolinkProtocol')\n    return open\n  }\n\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return schemeOrEmailAtext\n    }\n\n    return asciiAtext(code) ? emailAtext(code) : nok(code)\n  }\n\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)\n      ? schemeInsideOrEmailAtext(code)\n      : emailAtext(code)\n  }\n\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code)\n      return urlInside\n    }\n\n    if (\n      (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&\n      size++ < 32\n    ) {\n      effects.consume(code)\n      return schemeInsideOrEmailAtext\n    }\n\n    return emailAtext(code)\n  }\n\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol')\n      return end(code)\n    }\n\n    if (code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return urlInside\n  }\n\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n\n    if (asciiAtext(code)) {\n      effects.consume(code)\n      return emailAtext\n    }\n\n    return nok(code)\n  }\n\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)\n  }\n\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail'\n      return end(code)\n    }\n\n    return emailValue(code)\n  }\n\n  function emailValue(code) {\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      effects.consume(code)\n      return code === 45 ? emailValue : emailLabel\n    }\n\n    return nok(code)\n  }\n\n  function end(code) {\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.exit('autolink')\n    return ok\n  }\n}\n\nmodule.exports = autolink\n","'use strict'\n\nfunction normalizeIdentifier(value) {\n  return (\n    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()\n      .toUpperCase()\n  )\n}\n\nmodule.exports = normalizeIdentifier\n","'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)\n\nmodule.exports = unicodePunctuation\n","module.exports = code\n\nvar repeat = require('repeat-string')\nvar streak = require('longest-streak')\nvar formatCodeAsIndented = require('../util/format-code-as-indented')\nvar checkFence = require('../util/check-fence')\nvar indentLines = require('../util/indent-lines')\nvar safe = require('../util/safe')\n\nfunction code(node, _, context) {\n  var marker = checkFence(context)\n  var raw = node.value || ''\n  var suffix = marker === '`' ? 'GraveAccent' : 'Tilde'\n  var value\n  var sequence\n  var exit\n  var subexit\n\n  if (formatCodeAsIndented(node, context)) {\n    exit = context.enter('codeIndented')\n    value = indentLines(raw, map)\n  } else {\n    sequence = repeat(marker, Math.max(streak(raw, marker) + 1, 3))\n    exit = context.enter('codeFenced')\n    value = sequence\n\n    if (node.lang) {\n      subexit = context.enter('codeFencedLang' + suffix)\n      value += safe(context, node.lang, {\n        before: '`',\n        after: ' ',\n        encode: ['`']\n      })\n      subexit()\n    }\n\n    if (node.lang && node.meta) {\n      subexit = context.enter('codeFencedMeta' + suffix)\n      value +=\n        ' ' +\n        safe(context, node.meta, {\n          before: ' ',\n          after: '\\n',\n          encode: ['`']\n        })\n      subexit()\n    }\n\n    value += '\\n'\n\n    if (raw) {\n      value += raw + '\\n'\n    }\n\n    value += sequence\n  }\n\n  exit()\n  return value\n}\n\nfunction map(line, _, blank) {\n  return (blank ? '' : '    ') + line\n}\n","module.exports = flow\n\nvar repeat = require('repeat-string')\n\nfunction flow(parent, context) {\n  var children = parent.children || []\n  var results = []\n  var index = -1\n  var child\n\n  while (++index < children.length) {\n    child = children[index]\n\n    results.push(\n      context.handle(child, parent, context, {before: '\\n', after: '\\n'})\n    )\n\n    if (index + 1 < children.length) {\n      results.push(between(child, children[index + 1]))\n    }\n  }\n\n  return results.join('')\n\n  function between(left, right) {\n    var index = -1\n    var result\n\n    while (++index < context.join.length) {\n      result = context.join[index](left, right, parent, context)\n\n      if (result === true || result === 1) {\n        break\n      }\n\n      if (typeof result === 'number') {\n        return repeat('\\n', 1 + Number(result))\n      }\n\n      if (result === false) {\n        return '\\n\\n<!---->\\n\\n'\n      }\n    }\n\n    return '\\n\\n'\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 markdownSpace = require('../character/markdown-space.js')\nvar chunkedSplice = require('../util/chunked-splice.js')\nvar factorySpace = require('./factory-space.js')\n\nvar headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n}\n\nfunction resolveHeadingAtx(events, context) {\n  var contentEnd = events.length - 2\n  var contentStart = 3\n  var content\n  var text // Prefix whitespace, part of the opening.\n\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2\n  } // Suffix whitespace, part of the closing.\n\n  if (\n    contentEnd - 2 > contentStart &&\n    events[contentEnd][1].type === 'whitespace'\n  ) {\n    contentEnd -= 2\n  }\n\n  if (\n    events[contentEnd][1].type === 'atxHeadingSequence' &&\n    (contentStart === contentEnd - 1 ||\n      (contentEnd - 4 > contentStart &&\n        events[contentEnd - 2][1].type === 'whitespace'))\n  ) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4\n  }\n\n  if (contentEnd > contentStart) {\n    content = {\n      type: 'atxHeadingText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    }\n    text = {\n      type: 'chunkText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      contentType: 'text'\n    }\n    chunkedSplice(events, contentStart, contentEnd - contentStart + 1, [\n      ['enter', content, context],\n      ['enter', text, context],\n      ['exit', text, context],\n      ['exit', content, context]\n    ])\n  }\n\n  return events\n}\n\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  var self = this\n  var size = 0\n  return start\n\n  function start(code) {\n    effects.enter('atxHeading')\n    effects.enter('atxHeadingSequence')\n    return fenceOpenInside(code)\n  }\n\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code)\n      return fenceOpenInside\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence')\n      return self.interrupt ? ok(code) : headingBreak(code)\n    }\n\n    return nok(code)\n  }\n\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence')\n      return sequence(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading')\n      return ok(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code)\n    }\n\n    effects.enter('atxHeadingText')\n    return data(code)\n  }\n\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code)\n      return sequence\n    }\n\n    effects.exit('atxHeadingSequence')\n    return headingBreak(code)\n  }\n\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText')\n      return headingBreak(code)\n    }\n\n    effects.consume(code)\n    return data\n  }\n}\n\nmodule.exports = headingAtx\n","'use strict'\n\nmodule.exports = strong\n\nvar all = require('../all')\n\nfunction strong(h, node) {\n  return h(node, 'strong', all(h, node))\n}\n","'use strict'\n\nvar normalize = require('../../normalize')\nvar Schema = require('./schema')\nvar DefinedInfo = require('./defined-info')\n\nmodule.exports = create\n\nfunction create(definition) {\n  var space = definition.space\n  var mustUseProperty = definition.mustUseProperty || []\n  var attributes = definition.attributes || {}\n  var props = definition.properties\n  var transform = definition.transform\n  var property = {}\n  var normal = {}\n  var prop\n  var info\n\n  for (prop in props) {\n    info = new DefinedInfo(\n      prop,\n      transform(attributes, prop),\n      props[prop],\n      space\n    )\n\n    if (mustUseProperty.indexOf(prop) !== -1) {\n      info.mustUseProperty = true\n    }\n\n    property[prop] = info\n\n    normal[normalize(prop)] = prop\n    normal[normalize(info.attribute)] = prop\n  }\n\n  return new Schema(property, normal, space)\n}\n","'use strict'\n\nmodule.exports = wrap\n\nvar u = require('unist-builder')\n\n// Wrap `nodes` with line feeds between each entry.\n// Optionally adds line feeds at the start and end.\nfunction wrap(nodes, loose) {\n  var result = []\n  var index = -1\n  var length = nodes.length\n\n  if (loose) {\n    result.push(u('text', '\\n'))\n  }\n\n  while (++index < length) {\n    if (index) {\n      result.push(u('text', '\\n'))\n    }\n\n    result.push(nodes[index])\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push(u('text', '\\n'))\n  }\n\n  return result\n}\n","'use strict'\n\nvar fromCharCode = String.fromCharCode\n\nmodule.exports = fromCharCode\n","'use strict'\n\nfunction markdownLineEnding(code) {\n  return code < -2\n}\n\nmodule.exports = markdownLineEnding\n","'use strict'\n\nvar fromCharCode = require('../constant/from-char-code.js')\n\nfunction serializeChunks(chunks) {\n  var index = -1\n  var result = []\n  var chunk\n  var value\n  var atTab\n\n  while (++index < chunks.length) {\n    chunk = chunks[index]\n\n    if (typeof chunk === 'string') {\n      value = chunk\n    } else if (chunk === -5) {\n      value = '\\r'\n    } else if (chunk === -4) {\n      value = '\\n'\n    } else if (chunk === -3) {\n      value = '\\r' + '\\n'\n    } else if (chunk === -2) {\n      value = '\\t'\n    } else if (chunk === -1) {\n      if (atTab) continue\n      value = ' '\n    } else {\n      // Currently only replacement character.\n      value = fromCharCode(chunk)\n    }\n\n    atTab = chunk === -2\n    result.push(value)\n  }\n\n  return result.join('')\n}\n\nmodule.exports = serializeChunks\n","'use strict'\n\nvar powers = 0\n\nexports.boolean = increment()\nexports.booleanish = increment()\nexports.overloadedBoolean = increment()\nexports.number = increment()\nexports.spaceSeparated = increment()\nexports.commaSeparated = increment()\nexports.commaOrSpaceSeparated = increment()\n\nfunction increment() {\n  return Math.pow(2, ++powers)\n}\n","'use strict'\n\nmodule.exports = toHast\n\nvar u = require('unist-builder')\nvar visit = require('unist-util-visit')\nvar position = require('unist-util-position')\nvar generated = require('unist-util-generated')\nvar definitions = require('mdast-util-definitions')\nvar one = require('./one')\nvar footer = require('./footer')\nvar handlers = require('./handlers')\n\nvar own = {}.hasOwnProperty\n\nvar deprecationWarningIssued = false\n\n// Factory to transform.\nfunction factory(tree, options) {\n  var settings = options || {}\n\n  // Issue a warning if the deprecated tag 'allowDangerousHTML' is used\n  if (settings.allowDangerousHTML !== undefined && !deprecationWarningIssued) {\n    deprecationWarningIssued = true\n    console.warn(\n      'mdast-util-to-hast: deprecation: `allowDangerousHTML` is nonstandard, use `allowDangerousHtml` instead'\n    )\n  }\n\n  var dangerous = settings.allowDangerousHtml || settings.allowDangerousHTML\n  var footnoteById = {}\n\n  h.dangerous = dangerous\n  h.definition = definitions(tree)\n  h.footnoteById = footnoteById\n  h.footnoteOrder = []\n  h.augment = augment\n  h.handlers = Object.assign({}, handlers, settings.handlers)\n  h.unknownHandler = settings.unknownHandler\n  h.passThrough = settings.passThrough\n\n  visit(tree, 'footnoteDefinition', onfootnotedefinition)\n\n  return h\n\n  // Finalise the created `right`, a hast node, from `left`, an mdast node.\n  function augment(left, right) {\n    var data\n    var ctx\n\n    // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n    if (left && left.data) {\n      data = left.data\n\n      if (data.hName) {\n        if (right.type !== 'element') {\n          right = {\n            type: 'element',\n            tagName: '',\n            properties: {},\n            children: []\n          }\n        }\n\n        right.tagName = data.hName\n      }\n\n      if (right.type === 'element' && data.hProperties) {\n        right.properties = Object.assign({}, right.properties, data.hProperties)\n      }\n\n      if (right.children && data.hChildren) {\n        right.children = data.hChildren\n      }\n    }\n\n    ctx = left && left.position ? left : {position: left}\n\n    if (!generated(ctx)) {\n      right.position = {\n        start: position.start(ctx),\n        end: position.end(ctx)\n      }\n    }\n\n    return right\n  }\n\n  // Create an element for `node`.\n  function h(node, tagName, props, children) {\n    if (\n      (children === undefined || children === null) &&\n      typeof props === 'object' &&\n      'length' in props\n    ) {\n      children = props\n      props = {}\n    }\n\n    return augment(node, {\n      type: 'element',\n      tagName: tagName,\n      properties: props || {},\n      children: children || []\n    })\n  }\n\n  function onfootnotedefinition(definition) {\n    var id = String(definition.identifier).toUpperCase()\n\n    // Mimick CM behavior of link definitions.\n    // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/8290999/index.js#L26>.\n    if (!own.call(footnoteById, id)) {\n      footnoteById[id] = definition\n    }\n  }\n}\n\n// Transform `tree`, which is an mdast node, to a hast node.\nfunction toHast(tree, options) {\n  var h = factory(tree, options)\n  var node = one(h, tree)\n  var foot = footer(h)\n\n  if (foot) {\n    node.children = node.children.concat(u('text', '\\n'), foot)\n  }\n\n  return node\n}\n","exports.blockquote = require('./blockquote')\nexports.break = require('./break')\nexports.code = require('./code')\nexports.definition = require('./definition')\nexports.emphasis = require('./emphasis')\nexports.hardBreak = require('./break')\nexports.heading = require('./heading')\nexports.html = require('./html')\nexports.image = require('./image')\nexports.imageReference = require('./image-reference')\nexports.inlineCode = require('./inline-code')\nexports.link = require('./link')\nexports.linkReference = require('./link-reference')\nexports.list = require('./list')\nexports.listItem = require('./list-item')\nexports.paragraph = require('./paragraph')\nexports.root = require('./root')\nexports.strong = require('./strong')\nexports.text = require('./text')\nexports.thematicBreak = require('./thematic-break')\n","module.exports = safe\n\nvar patternCompile = require('./pattern-compile')\nvar patternInScope = require('./pattern-in-scope')\n\nfunction safe(context, input, config) {\n  var value = (config.before || '') + (input || '') + (config.after || '')\n  var positions = []\n  var result = []\n  var infos = {}\n  var index = -1\n  var before\n  var after\n  var position\n  var pattern\n  var expression\n  var match\n  var start\n  var end\n\n  while (++index < context.unsafe.length) {\n    pattern = context.unsafe[index]\n\n    if (!patternInScope(context.stack, pattern)) {\n      continue\n    }\n\n    expression = patternCompile(pattern)\n\n    while ((match = expression.exec(value))) {\n      before = 'before' in pattern || pattern.atBreak\n      after = 'after' in pattern\n\n      position = match.index + (before ? match[1].length : 0)\n\n      if (positions.indexOf(position) === -1) {\n        positions.push(position)\n        infos[position] = {before: before, after: after}\n      } else {\n        if (infos[position].before && !before) {\n          infos[position].before = false\n        }\n\n        if (infos[position].after && !after) {\n          infos[position].after = false\n        }\n      }\n    }\n  }\n\n  positions.sort(numerical)\n\n  start = config.before ? config.before.length : 0\n  end = value.length - (config.after ? config.after.length : 0)\n  index = -1\n\n  while (++index < positions.length) {\n    position = positions[index]\n\n    if (\n      // Character before or after matched:\n      position < start ||\n      position >= end\n    ) {\n      continue\n    }\n\n    // If this character is supposed to be escaped because it has a condition on\n    // the next character, and the next character is definitly being escaped,\n    // then skip this escape.\n    if (\n      position + 1 < end &&\n      positions[index + 1] === position + 1 &&\n      infos[position].after &&\n      !infos[position + 1].before &&\n      !infos[position + 1].after\n    ) {\n      continue\n    }\n\n    if (start !== position) {\n      // If we have to use a character reference, an ampersand would be more\n      // correct, but as backslashes only care about punctuation, either will\n      // do the trick\n      result.push(escapeBackslashes(value.slice(start, position), '\\\\'))\n    }\n\n    start = position\n\n    if (\n      /[!-/:-@[-`{-~]/.test(value.charAt(position)) &&\n      (!config.encode || config.encode.indexOf(value.charAt(position)) === -1)\n    ) {\n      // Character escape.\n      result.push('\\\\')\n    } else {\n      // Character reference.\n      result.push(\n        '&#x' + value.charCodeAt(position).toString(16).toUpperCase() + ';'\n      )\n      start++\n    }\n  }\n\n  result.push(escapeBackslashes(value.slice(start, end), config.after))\n\n  return result.join('')\n}\n\nfunction numerical(a, b) {\n  return a - b\n}\n\nfunction escapeBackslashes(value, after) {\n  var expression = /\\\\(?=[!-/:-@[-`{-~])/g\n  var positions = []\n  var results = []\n  var index = -1\n  var start = 0\n  var whole = value + after\n  var match\n\n  while ((match = expression.exec(whole))) {\n    positions.push(match.index)\n  }\n\n  while (++index < positions.length) {\n    if (start !== positions[index]) {\n      results.push(value.slice(start, positions[index]))\n    }\n\n    results.push('\\\\')\n    start = positions[index]\n  }\n\n  results.push(value.slice(start))\n\n  return results.join('')\n}\n","'use strict'\n\nvar normalize = require('./normalize')\nvar DefinedInfo = require('./lib/util/defined-info')\nvar Info = require('./lib/util/info')\n\nvar data = 'data'\n\nmodule.exports = find\n\nvar valid = /^data[-\\w.:]+$/i\nvar dash = /-[a-z]/g\nvar cap = /[A-Z]/g\n\nfunction find(schema, value) {\n  var normal = normalize(value)\n  var prop = value\n  var Type = Info\n\n  if (normal in schema.normal) {\n    return schema.property[schema.normal[normal]]\n  }\n\n  if (normal.length > 4 && normal.slice(0, 4) === data && valid.test(value)) {\n    // Attribute or property.\n    if (value.charAt(4) === '-') {\n      prop = datasetToProperty(value)\n    } else {\n      value = datasetToAttribute(value)\n    }\n\n    Type = DefinedInfo\n  }\n\n  return new Type(prop, value)\n}\n\nfunction datasetToProperty(attribute) {\n  var value = attribute.slice(5).replace(dash, camelcase)\n  return data + value.charAt(0).toUpperCase() + value.slice(1)\n}\n\nfunction datasetToAttribute(property) {\n  var value = property.slice(4)\n\n  if (dash.test(value)) {\n    return property\n  }\n\n  value = value.replace(cap, kebab)\n\n  if (value.charAt(0) !== '-') {\n    value = '-' + value\n  }\n\n  return data + value\n}\n\nfunction kebab($0) {\n  return '-' + $0.toLowerCase()\n}\n\nfunction camelcase($0) {\n  return $0.charAt(1).toUpperCase()\n}\n","'use strict'\n\nmodule.exports = code\n\nvar u = require('unist-builder')\n\nfunction code(h, node) {\n  var value = node.value ? node.value + '\\n' : ''\n  // To do: next major, use `node.lang` w/o regex, the splitting’s been going\n  // on for years in remark now.\n  var lang = node.lang && node.lang.match(/^[^ \\t]+(?=[ \\t]|$)/)\n  var props = {}\n  var code\n\n  if (lang) {\n    props.className = ['language-' + lang]\n  }\n\n  code = h(node, 'code', props, [u('text', value)])\n\n  if (node.meta) {\n    code.data = {meta: node.meta}\n  }\n\n  return h(node.position, 'pre', [code])\n}\n","module.exports = image\nimage.peek = imagePeek\n\nvar checkQuote = require('../util/check-quote')\nvar safe = require('../util/safe')\n\nfunction image(node, _, context) {\n  var quote = checkQuote(context)\n  var suffix = quote === '\"' ? 'Quote' : 'Apostrophe'\n  var exit = context.enter('image')\n  var subexit = context.enter('label')\n  var value = '![' + safe(context, node.alt, {before: '[', after: ']'}) + ']('\n\n  subexit()\n\n  if (\n    // If there’s no url but there is a title…\n    (!node.url && node.title) ||\n    // Or if there’s markdown whitespace or an eol, enclose.\n    /[ \\t\\r\\n]/.test(node.url)\n  ) {\n    subexit = context.enter('destinationLiteral')\n    value += '<' + safe(context, node.url, {before: '<', after: '>'}) + '>'\n  } else {\n    // No whitespace, raw is prettier.\n    subexit = context.enter('destinationRaw')\n    value += safe(context, node.url, {\n      before: '(',\n      after: node.title ? ' ' : ')'\n    })\n  }\n\n  subexit()\n\n  if (node.title) {\n    subexit = context.enter('title' + suffix)\n    value +=\n      ' ' +\n      quote +\n      safe(context, node.title, {before: quote, after: quote}) +\n      quote\n    subexit()\n  }\n\n  value += ')'\n  exit()\n\n  return value\n}\n\nfunction imagePeek() {\n  return '!'\n}\n","'use strict'\n\nvar chunkedSplice = require('./chunked-splice.js')\n\nfunction chunkedPush(list, items) {\n  if (list.length) {\n    chunkedSplice(list, list.length, 0, items)\n    return list\n  }\n\n  return items\n}\n\nmodule.exports = chunkedPush\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')\n\nvar definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n}\nvar titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n}\n\nfunction tokenizeDefinition(effects, ok, nok) {\n  var self = this\n  var identifier\n  return start\n\n  function start(code) {\n    effects.enter('definition')\n    return factoryLabel.call(\n      self,\n      effects,\n      labelAfter,\n      nok,\n      'definitionLabel',\n      'definitionLabelMarker',\n      'definitionLabelString'\n    )(code)\n  }\n\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(\n      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n    )\n\n    if (code === 58) {\n      effects.enter('definitionMarker')\n      effects.consume(code)\n      effects.exit('definitionMarker') // Note: blank lines can’t exist in content.\n\n      return factoryWhitespace(\n        effects,\n        factoryDestination(\n          effects,\n          effects.attempt(\n            titleConstruct,\n            factorySpace(effects, after, 'whitespace'),\n            factorySpace(effects, after, 'whitespace')\n          ),\n          nok,\n          'definitionDestination',\n          'definitionDestinationLiteral',\n          'definitionDestinationLiteralMarker',\n          'definitionDestinationRaw',\n          'definitionDestinationString'\n        )\n      )\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition')\n\n      if (self.parser.defined.indexOf(identifier) < 0) {\n        self.parser.defined.push(identifier)\n      }\n\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n\nfunction tokenizeTitle(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, before)(code)\n      : nok(code)\n  }\n\n  function before(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factorySpace(effects, after, 'whitespace'),\n        nok,\n        'definitionTitle',\n        'definitionTitleMarker',\n        'definitionTitleString'\n      )(code)\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n\nmodule.exports = definition\n","'use strict'\n\nvar merge = require('./lib/util/merge')\nvar xlink = require('./lib/xlink')\nvar xml = require('./lib/xml')\nvar xmlns = require('./lib/xmlns')\nvar aria = require('./lib/aria')\nvar svg = require('./lib/svg')\n\nmodule.exports = merge([xml, xlink, xmlns, aria, svg])\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 (\n    (node &&\n      (node.value ||\n        node.alt ||\n        node.title ||\n        ('children' in node && all(node.children)) ||\n        ('length' in node && all(node)))) ||\n    ''\n  )\n}\n\nfunction all(values) {\n  var result = []\n  var index = -1\n\n  while (++index < values.length) {\n    result[index] = toString(values[index])\n  }\n\n  return result.join('')\n}\n","'use strict'\n\nvar labelEnd = require('./label-end.js')\n\nvar labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n}\n\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  var self = this\n  return start\n\n  function start(code) {\n    effects.enter('labelLink')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelLink')\n    return after\n  }\n\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 &&\n      /* c8 ignore next */\n      '_hiddenFootnoteSupport' in self.parser.constructs\n      ? /* c8 ignore next */\n        nok(code)\n      : ok(code)\n  }\n}\n\nmodule.exports = labelStartLink\n","'use strict'\n\nfunction resolveAll(constructs, events, context) {\n  var called = []\n  var index = -1\n  var resolve\n\n  while (++index < constructs.length) {\n    resolve = constructs[index].resolveAll\n\n    if (resolve && called.indexOf(resolve) < 0) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n\nmodule.exports = resolveAll\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar shallow = require('../util/shallow.js')\nvar factorySpace = require('./factory-space.js')\n\nvar setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n}\n\nfunction resolveToSetextUnderline(events, context) {\n  var index = events.length\n  var content\n  var text\n  var definition\n  var heading // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index\n        break\n      }\n\n      if (events[index][1].type === 'paragraph') {\n        text = index\n      }\n    } // Exit\n    else {\n      if (events[index][1].type === 'content') {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1)\n      }\n\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index\n      }\n    }\n  }\n\n  heading = {\n    type: 'setextHeading',\n    start: shallow(events[text][1].start),\n    end: shallow(events[events.length - 1][1].end)\n  } // Change the paragraph to setext heading text.\n\n  events[text][1].type = 'setextHeadingText' // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context])\n    events.splice(definition + 1, 0, ['exit', events[content][1], context])\n    events[content][1].end = shallow(events[definition][1].end)\n  } else {\n    events[content][1] = heading\n  } // Add the heading exit at the end.\n\n  events.push(['exit', heading, context])\n  return events\n}\n\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  var self = this\n  var index = self.events.length\n  var marker\n  var paragraph // Find an opening.\n\n  while (index--) {\n    // Skip enter/exit of line ending, line prefix, and content.\n    // We can now either have a definition or a paragraph.\n    if (\n      self.events[index][1].type !== 'lineEnding' &&\n      self.events[index][1].type !== 'linePrefix' &&\n      self.events[index][1].type !== 'content'\n    ) {\n      paragraph = self.events[index][1].type === 'paragraph'\n      break\n    }\n  }\n\n  return start\n\n  function start(code) {\n    if (!self.lazy && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine')\n      effects.enter('setextHeadingLineSequence')\n      marker = code\n      return closingSequence(code)\n    }\n\n    return nok(code)\n  }\n\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return closingSequence\n    }\n\n    effects.exit('setextHeadingLineSequence')\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code)\n  }\n\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = setextUnderline\n","'use strict'\n\nvar normalize = require('mdurl/encode')\n\nmodule.exports = image\n\nfunction image(h, node) {\n  var props = {src: normalize(node.url), alt: node.alt}\n\n  if (node.title !== null && node.title !== undefined) {\n    props.title = node.title\n  }\n\n  return h(node, 'img', props)\n}\n","'use strict'\n\nmodule.exports = text\n\nvar u = require('unist-builder')\n\nfunction text(h, node) {\n  return h.augment(\n    node,\n    u('text', String(node.value).replace(/[ \\t]*(\\r?\\n|\\r)[ \\t]*/g, '$1'))\n  )\n}\n","'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')\n\nvar htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n}\nvar nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n}\n\nfunction resolveToHtmlFlow(events) {\n  var index = events.length\n\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break\n    }\n  }\n\n  if (index > 1 && events[index - 2][1].type === 'linePrefix') {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start // Add the prefix start to the HTML line token.\n\n    events[index + 1][1].start = events[index - 2][1].start // Remove the line prefix.\n\n    events.splice(index - 2, 2)\n  }\n\n  return events\n}\n\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  var self = this\n  var kind\n  var startTag\n  var buffer\n  var index\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter('htmlFlow')\n    effects.enter('htmlFlowData')\n    effects.consume(code)\n    return open\n  }\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationStart\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      kind = 3 // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = fromCharCode(code)\n      startTag = true\n      return tagName\n    }\n\n    return nok(code)\n  }\n\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code)\n      kind = 2\n      return commentOpenInside\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      kind = 5\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpenInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      kind = 4\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n\n  function cdataOpenInside(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length\n        ? self.interrupt\n          ? ok\n          : continuation\n        : cdataOpenInside\n    }\n\n    return nok(code)\n  }\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n\n  function tagName(code) {\n    if (\n      code === null ||\n      code === 47 ||\n      code === 62 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      if (\n        code !== 47 &&\n        startTag &&\n        htmlRawNames.indexOf(buffer.toLowerCase()) > -1\n      ) {\n        kind = 1\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      if (htmlBlockNames.indexOf(buffer.toLowerCase()) > -1) {\n        kind = 6\n\n        if (code === 47) {\n          effects.consume(code)\n          return basicSelfClosing\n        }\n\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      kind = 7 // Do not support complete HTML when interrupting.\n\n      return self.interrupt\n        ? nok(code)\n        : startTag\n        ? completeAttributeNameBefore(code)\n        : completeClosingTagAfter(code)\n    }\n\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      buffer += fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuation\n    }\n\n    return nok(code)\n  }\n\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeClosingTagAfter\n    }\n\n    return completeEnd(code)\n  }\n\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return completeEnd\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameBefore\n    }\n\n    return completeEnd(code)\n  }\n\n  function completeAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    return completeAttributeNameAfter(code)\n  }\n\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameAfter\n    }\n\n    return completeAttributeNameBefore(code)\n  }\n\n  function completeAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return completeAttributeValueQuoted\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    marker = undefined\n    return completeAttributeValueUnquoted(code)\n  }\n\n  function completeAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return completeAttributeValueQuotedAfter\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return completeAttributeValueQuoted\n  }\n\n  function completeAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      return completeAttributeNameAfter(code)\n    }\n\n    effects.consume(code)\n    return completeAttributeValueUnquoted\n  }\n\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code)\n    }\n\n    return nok(code)\n  }\n\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return nok(code)\n  }\n\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return code === null || markdownLineEnding(code)\n      ? continuation(code)\n      : nok(code)\n  }\n\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code)\n      return continuationCommentInside\n    }\n\n    if (code === 60 && kind === 1) {\n      effects.consume(code)\n      return continuationRawTagOpen\n    }\n\n    if (code === 62 && kind === 4) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (code === 63 && kind === 3) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    if (code === 93 && kind === 5) {\n      effects.consume(code)\n      return continuationCharacterDataInside\n    }\n\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(\n        nextBlankConstruct,\n        continuationClose,\n        continuationAtLineEnding\n      )(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code)\n    }\n\n    effects.consume(code)\n    return continuation\n  }\n\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData')\n    return htmlContinueStart(code)\n  }\n\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return htmlContinueStart\n    }\n\n    effects.enter('htmlFlowData')\n    return continuation(code)\n  }\n\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code)\n      buffer = ''\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code)\n      buffer += fromCharCode(code)\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    return continuation(code)\n  }\n\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData')\n      return done(code)\n    }\n\n    effects.consume(code)\n    return continuationClose\n  }\n\n  function done(code) {\n    effects.exit('htmlFlow')\n    return ok(code)\n  }\n}\n\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.exit('htmlFlowData')\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    return effects.attempt(partialBlankLine, ok, nok)\n  }\n}\n\nmodule.exports = htmlFlow\n","'use strict'\n\n// This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\nvar raws = ['pre', 'script', 'style', 'textarea']\n\nmodule.exports = raws\n","'use strict'\n\nmodule.exports = longestStreak\n\n// Get the count of the longest repeating streak of `character` in `value`.\nfunction longestStreak(value, character) {\n  var count = 0\n  var maximum = 0\n  var expected\n  var index\n\n  if (typeof character !== 'string' || character.length !== 1) {\n    throw new Error('Expected character')\n  }\n\n  value = String(value)\n  index = value.indexOf(character)\n  expected = index\n\n  while (index !== -1) {\n    count++\n\n    if (index === expected) {\n      if (count > maximum) {\n        maximum = count\n      }\n    } else {\n      count = 1\n    }\n\n    expected = index + 1\n    index = value.indexOf(character, expected)\n  }\n\n  return maximum\n}\n","'use strict'\n\nmodule.exports = require('./dist')\n","'use strict'\n\nObject.defineProperty(exports, '__esModule', {value: true})\n\nvar content = require('../tokenize/content.js')\nvar factorySpace = require('../tokenize/factory-space.js')\nvar partialBlankLine = require('../tokenize/partial-blank-line.js')\n\nvar tokenize = initializeFlow\n\nfunction initializeFlow(effects) {\n  var self = this\n  var initial = effects.attempt(\n    // Try to parse a blank line.\n    partialBlankLine,\n    atBlankEnding, // Try to parse initial flow (essentially, only code).\n    effects.attempt(\n      this.parser.constructs.flowInitial,\n      afterConstruct,\n      factorySpace(\n        effects,\n        effects.attempt(\n          this.parser.constructs.flow,\n          afterConstruct,\n          effects.attempt(content, afterConstruct)\n        ),\n        'linePrefix'\n      )\n    )\n  )\n  return initial\n\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    self.currentConstruct = undefined\n    return initial\n  }\n\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    self.currentConstruct = undefined\n    return initial\n  }\n}\n\nexports.tokenize = tokenize\n","'use strict'\n\nvar assign = require('../constant/assign.js')\nvar chunkedSplice = require('./chunked-splice.js')\nvar shallow = require('./shallow.js')\n\nfunction subtokenize(events) {\n  var jumps = {}\n  var index = -1\n  var event\n  var lineIndex\n  var otherIndex\n  var otherEvent\n  var parameters\n  var subevents\n  var more\n\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index]\n    }\n\n    event = events[index] // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n\n    if (\n      index &&\n      event[1].type === 'chunkFlow' &&\n      events[index - 1][1].type === 'listItemPrefix'\n    ) {\n      subevents = event[1]._tokenizer.events\n      otherIndex = 0\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'lineEndingBlank'\n      ) {\n        otherIndex += 2\n      }\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'content'\n      ) {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break\n          }\n\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1].isInFirstContentOfListItem = true\n            otherIndex++\n          }\n        }\n      }\n    } // Enter.\n\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        assign(jumps, subcontent(events, index))\n        index = jumps[index]\n        more = true\n      }\n    } // Exit.\n    else if (event[1]._container || event[1]._movePreviousLineEndings) {\n      otherIndex = index\n      lineIndex = undefined\n\n      while (otherIndex--) {\n        otherEvent = events[otherIndex]\n\n        if (\n          otherEvent[1].type === 'lineEnding' ||\n          otherEvent[1].type === 'lineEndingBlank'\n        ) {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank'\n            }\n\n            otherEvent[1].type = 'lineEnding'\n            lineIndex = otherIndex\n          }\n        } else {\n          break\n        }\n      }\n\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = shallow(events[lineIndex][1].start) // Switch container exit w/ line endings.\n\n        parameters = events.slice(lineIndex, index)\n        parameters.unshift(event)\n        chunkedSplice(events, lineIndex, index - lineIndex + 1, parameters)\n      }\n    }\n  }\n\n  return !more\n}\n\nfunction subcontent(events, eventIndex) {\n  var token = events[eventIndex][1]\n  var context = events[eventIndex][2]\n  var startPosition = eventIndex - 1\n  var startPositions = []\n  var tokenizer =\n    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\n    startPositions.push(startPosition)\n\n    if (!token._tokenizer) {\n      stream = context.sliceStream(token)\n\n      if (!token.next) {\n        stream.push(null)\n      }\n\n      if (previous) {\n        tokenizer.defineSkip(token.start)\n      }\n\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true\n      }\n\n      tokenizer.write(stream)\n\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined\n      }\n    } // Unravel the next token.\n\n    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\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 &&\n      childEvents[index][1].type === childEvents[index - 1][1].type &&\n      childEvents[index][1].start.line !== childEvents[index][1].end.line\n    ) {\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\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]\n    adjust += jumps[index][1] - jumps[index][0] - 1\n  }\n\n  return gaps\n\n  function add(slice) {\n    var start = startPositions.pop()\n    jumps.unshift([start, start + slice.length - 1])\n    chunkedSplice(events, start, 2, slice)\n  }\n}\n\nmodule.exports = subtokenize\n","'use strict'\n\nmodule.exports = inlineCode\n\nvar u = require('unist-builder')\n\nfunction inlineCode(h, node) {\n  var value = node.value.replace(/\\r?\\n|\\r/g, ' ')\n  return h(node, 'code', [u('text', value)])\n}\n","'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]/\n\nmodule.exports = unicodePunctuation\n","'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')\n\nvar codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented,\n  resolve: resolveCodeIndented\n}\nvar indentedContentConstruct = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\n}\n\nfunction resolveCodeIndented(events, context) {\n  var code = {\n    type: 'codeIndented',\n    start: events[0][1].start,\n    end: events[events.length - 1][1].end\n  }\n  chunkedSplice(events, 0, 0, [['enter', code, context]])\n  chunkedSplice(events, events.length, 0, [['exit', code, context]])\n  return events\n}\n\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  return effects.attempt(indentedContentConstruct, afterPrefix, nok)\n\n  function afterPrefix(code) {\n    if (code === null) {\n      return ok(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContentConstruct, afterPrefix, ok)(code)\n    }\n\n    effects.enter('codeFlowValue')\n    return content(code)\n  }\n\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return afterPrefix(code)\n    }\n\n    effects.consume(code)\n    return content\n  }\n}\n\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  var self = this\n  return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)\n\n  function afterPrefix(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)\n    }\n\n    return prefixSize(self.events, 'linePrefix') < 4 ? nok(code) : ok(code)\n  }\n}\n\nmodule.exports = codeIndented\n","'use strict'\n\nvar assign = Object.assign\n\nmodule.exports = assign\n","module.exports = checkListItemIndent\n\nfunction checkListItemIndent(context) {\n  var style = context.options.listItemIndent || 'tab'\n\n  if (style === 1 || style === '1') {\n    return 'one'\n  }\n\n  if (style !== 'tab' && style !== 'one' && style !== 'mixed') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        style +\n        '` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`'\n    )\n  }\n\n  return style\n}\n","'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\n\nmodule.exports = asciiAlphanumeric\n","'use strict'\n\nmodule.exports = root\n\nvar u = require('unist-builder')\nvar wrap = require('../wrap')\nvar all = require('../all')\n\nfunction root(h, node) {\n  return h.augment(node, u('root', wrap(all(h, node))))\n}\n","module.exports = [joinDefaults]\n\nvar formatCodeAsIndented = require('./util/format-code-as-indented')\nvar formatHeadingAsSetext = require('./util/format-heading-as-setext')\n\nfunction joinDefaults(left, right, parent, context) {\n  if (\n    // Two lists with the same marker.\n    (right.type === 'list' &&\n      right.type === left.type &&\n      Boolean(left.ordered) === Boolean(right.ordered)) ||\n    // Indented code after list or another indented code.\n    (right.type === 'code' &&\n      formatCodeAsIndented(right, context) &&\n      (left.type === 'list' ||\n        (left.type === right.type && formatCodeAsIndented(left, context))))\n  ) {\n    return false\n  }\n\n  // Join children of a list or an item.\n  // In which case, `parent` has a `spread` field.\n  if (typeof parent.spread === 'boolean') {\n    if (\n      left.type === 'paragraph' &&\n      // Two paragraphs.\n      (left.type === right.type ||\n        right.type === 'definition' ||\n        // Paragraph followed by a setext heading.\n        (right.type === 'heading' && formatHeadingAsSetext(right, context)))\n    ) {\n      return\n    }\n\n    return parent.spread ? 1 : 0\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')\n\nvar labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n}\nvar resourceConstruct = {\n  tokenize: tokenizeResource\n}\nvar fullReferenceConstruct = {\n  tokenize: tokenizeFullReference\n}\nvar collapsedReferenceConstruct = {\n  tokenize: tokenizeCollapsedReference\n}\n\nfunction resolveAllLabelEnd(events) {\n  var index = -1\n  var token\n\n  while (++index < events.length) {\n    token = events[index][1]\n\n    if (\n      !token._used &&\n      (token.type === 'labelImage' ||\n        token.type === 'labelLink' ||\n        token.type === 'labelEnd')\n    ) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2)\n      token.type = 'data'\n      index++\n    }\n  }\n\n  return events\n}\n\nfunction resolveToLabelEnd(events, context) {\n  var index = events.length\n  var offset = 0\n  var group\n  var label\n  var text\n  var token\n  var open\n  var close\n  var media // Find an opening.\n\n  while (index--) {\n    token = events[index][1]\n\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (\n        token.type === 'link' ||\n        (token.type === 'labelLink' && token._inactive)\n      ) {\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 (\n        events[index][0] === 'enter' &&\n        (token.type === 'labelImage' || token.type === 'labelLink') &&\n        !token._balanced\n      ) {\n        open = index\n\n        if (token.type !== 'labelLink') {\n          offset = 2\n          break\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index\n    }\n  }\n\n  group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: shallow(events[open][1].start),\n    end: shallow(events[events.length - 1][1].end)\n  }\n  label = {\n    type: 'label',\n    start: shallow(events[open][1].start),\n    end: shallow(events[close][1].end)\n  }\n  text = {\n    type: 'labelText',\n    start: shallow(events[open + offset + 2][1].end),\n    end: shallow(events[close - 2][1].start)\n  }\n  media = [\n    ['enter', group, context],\n    ['enter', label, context]\n  ] // 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(\n    media,\n    resolveAll(\n      context.parser.constructs.insideSpan.null,\n      events.slice(open + offset + 4, close - 3),\n      context\n    )\n  ) // Text close, marker close, label close.\n\n  media = chunkedPush(media, [\n    ['exit', text, context],\n    events[close - 2],\n    events[close - 1],\n    ['exit', label, context]\n  ]) // Reference, resource, or so.\n\n  media = chunkedPush(media, events.slice(close + 1)) // Media close.\n\n  media = chunkedPush(media, [['exit', group, context]])\n  chunkedSplice(events, open, events.length, media)\n  return events\n}\n\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  var self = this\n  var index = self.events.length\n  var labelStart\n  var defined // Find an opening.\n\n  while (index--) {\n    if (\n      (self.events[index][1].type === 'labelImage' ||\n        self.events[index][1].type === 'labelLink') &&\n      !self.events[index][1]._balanced\n    ) {\n      labelStart = self.events[index][1]\n      break\n    }\n  }\n\n  return start\n\n  function start(code) {\n    if (!labelStart) {\n      return nok(code)\n    } // It’s a balanced bracket, but contains a link.\n\n    if (labelStart._inactive) return balanced(code)\n    defined =\n      self.parser.defined.indexOf(\n        normalizeIdentifier(\n          self.sliceSerialize({\n            start: labelStart.end,\n            end: self.now()\n          })\n        )\n      ) > -1\n    effects.enter('labelEnd')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelEnd')\n    return afterLabelEnd\n  }\n\n  function afterLabelEnd(code) {\n    // Resource: `[asd](fgh)`.\n    if (code === 40) {\n      return effects.attempt(\n        resourceConstruct,\n        ok,\n        defined ? ok : balanced\n      )(code)\n    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?\n\n    if (code === 91) {\n      return effects.attempt(\n        fullReferenceConstruct,\n        ok,\n        defined\n          ? effects.attempt(collapsedReferenceConstruct, ok, balanced)\n          : balanced\n      )(code)\n    } // Shortcut reference: `[asd]`?\n\n    return defined ? ok(code) : balanced(code)\n  }\n\n  function balanced(code) {\n    labelStart._balanced = true\n    return nok(code)\n  }\n}\n\nfunction tokenizeResource(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.enter('resource')\n    effects.enter('resourceMarker')\n    effects.consume(code)\n    effects.exit('resourceMarker')\n    return factoryWhitespace(effects, open)\n  }\n\n  function open(code) {\n    if (code === 41) {\n      return end(code)\n    }\n\n    return factoryDestination(\n      effects,\n      destinationAfter,\n      nok,\n      'resourceDestination',\n      'resourceDestinationLiteral',\n      'resourceDestinationLiteralMarker',\n      'resourceDestinationRaw',\n      'resourceDestinationString',\n      3\n    )(code)\n  }\n\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, between)(code)\n      : end(code)\n  }\n\n  function between(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factoryWhitespace(effects, end),\n        nok,\n        'resourceTitle',\n        'resourceTitleMarker',\n        'resourceTitleString'\n      )(code)\n    }\n\n    return end(code)\n  }\n\n  function end(code) {\n    if (code === 41) {\n      effects.enter('resourceMarker')\n      effects.consume(code)\n      effects.exit('resourceMarker')\n      effects.exit('resource')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n\nfunction tokenizeFullReference(effects, ok, nok) {\n  var self = this\n  return start\n\n  function start(code) {\n    return factoryLabel.call(\n      self,\n      effects,\n      afterLabel,\n      nok,\n      'reference',\n      'referenceMarker',\n      'referenceString'\n    )(code)\n  }\n\n  function afterLabel(code) {\n    return self.parser.defined.indexOf(\n      normalizeIdentifier(\n        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n      )\n    ) < 0\n      ? nok(code)\n      : ok(code)\n  }\n}\n\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.enter('reference')\n    effects.enter('referenceMarker')\n    effects.consume(code)\n    effects.exit('referenceMarker')\n    return open\n  }\n\n  function open(code) {\n    if (code === 93) {\n      effects.enter('referenceMarker')\n      effects.consume(code)\n      effects.exit('referenceMarker')\n      effects.exit('reference')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = labelEnd\n","module.exports = strong\nstrong.peek = strongPeek\n\nvar checkStrong = require('../util/check-strong')\nvar phrasing = require('../util/container-phrasing')\n\n// To do: there are cases where emphasis cannot “form” depending on the\n// previous or next character of sequences.\n// There’s no way around that though, except for injecting zero-width stuff.\n// Do we need to safeguard against that?\nfunction strong(node, _, context) {\n  var marker = checkStrong(context)\n  var exit = context.enter('strong')\n  var value = phrasing(node, context, {before: marker, after: marker})\n  exit()\n  return marker + marker + value + marker + marker\n}\n\nfunction strongPeek(node, _, context) {\n  return context.options.strong || '*'\n}\n","'use strict'\n\nvar sizeChunks = require('./size-chunks.js')\n\nfunction prefixSize(events, type) {\n  var tail = events[events.length - 1]\n  if (!tail || tail[1].type !== type) return 0\n  return sizeChunks(tail[2].sliceStream(tail[1]))\n}\n\nmodule.exports = prefixSize\n","'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')\n\nvar codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n}\n\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  var self = this\n  var closingFenceConstruct = {\n    tokenize: tokenizeClosingFence,\n    partial: true\n  }\n  var initialPrefix = prefixSize(this.events, 'linePrefix')\n  var sizeOpen = 0\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter('codeFenced')\n    effects.enter('codeFencedFence')\n    effects.enter('codeFencedFenceSequence')\n    marker = code\n    return sequenceOpen(code)\n  }\n\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code)\n      sizeOpen++\n      return sequenceOpen\n    }\n\n    effects.exit('codeFencedFenceSequence')\n    return sizeOpen < 3\n      ? nok(code)\n      : factorySpace(effects, infoOpen, 'whitespace')(code)\n  }\n\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceInfo')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return info(code)\n  }\n\n  function info(code) {\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceInfo')\n      return factorySpace(effects, infoAfter, 'whitespace')(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return info\n  }\n\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceMeta')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return meta(code)\n  }\n\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceMeta')\n      return openAfter(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return meta\n  }\n\n  function openAfter(code) {\n    effects.exit('codeFencedFence')\n    return self.interrupt ? ok(code) : content(code)\n  }\n\n  function content(code) {\n    if (code === null) {\n      return after(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return effects.attempt(\n        closingFenceConstruct,\n        after,\n        initialPrefix\n          ? factorySpace(effects, content, 'linePrefix', initialPrefix + 1)\n          : content\n      )\n    }\n\n    effects.enter('codeFlowValue')\n    return contentContinue(code)\n  }\n\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return content(code)\n    }\n\n    effects.consume(code)\n    return contentContinue\n  }\n\n  function after(code) {\n    effects.exit('codeFenced')\n    return ok(code)\n  }\n\n  function tokenizeClosingFence(effects, ok, nok) {\n    var size = 0\n    return factorySpace(\n      effects,\n      closingSequenceStart,\n      'linePrefix',\n      this.parser.constructs.disable.null.indexOf('codeIndented') > -1\n        ? undefined\n        : 4\n    )\n\n    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence')\n      effects.enter('codeFencedFenceSequence')\n      return closingSequence(code)\n    }\n\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code)\n        size++\n        return closingSequence\n      }\n\n      if (size < sizeOpen) return nok(code)\n      effects.exit('codeFencedFenceSequence')\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code)\n    }\n\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence')\n        return ok(code)\n      }\n\n      return nok(code)\n    }\n  }\n}\n\nmodule.exports = codeFenced\n","'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\n\nmodule.exports = asciiHexDigit\n","'use strict'\n\nfunction markdownLineEndingOrSpace(code) {\n  return code < 0 || code === 32\n}\n\nmodule.exports = markdownLineEndingOrSpace\n","'use strict'\n\nvar types = require('./util/types')\nvar create = require('./util/create')\nvar caseInsensitiveTransform = require('./util/case-insensitive-transform')\n\nvar boolean = types.boolean\nvar overloadedBoolean = types.overloadedBoolean\nvar booleanish = types.booleanish\nvar number = types.number\nvar spaceSeparated = types.spaceSeparated\nvar commaSeparated = types.commaSeparated\n\nmodule.exports = create({\n  space: 'html',\n  attributes: {\n    acceptcharset: 'accept-charset',\n    classname: 'class',\n    htmlfor: 'for',\n    httpequiv: 'http-equiv'\n  },\n  transform: caseInsensitiveTransform,\n  mustUseProperty: ['checked', 'multiple', 'muted', 'selected'],\n  properties: {\n    // Standard Properties.\n    abbr: null,\n    accept: commaSeparated,\n    acceptCharset: spaceSeparated,\n    accessKey: spaceSeparated,\n    action: null,\n    allow: null,\n    allowFullScreen: boolean,\n    allowPaymentRequest: boolean,\n    allowUserMedia: boolean,\n    alt: null,\n    as: null,\n    async: boolean,\n    autoCapitalize: null,\n    autoComplete: spaceSeparated,\n    autoFocus: boolean,\n    autoPlay: boolean,\n    capture: boolean,\n    charSet: null,\n    checked: boolean,\n    cite: null,\n    className: spaceSeparated,\n    cols: number,\n    colSpan: null,\n    content: null,\n    contentEditable: booleanish,\n    controls: boolean,\n    controlsList: spaceSeparated,\n    coords: number | commaSeparated,\n    crossOrigin: null,\n    data: null,\n    dateTime: null,\n    decoding: null,\n    default: boolean,\n    defer: boolean,\n    dir: null,\n    dirName: null,\n    disabled: boolean,\n    download: overloadedBoolean,\n    draggable: booleanish,\n    encType: null,\n    enterKeyHint: null,\n    form: null,\n    formAction: null,\n    formEncType: null,\n    formMethod: null,\n    formNoValidate: boolean,\n    formTarget: null,\n    headers: spaceSeparated,\n    height: number,\n    hidden: boolean,\n    high: number,\n    href: null,\n    hrefLang: null,\n    htmlFor: spaceSeparated,\n    httpEquiv: spaceSeparated,\n    id: null,\n    imageSizes: null,\n    imageSrcSet: commaSeparated,\n    inputMode: null,\n    integrity: null,\n    is: null,\n    isMap: boolean,\n    itemId: null,\n    itemProp: spaceSeparated,\n    itemRef: spaceSeparated,\n    itemScope: boolean,\n    itemType: spaceSeparated,\n    kind: null,\n    label: null,\n    lang: null,\n    language: null,\n    list: null,\n    loading: null,\n    loop: boolean,\n    low: number,\n    manifest: null,\n    max: null,\n    maxLength: number,\n    media: null,\n    method: null,\n    min: null,\n    minLength: number,\n    multiple: boolean,\n    muted: boolean,\n    name: null,\n    nonce: null,\n    noModule: boolean,\n    noValidate: boolean,\n    onAbort: null,\n    onAfterPrint: null,\n    onAuxClick: null,\n    onBeforePrint: null,\n    onBeforeUnload: null,\n    onBlur: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onContextMenu: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFormData: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLanguageChange: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadEnd: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMessageError: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRejectionHandled: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onSecurityPolicyViolation: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onSlotChange: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnhandledRejection: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onWheel: null,\n    open: boolean,\n    optimum: number,\n    pattern: null,\n    ping: spaceSeparated,\n    placeholder: null,\n    playsInline: boolean,\n    poster: null,\n    preload: null,\n    readOnly: boolean,\n    referrerPolicy: null,\n    rel: spaceSeparated,\n    required: boolean,\n    reversed: boolean,\n    rows: number,\n    rowSpan: number,\n    sandbox: spaceSeparated,\n    scope: null,\n    scoped: boolean,\n    seamless: boolean,\n    selected: boolean,\n    shape: null,\n    size: number,\n    sizes: null,\n    slot: null,\n    span: number,\n    spellCheck: booleanish,\n    src: null,\n    srcDoc: null,\n    srcLang: null,\n    srcSet: commaSeparated,\n    start: number,\n    step: null,\n    style: null,\n    tabIndex: number,\n    target: null,\n    title: null,\n    translate: null,\n    type: null,\n    typeMustMatch: boolean,\n    useMap: null,\n    value: booleanish,\n    width: number,\n    wrap: null,\n\n    // Legacy.\n    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis\n    align: null, // Several. Use CSS `text-align` instead,\n    aLink: null, // `<body>`. Use CSS `a:active {color}` instead\n    archive: spaceSeparated, // `<object>`. List of URIs to archives\n    axis: null, // `<td>` and `<th>`. Use `scope` on `<th>`\n    background: null, // `<body>`. Use CSS `background-image` instead\n    bgColor: null, // `<body>` and table elements. Use CSS `background-color` instead\n    border: number, // `<table>`. Use CSS `border-width` instead,\n    borderColor: null, // `<table>`. Use CSS `border-color` instead,\n    bottomMargin: number, // `<body>`\n    cellPadding: null, // `<table>`\n    cellSpacing: null, // `<table>`\n    char: null, // Several table elements. When `align=char`, sets the character to align on\n    charOff: null, // Several table elements. When `char`, offsets the alignment\n    classId: null, // `<object>`\n    clear: null, // `<br>`. Use CSS `clear` instead\n    code: null, // `<object>`\n    codeBase: null, // `<object>`\n    codeType: null, // `<object>`\n    color: null, // `<font>` and `<hr>`. Use CSS instead\n    compact: boolean, // Lists. Use CSS to reduce space between items instead\n    declare: boolean, // `<object>`\n    event: null, // `<script>`\n    face: null, // `<font>`. Use CSS instead\n    frame: null, // `<table>`\n    frameBorder: null, // `<iframe>`. Use CSS `border` instead\n    hSpace: number, // `<img>` and `<object>`\n    leftMargin: number, // `<body>`\n    link: null, // `<body>`. Use CSS `a:link {color: *}` instead\n    longDesc: null, // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`\n    lowSrc: null, // `<img>`. Use a `<picture>`\n    marginHeight: number, // `<body>`\n    marginWidth: number, // `<body>`\n    noResize: boolean, // `<frame>`\n    noHref: boolean, // `<area>`. Use no href instead of an explicit `nohref`\n    noShade: boolean, // `<hr>`. Use background-color and height instead of borders\n    noWrap: boolean, // `<td>` and `<th>`\n    object: null, // `<applet>`\n    profile: null, // `<head>`\n    prompt: null, // `<isindex>`\n    rev: null, // `<link>`\n    rightMargin: number, // `<body>`\n    rules: null, // `<table>`\n    scheme: null, // `<meta>`\n    scrolling: booleanish, // `<frame>`. Use overflow in the child context\n    standby: null, // `<object>`\n    summary: null, // `<table>`\n    text: null, // `<body>`. Use CSS `color` instead\n    topMargin: number, // `<body>`\n    valueType: null, // `<param>`\n    version: null, // `<html>`. Use a doctype.\n    vAlign: null, // Several. Use CSS `vertical-align` instead\n    vLink: null, // `<body>`. Use CSS `a:visited {color}` instead\n    vSpace: number, // `<img>` and `<object>`\n\n    // Non-standard Properties.\n    allowTransparency: null,\n    autoCorrect: null,\n    autoSave: null,\n    disablePictureInPicture: boolean,\n    disableRemotePlayback: boolean,\n    prefix: null,\n    property: null,\n    results: number,\n    security: null,\n    unselectable: null\n  }\n})\n","/*!\n * repeat-string <https://github.com/jonschlinkert/repeat-string>\n *\n * Copyright (c) 2014-2015, Jon Schlinkert.\n * Licensed under the MIT License.\n */\n\n'use strict';\n\n/**\n * Results cache\n */\n\nvar res = '';\nvar cache;\n\n/**\n * Expose `repeat`\n */\n\nmodule.exports = repeat;\n\n/**\n * Repeat the given `string` the specified `number`\n * of times.\n *\n * **Example:**\n *\n * ```js\n * var repeat = require('repeat-string');\n * repeat('A', 5);\n * //=> AAAAA\n * ```\n *\n * @param {String} `string` The string to repeat\n * @param {Number} `number` The number of times to repeat the string\n * @return {String} Repeated string\n * @api public\n */\n\nfunction repeat(str, num) {\n  if (typeof str !== 'string') {\n    throw new TypeError('expected a string');\n  }\n\n  // cover common, quick use cases\n  if (num === 1) return str;\n  if (num === 2) return str + str;\n\n  var max = str.length * num;\n  if (cache !== str || typeof cache === 'undefined') {\n    cache = str;\n    res = '';\n  } else if (res.length >= max) {\n    return res.substr(0, max);\n  }\n\n  while (max > res.length && num > 1) {\n    if (num & 1) {\n      res += str;\n    }\n\n    num >>= 1;\n    str += str;\n  }\n\n  res += str;\n  res = res.substr(0, max);\n  return res;\n}\n","'use strict'\n\nObject.defineProperty(exports, '__esModule', {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')\n\nvar document = {\n  42: list,\n  // Asterisk\n  43: list,\n  // Plus sign\n  45: list,\n  // Dash\n  48: list,\n  // 0\n  49: list,\n  // 1\n  50: list,\n  // 2\n  51: list,\n  // 3\n  52: list,\n  // 4\n  53: list,\n  // 5\n  54: list,\n  // 6\n  55: list,\n  // 7\n  56: list,\n  // 8\n  57: list,\n  // 9\n  62: blockQuote // Greater than\n}\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}\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\n","'use strict'\n\nmodule.exports = table\n\nvar position = require('unist-util-position')\nvar wrap = require('../wrap')\nvar all = require('../all')\n\nfunction table(h, node) {\n  var rows = node.children\n  var index = rows.length\n  var align = node.align || []\n  var alignLength = align.length\n  var result = []\n  var pos\n  var row\n  var out\n  var name\n  var cell\n\n  while (index--) {\n    row = rows[index].children\n    name = index === 0 ? 'th' : 'td'\n    pos = alignLength || row.length\n    out = []\n\n    while (pos--) {\n      cell = row[pos]\n      out[pos] = h(cell, name, {align: align[pos]}, cell ? all(h, cell) : [])\n    }\n\n    result[index] = h(rows[index], 'tr', wrap(out, true))\n  }\n\n  return h(\n    node,\n    'table',\n    wrap(\n      [h(result[0].position, 'thead', wrap([result[0]], true))].concat(\n        result[1]\n          ? h(\n              {\n                start: position.start(result[1]),\n                end: position.end(result[result.length - 1])\n              },\n              'tbody',\n              wrap(result.slice(1), true)\n            )\n          : []\n      ),\n      true\n    )\n  )\n}\n","'use strict'\n\n// This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\nvar basics = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'section',\n  'source',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\nmodule.exports = basics\n","module.exports = link\nlink.peek = linkPeek\n\nvar checkQuote = require('../util/check-quote')\nvar formatLinkAsAutolink = require('../util/format-link-as-autolink')\nvar phrasing = require('../util/container-phrasing')\nvar safe = require('../util/safe')\n\nfunction link(node, _, context) {\n  var quote = checkQuote(context)\n  var suffix = quote === '\"' ? 'Quote' : 'Apostrophe'\n  var exit\n  var subexit\n  var value\n  var stack\n\n  if (formatLinkAsAutolink(node, context)) {\n    // Hide the fact that we’re in phrasing, because escapes don’t work.\n    stack = context.stack\n    context.stack = []\n    exit = context.enter('autolink')\n    value = '<' + phrasing(node, context, {before: '<', after: '>'}) + '>'\n    exit()\n    context.stack = stack\n    return value\n  }\n\n  exit = context.enter('link')\n  subexit = context.enter('label')\n  value = '[' + phrasing(node, context, {before: '[', after: ']'}) + ']('\n  subexit()\n\n  if (\n    // If there’s no url but there is a title…\n    (!node.url && node.title) ||\n    // Or if there’s markdown whitespace or an eol, enclose.\n    /[ \\t\\r\\n]/.test(node.url)\n  ) {\n    subexit = context.enter('destinationLiteral')\n    value += '<' + safe(context, node.url, {before: '<', after: '>'}) + '>'\n  } else {\n    // No whitespace, raw is prettier.\n    subexit = context.enter('destinationRaw')\n    value += safe(context, node.url, {\n      before: '(',\n      after: node.title ? ' ' : ')'\n    })\n  }\n\n  subexit()\n\n  if (node.title) {\n    subexit = context.enter('title' + suffix)\n    value +=\n      ' ' +\n      quote +\n      safe(context, node.title, {before: quote, after: quote}) +\n      quote\n    subexit()\n  }\n\n  value += ')'\n\n  exit()\n  return value\n}\n\nfunction linkPeek(node, _, context) {\n  return formatLinkAsAutolink(node, context) ? '<' : '['\n}\n","module.exports = listItem\n\nvar repeat = require('repeat-string')\nvar checkBullet = require('../util/check-bullet')\nvar checkListItemIndent = require('../util/check-list-item-indent')\nvar flow = require('../util/container-flow')\nvar indentLines = require('../util/indent-lines')\n\nfunction listItem(node, parent, context) {\n  var bullet = checkBullet(context)\n  var listItemIndent = checkListItemIndent(context)\n  var size\n  var value\n  var exit\n\n  if (parent && parent.ordered) {\n    bullet =\n      (parent.start > -1 ? parent.start : 1) +\n      (context.options.incrementListMarker === false\n        ? 0\n        : parent.children.indexOf(node)) +\n      '.'\n  }\n\n  size = bullet.length + 1\n\n  if (\n    listItemIndent === 'tab' ||\n    (listItemIndent === 'mixed' && ((parent && parent.spread) || node.spread))\n  ) {\n    size = Math.ceil(size / 4) * 4\n  }\n\n  exit = context.enter('listItem')\n  value = indentLines(flow(node, context), map)\n  exit()\n\n  return value\n\n  function map(line, index, blank) {\n    if (index) {\n      return (blank ? '' : repeat(' ', size)) + line\n    }\n\n    return (blank ? bullet : bullet + repeat(' ', size - bullet.length)) + line\n  }\n}\n","module.exports = formatCodeAsIndented\n\nfunction formatCodeAsIndented(node, context) {\n  return (\n    !context.options.fences &&\n    node.value &&\n    // If there’s no info…\n    !node.lang &&\n    // And there’s a non-whitespace character…\n    /[^ \\r\\n]/.test(node.value) &&\n    // And the value doesn’t start or end in a blank…\n    !/^[\\t ]*(?:[\\r\\n]|$)|(?:^|[\\r\\n])[\\t ]*$/.test(node.value)\n  )\n}\n","'use strict'\n\nvar own = {}.hasOwnProperty\n\nmodule.exports = own\n","'use strict'\n\nvar assign = require('../constant/assign.js')\n\nfunction shallow(object) {\n  return assign({}, object)\n}\n\nmodule.exports = shallow\n","module.exports = checkRule\n\nfunction checkRule(context) {\n  var marker = context.options.rule || '*'\n\n  if (marker !== '*' && marker !== '-' && marker !== '_') {\n    throw new Error(\n      'Cannot serialize rules with `' +\n        marker +\n        '` for `options.rule`, expected `*`, `-`, or `_`'\n    )\n  }\n\n  return marker\n}\n","module.exports = formatLinkAsAutolink\n\nvar toString = require('mdast-util-to-string')\n\nfunction formatLinkAsAutolink(node, context) {\n  var raw = toString(node)\n\n  return (\n    !context.options.resourceLink &&\n    // If there’s a url…\n    node.url &&\n    // And there’s a no title…\n    !node.title &&\n    // And the content of `node` is a single text node…\n    node.children &&\n    node.children.length === 1 &&\n    node.children[0].type === 'text' &&\n    // And if the url is the same as the content…\n    (raw === node.url || 'mailto:' + raw === node.url) &&\n    // And that starts w/ a protocol…\n    /^[a-z][a-z+.-]+:/i.test(node.url) &&\n    // And that doesn’t contain ASCII control codes (character escapes and\n    // references don’t work) or angle brackets…\n    !/[\\0- <>\\u007F]/.test(node.url)\n  )\n}\n","module.exports = patternInScope\n\nfunction patternInScope(stack, pattern) {\n  return (\n    listInScope(stack, pattern.inConstruct, true) &&\n    !listInScope(stack, pattern.notInConstruct)\n  )\n}\n\nfunction listInScope(stack, list, none) {\n  var index\n\n  if (!list) {\n    return none\n  }\n\n  if (typeof list === 'string') {\n    list = [list]\n  }\n\n  index = -1\n\n  while (++index < list.length) {\n    if (stack.indexOf(list[index]) !== -1) {\n      return true\n    }\n  }\n\n  return false\n}\n","'use strict'\n\nvar asciiPunctuation = require('../character/ascii-punctuation.js')\n\nvar characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n}\n\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.enter('characterEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    effects.exit('escapeMarker')\n    return open\n  }\n\n  function open(code) {\n    if (asciiPunctuation(code)) {\n      effects.enter('characterEscapeValue')\n      effects.consume(code)\n      effects.exit('characterEscapeValue')\n      effects.exit('characterEscape')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = characterEscape\n","module.exports = configure\n\nfunction configure(base, extension) {\n  var index = -1\n  var key\n\n  // First do subextensions.\n  if (extension.extensions) {\n    while (++index < extension.extensions.length) {\n      configure(base, extension.extensions[index])\n    }\n  }\n\n  for (key in extension) {\n    if (key === 'extensions') {\n      // Empty.\n    } else if (key === 'unsafe' || key === 'join') {\n      base[key] = base[key].concat(extension[key] || [])\n    } else if (key === 'handlers') {\n      base[key] = Object.assign(base[key], extension[key] || {})\n    } else {\n      base.options[key] = extension[key]\n    }\n  }\n\n  return base\n}\n","'use strict'\n\nmodule.exports = generateFootnotes\n\nvar thematicBreak = require('./handlers/thematic-break')\nvar list = require('./handlers/list')\nvar wrap = require('./wrap')\n\nfunction generateFootnotes(h) {\n  var footnoteById = h.footnoteById\n  var footnoteOrder = h.footnoteOrder\n  var length = footnoteOrder.length\n  var index = -1\n  var listItems = []\n  var def\n  var backReference\n  var content\n  var tail\n\n  while (++index < length) {\n    def = footnoteById[footnoteOrder[index].toUpperCase()]\n\n    if (!def) {\n      continue\n    }\n\n    content = def.children.concat()\n    tail = content[content.length - 1]\n    backReference = {\n      type: 'link',\n      url: '#fnref-' + def.identifier,\n      data: {hProperties: {className: ['footnote-backref']}},\n      children: [{type: 'text', value: '↩'}]\n    }\n\n    if (!tail || tail.type !== 'paragraph') {\n      tail = {type: 'paragraph', children: []}\n      content.push(tail)\n    }\n\n    tail.children.push(backReference)\n\n    listItems.push({\n      type: 'listItem',\n      data: {hProperties: {id: 'fn-' + def.identifier}},\n      children: content,\n      position: def.position\n    })\n  }\n\n  if (listItems.length === 0) {\n    return null\n  }\n\n  return h(\n    null,\n    'div',\n    {className: ['footnotes']},\n    wrap(\n      [\n        thematicBreak(h),\n        list(h, {type: 'list', ordered: true, children: listItems})\n      ],\n      true\n    )\n  )\n}\n","'use strict'\n\nmodule.exports = Info\n\nvar proto = Info.prototype\n\nproto.space = null\nproto.attribute = null\nproto.property = null\nproto.boolean = false\nproto.booleanish = false\nproto.overloadedBoolean = false\nproto.number = false\nproto.commaSeparated = false\nproto.spaceSeparated = false\nproto.commaOrSpaceSeparated = false\nproto.mustUseProperty = false\nproto.defined = false\n\nfunction Info(property, attribute) {\n  this.property = property\n  this.attribute = attribute\n}\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar factorySpace = require('./factory-space.js')\n\nvar partialBlankLine = {\n  tokenize: tokenizePartialBlankLine,\n  partial: true\n}\n\nfunction tokenizePartialBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix')\n\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n\nmodule.exports = partialBlankLine\n","module.exports = formatHeadingAsSetext\n\nvar toString = require('mdast-util-to-string')\n\nfunction formatHeadingAsSetext(node, context) {\n  return (\n    context.options.setext && (!node.depth || node.depth < 3) && toString(node)\n  )\n}\n","'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\n  remove = remove > 0 ? remove : 0 // No need to chunk the items if there’s only a couple (10k) items.\n\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove)\n    splice.apply(list, parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) splice.apply(list, [start, remove]) // Insert the items in chunks to not cause stack overflows.\n\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0)\n      splice.apply(list, parameters)\n      chunkStart += 10000\n      start += 10000\n    }\n  }\n}\n\nmodule.exports = chunkedSplice\n","'use strict'\n\nmodule.exports = all\n\nvar one = require('./one')\n\nfunction all(h, parent) {\n  var nodes = parent.children || []\n  var length = nodes.length\n  var values = []\n  var index = -1\n  var result\n  var head\n\n  while (++index < length) {\n    result = one(h, nodes[index], parent)\n\n    if (result) {\n      if (index && nodes[index - 1].type === 'break') {\n        if (result.value) {\n          result.value = result.value.replace(/^\\s+/, '')\n        }\n\n        head = result.children && result.children[0]\n\n        if (head && head.value) {\n          head.value = head.value.replace(/^\\s+/, '')\n        }\n      }\n\n      values = values.concat(result)\n    }\n  }\n\n  return values\n}\n","'use strict'\n\nmodule.exports = thematicBreak\n\nfunction thematicBreak(h, node) {\n  return h(node, 'hr')\n}\n","'use strict'\n\nmodule.exports = revert\n\nvar u = require('unist-builder')\nvar all = require('./all')\n\n// Return the content of a reference without definition as Markdown.\nfunction revert(h, node) {\n  var subtype = node.referenceType\n  var suffix = ']'\n  var contents\n  var head\n  var tail\n\n  if (subtype === 'collapsed') {\n    suffix += '[]'\n  } else if (subtype === 'full') {\n    suffix += '[' + (node.label || node.identifier) + ']'\n  }\n\n  if (node.type === 'imageReference') {\n    return u('text', '![' + node.alt + suffix)\n  }\n\n  contents = all(h, node)\n  head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift(u('text', '['))\n  }\n\n  tail = contents[contents.length - 1]\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix\n  } else {\n    contents.push(u('text', suffix))\n  }\n\n  return contents\n}\n","'use strict'\n\n/* eslint-env browser */\n\nvar el\n\nvar semicolon = 59 //  ';'\n\nmodule.exports = decodeEntity\n\nfunction decodeEntity(characters) {\n  var entity = '&' + characters + ';'\n  var char\n\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}\n","'use strict'\n\nmodule.exports = linkReference\n\nvar normalize = require('mdurl/encode')\nvar revert = require('../revert')\nvar all = require('../all')\n\nfunction linkReference(h, node) {\n  var def = h.definition(node.identifier)\n  var props\n\n  if (!def) {\n    return revert(h, node)\n  }\n\n  props = {href: normalize(def.url || '')}\n\n  if (def.title !== null && def.title !== undefined) {\n    props.title = def.title\n  }\n\n  return h(node, 'a', props, all(h, node))\n}\n","'use strict'\n\nvar unified = require('unified')\nvar parse = require('remark-parse')\nvar stringify = require('remark-stringify')\n\nmodule.exports = unified().use(parse).use(stringify).freeze()\n","'use strict'\n\nObject.defineProperty(exports, '__esModule', {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')\n\nvar tokenize = initializeDocument\nvar containerConstruct = {\n  tokenize: tokenizeContainer\n}\nvar lazyFlowConstruct = {\n  tokenize: tokenizeLazyFlow\n}\n\nfunction initializeDocument(effects) {\n  var self = this\n  var stack = []\n  var continued = 0\n  var inspectConstruct = {\n    tokenize: tokenizeInspect,\n    partial: true\n  }\n  var inspectResult\n  var childFlow\n  var childToken\n  return start\n\n  function start(code) {\n    if (continued < stack.length) {\n      self.containerState = stack[continued][1]\n      return effects.attempt(\n        stack[continued][0].continuation,\n        documentContinue,\n        documentContinued\n      )(code)\n    }\n\n    return documentContinued(code)\n  }\n\n  function documentContinue(code) {\n    continued++\n    return start(code)\n  }\n\n  function documentContinued(code) {\n    // If we’re in a concrete construct (such as when expecting another line of\n    // HTML, or we resulted in lazy content), we can immediately start flow.\n    if (inspectResult && inspectResult.flowContinue) {\n      return flowStart(code)\n    }\n\n    self.interrupt =\n      childFlow &&\n      childFlow.currentConstruct &&\n      childFlow.currentConstruct.interruptible\n    self.containerState = {}\n    return effects.attempt(\n      containerConstruct,\n      containerContinue,\n      flowStart\n    )(code)\n  }\n\n  function containerContinue(code) {\n    stack.push([self.currentConstruct, self.containerState])\n    self.containerState = undefined\n    return documentContinued(code)\n  }\n\n  function flowStart(code) {\n    if (code === null) {\n      exitContainers(0, true)\n      effects.consume(code)\n      return\n    }\n\n    childFlow = childFlow || self.parser.flow(self.now())\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    })\n    return flowContinue(code)\n  }\n\n  function flowContinue(code) {\n    if (code === null) {\n      continueFlow(effects.exit('chunkFlow'))\n      return flowStart(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      continueFlow(effects.exit('chunkFlow'))\n      return effects.check(inspectConstruct, documentAfterPeek)\n    }\n\n    effects.consume(code)\n    return flowContinue\n  }\n\n  function documentAfterPeek(code) {\n    exitContainers(\n      inspectResult.continued,\n      inspectResult && inspectResult.flowEnd\n    )\n    continued = 0\n    return start(code)\n  }\n\n  function continueFlow(token) {\n    if (childToken) childToken.next = token\n    childToken = token\n    childFlow.lazy = inspectResult && inspectResult.lazy\n    childFlow.defineSkip(token.start)\n    childFlow.write(self.sliceStream(token))\n  }\n\n  function exitContainers(size, end) {\n    var index = stack.length // Close the flow.\n\n    if (childFlow && end) {\n      childFlow.write([null])\n      childToken = childFlow = undefined\n    } // Exit open containers.\n\n    while (index-- > size) {\n      self.containerState = stack[index][1]\n      stack[index][0].exit.call(self, effects)\n    }\n\n    stack.length = size\n  }\n\n  function tokenizeInspect(effects, ok) {\n    var subcontinued = 0\n    inspectResult = {}\n    return inspectStart\n\n    function inspectStart(code) {\n      if (subcontinued < stack.length) {\n        self.containerState = stack[subcontinued][1]\n        return effects.attempt(\n          stack[subcontinued][0].continuation,\n          inspectContinue,\n          inspectLess\n        )(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\n      self.interrupt =\n        childFlow.currentConstruct && childFlow.currentConstruct.interruptible\n      self.containerState = {}\n      return effects.attempt(\n        containerConstruct,\n        inspectFlowEnd,\n        inspectDone\n      )(code)\n    }\n\n    function inspectContinue(code) {\n      subcontinued++\n      return self.containerState._closeFlow\n        ? inspectFlowEnd(code)\n        : inspectStart(code)\n    }\n\n    function inspectLess(code) {\n      if (childFlow.currentConstruct && childFlow.currentConstruct.lazy) {\n        // Maybe another container?\n        self.containerState = {}\n        return effects.attempt(\n          containerConstruct,\n          inspectFlowEnd, // Maybe flow, or a blank line?\n          effects.attempt(\n            lazyFlowConstruct,\n            inspectFlowEnd,\n            effects.check(partialBlankLine, inspectFlowEnd, inspectLazy)\n          )\n        )(code)\n      } // Otherwise we’re interrupting.\n\n      return inspectFlowEnd(code)\n    }\n\n    function inspectLazy(code) {\n      // Act as if all containers are continued.\n      subcontinued = stack.length\n      inspectResult.lazy = true\n      inspectResult.flowContinue = true\n      return inspectDone(code)\n    } // We’re done with flow if we have more containers, or an interruption.\n\n    function inspectFlowEnd(code) {\n      inspectResult.flowEnd = true\n      return inspectDone(code)\n    }\n\n    function inspectDone(code) {\n      inspectResult.continued = subcontinued\n      self.interrupt = self.containerState = undefined\n      return ok(code)\n    }\n  }\n}\n\nfunction tokenizeContainer(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(this.parser.constructs.document, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.indexOf('codeIndented') > -1\n      ? undefined\n      : 4\n  )\n}\n\nfunction tokenizeLazyFlow(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.lazy(this.parser.constructs.flow, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.indexOf('codeIndented') > -1\n      ? undefined\n      : 4\n  )\n}\n\nexports.tokenize = tokenize\n","'use strict'\n\nmodule.exports = stringify\n\nvar toMarkdown = require('mdast-util-to-markdown')\n\nfunction stringify(options) {\n  var self = this\n\n  this.Compiler = compile\n\n  function compile(tree) {\n    return toMarkdown(\n      tree,\n      Object.assign({}, self.data('settings'), options, {\n        // Note: this option is not in the readme.\n        // The goal is for it to be set by plugins on `data` instead of being\n        // passed by users.\n        extensions: self.data('toMarkdownExtensions') || []\n      })\n    )\n  }\n}\n","'use strict'\n\nmodule.exports = {\n  blockquote: require('./blockquote'),\n  break: require('./break'),\n  code: require('./code'),\n  delete: require('./delete'),\n  emphasis: require('./emphasis'),\n  footnoteReference: require('./footnote-reference'),\n  footnote: require('./footnote'),\n  heading: require('./heading'),\n  html: require('./html'),\n  imageReference: require('./image-reference'),\n  image: require('./image'),\n  inlineCode: require('./inline-code'),\n  linkReference: require('./link-reference'),\n  link: require('./link'),\n  listItem: require('./list-item'),\n  list: require('./list'),\n  paragraph: require('./paragraph'),\n  root: require('./root'),\n  strong: require('./strong'),\n  table: require('./table'),\n  text: require('./text'),\n  thematicBreak: require('./thematic-break'),\n  toml: ignore,\n  yaml: ignore,\n  definition: ignore,\n  footnoteDefinition: ignore\n}\n\n// Return nothing for nodes that are ignored.\nfunction ignore() {\n  return null\n}\n","'use strict'\n\nvar fromCharCode = require('../constant/from-char-code.js')\n\nfunction safeFromInt(value, base) {\n  var code = parseInt(value, base)\n\n  if (\n    // C0 except for HT, LF, FF, CR, space\n    code < 9 ||\n    code === 11 ||\n    (code > 13 && code < 32) || // Control character (DEL) of the basic block and C1 controls.\n    (code > 126 && code < 160) || // Lone high surrogates and low surrogates.\n    (code > 55295 && code < 57344) || // Noncharacters.\n    (code > 64975 && code < 65008) ||\n    (code & 65535) === 65535 ||\n    (code & 65535) === 65534 || // Out of range\n    code > 1114111\n  ) {\n    return '\\uFFFD'\n  }\n\n  return fromCharCode(code)\n}\n\nmodule.exports = safeFromInt\n","module.exports = emphasis\nemphasis.peek = emphasisPeek\n\nvar checkEmphasis = require('../util/check-emphasis')\nvar phrasing = require('../util/container-phrasing')\n\n// To do: there are cases where emphasis cannot “form” depending on the\n// previous or next character of sequences.\n// There’s no way around that though, except for injecting zero-width stuff.\n// Do we need to safeguard against that?\nfunction emphasis(node, _, context) {\n  var marker = checkEmphasis(context)\n  var exit = context.enter('emphasis')\n  var value = phrasing(node, context, {before: marker, after: marker})\n  exit()\n  return marker + value + marker\n}\n\nfunction emphasisPeek(node, _, context) {\n  return context.options.emphasis || '*'\n}\n","'use strict'\n\nmodule.exports = hardBreak\n\nvar u = require('unist-builder')\n\nfunction hardBreak(h, node) {\n  return [h(node, 'br'), u('text', '\\n')]\n}\n","'use strict'\n\nmodule.exports = normalize\n\nfunction normalize(value) {\n  return value.toLowerCase()\n}\n","'use strict'\n\nvar types = require('./util/types')\nvar create = require('./util/create')\n\nvar booleanish = types.booleanish\nvar number = types.number\nvar spaceSeparated = types.spaceSeparated\n\nmodule.exports = create({\n  transform: ariaTransform,\n  properties: {\n    ariaActiveDescendant: null,\n    ariaAtomic: booleanish,\n    ariaAutoComplete: null,\n    ariaBusy: booleanish,\n    ariaChecked: booleanish,\n    ariaColCount: number,\n    ariaColIndex: number,\n    ariaColSpan: number,\n    ariaControls: spaceSeparated,\n    ariaCurrent: null,\n    ariaDescribedBy: spaceSeparated,\n    ariaDetails: null,\n    ariaDisabled: booleanish,\n    ariaDropEffect: spaceSeparated,\n    ariaErrorMessage: null,\n    ariaExpanded: booleanish,\n    ariaFlowTo: spaceSeparated,\n    ariaGrabbed: booleanish,\n    ariaHasPopup: null,\n    ariaHidden: booleanish,\n    ariaInvalid: null,\n    ariaKeyShortcuts: null,\n    ariaLabel: null,\n    ariaLabelledBy: spaceSeparated,\n    ariaLevel: number,\n    ariaLive: null,\n    ariaModal: booleanish,\n    ariaMultiLine: booleanish,\n    ariaMultiSelectable: booleanish,\n    ariaOrientation: null,\n    ariaOwns: spaceSeparated,\n    ariaPlaceholder: null,\n    ariaPosInSet: number,\n    ariaPressed: booleanish,\n    ariaReadOnly: booleanish,\n    ariaRelevant: null,\n    ariaRequired: booleanish,\n    ariaRoleDescription: spaceSeparated,\n    ariaRowCount: number,\n    ariaRowIndex: number,\n    ariaRowSpan: number,\n    ariaSelected: booleanish,\n    ariaSetSize: number,\n    ariaSort: null,\n    ariaValueMax: number,\n    ariaValueMin: number,\n    ariaValueNow: number,\n    ariaValueText: null,\n    role: null\n  }\n})\n\nfunction ariaTransform(_, prop) {\n  return prop === 'role' ? prop : 'aria-' + prop.slice(4).toLowerCase()\n}\n","'use strict'\n\nmodule.exports = listItem\n\nvar u = require('unist-builder')\nvar all = require('../all')\n\nfunction listItem(h, node, parent) {\n  var result = all(h, node)\n  var head = result[0]\n  var loose = parent ? listLoose(parent) : listItemLoose(node)\n  var props = {}\n  var wrapped = []\n  var length\n  var index\n  var child\n\n  if (typeof node.checked === 'boolean') {\n    if (!head || head.tagName !== 'p') {\n      head = h(null, 'p', [])\n      result.unshift(head)\n    }\n\n    if (head.children.length > 0) {\n      head.children.unshift(u('text', ' '))\n    }\n\n    head.children.unshift(\n      h(null, 'input', {\n        type: 'checkbox',\n        checked: node.checked,\n        disabled: true\n      })\n    )\n\n    // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n    props.className = ['task-list-item']\n  }\n\n  length = result.length\n  index = -1\n\n  while (++index < length) {\n    child = result[index]\n\n    // Add eols before nodes, except if this is a loose, first paragraph.\n    if (loose || index !== 0 || child.tagName !== 'p') {\n      wrapped.push(u('text', '\\n'))\n    }\n\n    if (child.tagName === 'p' && !loose) {\n      wrapped = wrapped.concat(child.children)\n    } else {\n      wrapped.push(child)\n    }\n  }\n\n  // Add a final eol.\n  if (length && (loose || child.tagName !== 'p')) {\n    wrapped.push(u('text', '\\n'))\n  }\n\n  return h(node, 'li', props, wrapped)\n}\n\nfunction listLoose(node) {\n  var loose = node.spread\n  var children = node.children\n  var length = children.length\n  var index = -1\n\n  while (!loose && ++index < length) {\n    loose = listItemLoose(children[index])\n  }\n\n  return loose\n}\n\nfunction listItemLoose(node) {\n  var spread = node.spread\n\n  return spread === undefined || spread === null\n    ? node.children.length > 1\n    : spread\n}\n","module.exports = html\nhtml.peek = htmlPeek\n\nfunction html(node) {\n  return node.value || ''\n}\n\nfunction htmlPeek() {\n  return '<'\n}\n","'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')\n\nvar attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n}\n\nfunction resolveAllAttention(events, context) {\n  var index = -1\n  var open\n  var group\n  var text\n  var openingSequence\n  var closingSequence\n  var use\n  var nextEvents\n  var offset // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (\n      events[index][0] === 'enter' &&\n      events[index][1].type === 'attentionSequence' &&\n      events[index][1]._close\n    ) {\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 (\n          events[open][0] === 'exit' &&\n          events[open][1].type === 'attentionSequence' &&\n          events[open][1]._open && // If the markers are the same:\n          context.sliceSerialize(events[open][1]).charCodeAt(0) ===\n            context.sliceSerialize(events[index][1]).charCodeAt(0)\n        ) {\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 (\n            (events[open][1]._close || events[index][1]._open) &&\n            (events[index][1].end.offset - events[index][1].start.offset) % 3 &&\n            !(\n              (events[open][1].end.offset -\n                events[open][1].start.offset +\n                events[index][1].end.offset -\n                events[index][1].start.offset) %\n              3\n            )\n          ) {\n            continue\n          } // Number of markers to use from the sequence.\n\n          use =\n            events[open][1].end.offset - events[open][1].start.offset > 1 &&\n            events[index][1].end.offset - events[index][1].start.offset > 1\n              ? 2\n              : 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, [\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context]\n            ])\n          } // Opening.\n\n          nextEvents = chunkedPush(nextEvents, [\n            ['enter', group, context],\n            ['enter', openingSequence, context],\n            ['exit', openingSequence, context],\n            ['enter', text, context]\n          ]) // Between.\n\n          nextEvents = chunkedPush(\n            nextEvents,\n            resolveAll(\n              context.parser.constructs.insideSpan.null,\n              events.slice(open + 1, index),\n              context\n            )\n          ) // Closing.\n\n          nextEvents = chunkedPush(nextEvents, [\n            ['exit', text, context],\n            ['enter', closingSequence, context],\n            ['exit', closingSequence, context],\n            ['exit', group, context]\n          ]) // 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, [\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context]\n            ])\n          } else {\n            offset = 0\n          }\n\n          chunkedSplice(events, open - 1, index - open + 3, nextEvents)\n          index = open + nextEvents.length - offset - 2\n          break\n        }\n      }\n    }\n  } // Remove remaining sequences.\n\n  index = -1\n\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data'\n    }\n  }\n\n  return events\n}\n\nfunction tokenizeAttention(effects, ok) {\n  var before = classifyCharacter(this.previous)\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter('attentionSequence')\n    marker = code\n    return sequence(code)\n  }\n\n  function sequence(code) {\n    var token\n    var after\n    var open\n    var close\n\n    if (code === marker) {\n      effects.consume(code)\n      return sequence\n    }\n\n    token = effects.exit('attentionSequence')\n    after = classifyCharacter(code)\n    open = !after || (after === 2 && before)\n    close = !before || (before === 2 && after)\n    token._open = marker === 42 ? open : open && (before || !close)\n    token._close = marker === 42 ? close : close && (after || !open)\n    return ok(code)\n  }\n}\n\nmodule.exports = attention\n","'use strict'\n\nmodule.exports = Schema\n\nvar proto = Schema.prototype\n\nproto.space = null\nproto.normal = {}\nproto.property = {}\n\nfunction Schema(property, normal, space) {\n  this.property = property\n  this.normal = normal\n\n  if (space) {\n    this.space = space\n  }\n}\n","'use strict'\n\nvar create = require('./util/create')\nvar caseInsensitiveTransform = require('./util/case-insensitive-transform')\n\nmodule.exports = create({\n  space: 'xmlns',\n  attributes: {\n    xmlnsxlink: 'xmlns:xlink'\n  },\n  transform: caseInsensitiveTransform,\n  properties: {\n    xmlns: null,\n    xmlnsXLink: null\n  }\n})\n","module.exports = indentLines\n\nvar eol = /\\r?\\n|\\r/g\n\nfunction indentLines(value, map) {\n  var result = []\n  var start = 0\n  var line = 0\n  var match\n\n  while ((match = eol.exec(value))) {\n    one(value.slice(start, match.index))\n    result.push(match[0])\n    start = match.index + match[0].length\n    line++\n  }\n\n  one(value.slice(start))\n\n  return result.join('')\n\n  function one(value) {\n    result.push(map(value, line, !value))\n  }\n}\n","'use strict'\n\nvar create = require('./util/create')\n\nmodule.exports = create({\n  space: 'xlink',\n  transform: xlinkTransform,\n  properties: {\n    xLinkActuate: null,\n    xLinkArcRole: null,\n    xLinkHref: null,\n    xLinkRole: null,\n    xLinkShow: null,\n    xLinkTitle: null,\n    xLinkType: null\n  }\n})\n\nfunction xlinkTransform(_, prop) {\n  return 'xlink:' + prop.slice(5).toLowerCase()\n}\n","'use strict'\n\nvar create = require('./util/create')\n\nmodule.exports = create({\n  space: 'xml',\n  transform: xmlTransform,\n  properties: {\n    xmlLang: null,\n    xmlBase: null,\n    xmlSpace: null\n  }\n})\n\nfunction xmlTransform(_, prop) {\n  return 'xml:' + prop.slice(3).toLowerCase()\n}\n","'use strict'\nmodule.exports = require('./lib')\n","'use strict'\n\nvar factorySpace = require('./factory-space.js')\n\nvar lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n}\n\nfunction tokenizeLineEnding(effects, ok) {\n  return start\n\n  function start(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, ok, 'linePrefix')\n  }\n}\n\nmodule.exports = lineEnding\n","'use strict'\n\nmodule.exports = html\n\nvar u = require('unist-builder')\n\n// Return either a `raw` node in dangerous mode, otherwise nothing.\nfunction html(h, node) {\n  return h.dangerous ? h.augment(node, u('raw', node.value)) : null\n}\n","'use strict'\n\nmodule.exports = parse\n\nvar fromMarkdown = require('mdast-util-from-markdown')\n\nfunction parse(options) {\n  var self = this\n\n  this.Parser = parse\n\n  function parse(doc) {\n    return fromMarkdown(\n      doc,\n      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  }\n}\n","'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 (\n    code === null ||\n    markdownLineEndingOrSpace(code) ||\n    unicodeWhitespace(code)\n  ) {\n    return 1\n  }\n\n  if (unicodePunctuation(code)) {\n    return 2\n  }\n}\n\nmodule.exports = classifyCharacter\n","module.exports = toMarkdown\n\nvar zwitch = require('zwitch')\nvar configure = require('./configure')\nvar defaultHandlers = require('./handle')\nvar defaultJoin = require('./join')\nvar defaultUnsafe = require('./unsafe')\n\nfunction toMarkdown(tree, options) {\n  var settings = options || {}\n  var context = {\n    enter: enter,\n    stack: [],\n    unsafe: [],\n    join: [],\n    handlers: {},\n    options: {}\n  }\n  var result\n\n  configure(context, {\n    unsafe: defaultUnsafe,\n    join: defaultJoin,\n    handlers: defaultHandlers\n  })\n  configure(context, settings)\n\n  if (context.options.tightDefinitions) {\n    context.join = [joinDefinition].concat(context.join)\n  }\n\n  context.handle = zwitch('type', {\n    invalid: invalid,\n    unknown: unknown,\n    handlers: context.handlers\n  })\n\n  result = context.handle(tree, null, context, {before: '\\n', after: '\\n'})\n\n  if (\n    result &&\n    result.charCodeAt(result.length - 1) !== 10 &&\n    result.charCodeAt(result.length - 1) !== 13\n  ) {\n    result += '\\n'\n  }\n\n  return result\n\n  function enter(name) {\n    context.stack.push(name)\n    return exit\n\n    function exit() {\n      context.stack.pop()\n    }\n  }\n}\n\nfunction invalid(value) {\n  throw new Error('Cannot handle value `' + value + '`, expected node')\n}\n\nfunction unknown(node) {\n  throw new Error('Cannot handle unknown node `' + node.type + '`')\n}\n\nfunction joinDefinition(left, right) {\n  // No blank line between adjacent definitions.\n  if (left.type === 'definition' && left.type === right.type) {\n    return 0\n  }\n}\n","module.exports = inlineCode\ninlineCode.peek = inlineCodePeek\n\nvar patternCompile = require('../util/pattern-compile')\n\nfunction inlineCode(node, parent, context) {\n  var value = node.value || ''\n  var sequence = '`'\n  var index = -1\n  var pattern\n  var expression\n  var match\n  var position\n\n  // If there is a single grave accent on its own in the code, use a fence of\n  // two.\n  // If there are two in a row, use one.\n  while (new RegExp('(^|[^`])' + sequence + '([^`]|$)').test(value)) {\n    sequence += '`'\n  }\n\n  // If this is not just spaces or eols (tabs don’t count), and either the\n  // first or last character are a space, eol, or tick, then pad with spaces.\n  if (\n    /[^ \\r\\n]/.test(value) &&\n    (/[ \\r\\n`]/.test(value.charAt(0)) ||\n      /[ \\r\\n`]/.test(value.charAt(value.length - 1)))\n  ) {\n    value = ' ' + value + ' '\n  }\n\n  // We have a potential problem: certain characters after eols could result in\n  // blocks being seen.\n  // For example, if someone injected the string `'\\n# b'`, then that would\n  // result in an ATX heading.\n  // We can’t escape characters in `inlineCode`, but because eols are\n  // transformed to spaces when going from markdown to HTML anyway, we can swap\n  // them out.\n  while (++index < context.unsafe.length) {\n    pattern = context.unsafe[index]\n\n    // Only look for `atBreak`s.\n    // Btw: note that `atBreak` patterns will always start the regex at LF or\n    // CR.\n    if (!pattern.atBreak) continue\n\n    expression = patternCompile(pattern)\n\n    while ((match = expression.exec(value))) {\n      position = match.index\n\n      // Support CRLF (patterns only look for one of the characters).\n      if (\n        value.charCodeAt(position) === 10 /* `\\n` */ &&\n        value.charCodeAt(position - 1) === 13 /* `\\r` */\n      ) {\n        position--\n      }\n\n      value = value.slice(0, position) + ' ' + value.slice(match.index + 1)\n    }\n  }\n\n  return sequence + value + sequence\n}\n\nfunction inlineCodePeek() {\n  return '`'\n}\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\n\nvar hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n}\n\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start\n\n  function start(code) {\n    effects.enter('hardBreakEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    return open\n  }\n\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker')\n      effects.exit('hardBreakEscape')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = hardBreakEscape\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(\n  effects,\n  ok,\n  nok,\n  type,\n  literalType,\n  literalMarkerType,\n  rawType,\n  stringType,\n  max\n) {\n  var limit = max || Infinity\n  var balance = 0\n  return start\n\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type)\n      effects.enter(literalType)\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      return destinationEnclosedBefore\n    }\n\n    if (asciiControl(code) || code === 41) {\n      return nok(code)\n    }\n\n    effects.enter(type)\n    effects.enter(rawType)\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationRaw(code)\n  }\n\n  function destinationEnclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      effects.exit(literalType)\n      effects.exit(type)\n      return ok\n    }\n\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationEnclosed(code)\n  }\n\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      return destinationEnclosedBefore(code)\n    }\n\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed\n  }\n\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code)\n      return destinationEnclosed\n    }\n\n    return destinationEnclosed(code)\n  }\n\n  function destinationRaw(code) {\n    if (code === 40) {\n      if (++balance > limit) return nok(code)\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === 41) {\n      if (!balance--) {\n        effects.exit('chunkString')\n        effects.exit(stringType)\n        effects.exit(rawType)\n        effects.exit(type)\n        return ok(code)\n      }\n\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      if (balance) return nok(code)\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      effects.exit(rawType)\n      effects.exit(type)\n      return ok(code)\n    }\n\n    if (asciiControl(code)) return nok(code)\n    effects.consume(code)\n    return code === 92 ? destinationRawEscape : destinationRaw\n  }\n\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    return destinationRaw(code)\n  }\n}\n\nmodule.exports = destinationFactory\n","'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiAlpha = regexCheck(/[A-Za-z]/)\n\nmodule.exports = asciiAlpha\n","'use strict'\n\nmodule.exports = blockquote\n\nvar wrap = require('../wrap')\nvar all = require('../all')\n\nfunction blockquote(h, node) {\n  return h(node, 'blockquote', wrap(all(h, node), true))\n}\n","module.exports = checkFence\n\nfunction checkFence(context) {\n  var marker = context.options.fence || '`'\n\n  if (marker !== '`' && marker !== '~') {\n    throw new Error(\n      'Cannot serialize code with `' +\n        marker +\n        '` for `options.fence`, expected `` ` `` or `~`'\n    )\n  }\n\n  return marker\n}\n","module.exports = checkRule\n\nfunction checkRule(context) {\n  var repetition = context.options.ruleRepetition || 3\n\n  if (repetition < 3) {\n    throw new Error(\n      'Cannot serialize rules with repetition `' +\n        repetition +\n        '` for `options.ruleRepetition`, expected `3` or more'\n    )\n  }\n\n  return repetition\n}\n","'use strict'\n\nmodule.exports = one\n\nvar u = require('unist-builder')\nvar all = require('./all')\n\nvar own = {}.hasOwnProperty\n\n// Transform an unknown node.\nfunction unknown(h, node) {\n  if (text(node)) {\n    return h.augment(node, u('text', node.value))\n  }\n\n  return h(node, 'div', all(h, node))\n}\n\n// Visit a node.\nfunction one(h, node, parent) {\n  var type = node && node.type\n  var fn\n\n  // Fail on non-nodes.\n  if (!type) {\n    throw new Error('Expected node, got `' + node + '`')\n  }\n\n  if (own.call(h.handlers, type)) {\n    fn = h.handlers[type]\n  } else if (h.passThrough && h.passThrough.indexOf(type) > -1) {\n    fn = returnNode\n  } else {\n    fn = h.unknownHandler\n  }\n\n  return (typeof fn === 'function' ? fn : unknown)(h, node, parent)\n}\n\n// Check if the node should be renderered as a text node.\nfunction text(node) {\n  var data = node.data || {}\n\n  if (\n    own.call(data, 'hName') ||\n    own.call(data, 'hProperties') ||\n    own.call(data, 'hChildren')\n  ) {\n    return false\n  }\n\n  return 'value' in node\n}\n\nfunction returnNode(h, node) {\n  var clone\n\n  if (node.children) {\n    clone = Object.assign({}, node)\n    clone.children = all(h, node)\n    return clone\n  }\n\n  return node\n}\n","'use strict'\n\n// Counts tabs based on their expanded size, and CR+LF as one character.\n\nfunction sizeChunks(chunks) {\n  var index = -1\n  var size = 0\n\n  while (++index < chunks.length) {\n    size += typeof chunks[index] === 'string' ? chunks[index].length : 1\n  }\n\n  return size\n}\n\nmodule.exports = sizeChunks\n","'use strict'\n\nvar markdownSpace = require('../character/markdown-space.js')\nvar factorySpace = require('./factory-space.js')\n\nvar blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit: exit\n}\n\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  var self = this\n  return start\n\n  function start(code) {\n    if (code === 62) {\n      if (!self.containerState.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        })\n        self.containerState.open = true\n      }\n\n      effects.enter('blockQuotePrefix')\n      effects.enter('blockQuoteMarker')\n      effects.consume(code)\n      effects.exit('blockQuoteMarker')\n      return after\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter('blockQuotePrefixWhitespace')\n      effects.consume(code)\n      effects.exit('blockQuotePrefixWhitespace')\n      effects.exit('blockQuotePrefix')\n      return ok\n    }\n\n    effects.exit('blockQuotePrefix')\n    return ok(code)\n  }\n}\n\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(blockQuote, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.indexOf('codeIndented') > -1\n      ? undefined\n      : 4\n  )\n}\n\nfunction exit(effects) {\n  effects.exit('blockQuote')\n}\n\nmodule.exports = blockQuote\n","'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\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    effects.enter(stringType)\n    return atBreak\n  }\n\n  function atBreak(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      (code === 93 && !data) ||\n      /* c8 ignore next */\n      (code === 94 &&\n        /* c8 ignore next */\n        !size &&\n        /* c8 ignore next */\n        '_hiddenFootnoteSupport' in self.parser.constructs) ||\n      size > 999\n    ) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.exit(stringType)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return atBreak\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return label(code)\n  }\n\n  function label(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      code === 93 ||\n      markdownLineEnding(code) ||\n      size++ > 999\n    ) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n\n    effects.consume(code)\n    data = data || !markdownSpace(code)\n    return code === 92 ? labelEscape : label\n  }\n\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return label\n    }\n\n    return label(code)\n  }\n}\n\nmodule.exports = labelFactory\n","'use strict'\n\nmodule.exports = emphasis\n\nvar all = require('../all')\n\nfunction emphasis(h, node) {\n  return h(node, 'em', all(h, node))\n}\n","'use strict'\n\nmodule.exports = heading\n\nvar all = require('../all')\n\nfunction heading(h, node) {\n  return h(node, 'h' + node.depth, all(h, node))\n}\n","'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiDigit = regexCheck(/\\d/)\n\nmodule.exports = asciiDigit\n","module.exports = root\n\nvar flow = require('../util/container-flow')\n\nfunction root(node, _, context) {\n  return flow(node, context)\n}\n","module.exports = association\n\nvar decode = require('parse-entities/decode-entity')\n\nvar characterEscape = /\\\\([!-/:-@[-`{-~])/g\nvar characterReference = /&(#(\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi\n\n// The `label` of an association is the string value: character escapes and\n// references work, and casing is intact.\n// The `identifier` is used to match one association to another: controversially,\n// character escapes and references don’t work in this matching: `&copy;` does\n// not match `©`, and `\\+` does not match `+`.\n// But casing is ignored (and whitespace) is trimmed and collapsed: ` A\\nb`\n// matches `a b`.\n// So, we do prefer the label when figuring out how we’re going to serialize:\n// it has whitespace, casing, and we can ignore most useless character escapes\n// and all character references.\nfunction association(node) {\n  if (node.label || !node.identifier) {\n    return node.label || ''\n  }\n\n  return node.identifier\n    .replace(characterEscape, '$1')\n    .replace(characterReference, decodeIfPossible)\n}\n\nfunction decodeIfPossible($0, $1) {\n  return decode($1) || $0\n}\n","'use strict'\n\nmodule.exports = footnote\n\nvar footnoteReference = require('./footnote-reference')\n\nfunction footnote(h, node) {\n  var footnoteById = h.footnoteById\n  var footnoteOrder = h.footnoteOrder\n  var identifier = 1\n\n  while (identifier in footnoteById) {\n    identifier++\n  }\n\n  identifier = String(identifier)\n\n  // No need to check if `identifier` exists in `footnoteOrder`, it’s guaranteed\n  // to not exist because we just generated it.\n  footnoteOrder.push(identifier)\n\n  footnoteById[identifier] = {\n    type: 'footnoteDefinition',\n    identifier: identifier,\n    children: [{type: 'paragraph', children: node.children}],\n    position: node.position\n  }\n\n  return footnoteReference(h, {\n    type: 'footnoteReference',\n    identifier: identifier,\n    position: node.position\n  })\n}\n","'use strict'\n\nvar hasOwnProperty = require('../constant/has-own-property.js')\nvar chunkedSplice = require('./chunked-splice.js')\nvar miniflat = require('./miniflat.js')\n\nfunction combineExtensions(extensions) {\n  var all = {}\n  var index = -1\n\n  while (++index < extensions.length) {\n    extension(all, extensions[index])\n  }\n\n  return all\n}\n\nfunction extension(all, extension) {\n  var hook\n  var left\n  var right\n  var code\n\n  for (hook in extension) {\n    left = hasOwnProperty.call(all, hook) ? all[hook] : (all[hook] = {})\n    right = extension[hook]\n\n    for (code in right) {\n      left[code] = constructs(\n        miniflat(right[code]),\n        hasOwnProperty.call(left, code) ? left[code] : []\n      )\n    }\n  }\n}\n\nfunction constructs(list, existing) {\n  var index = -1\n  var before = []\n\n  while (++index < list.length) {\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  chunkedSplice(existing, 0, 0, before)\n  return existing\n}\n\nmodule.exports = combineExtensions\n","'use strict'\n\nvar search = /[\\0\\t\\n\\r]/g\n\nfunction preprocess() {\n  var start = true\n  var column = 1\n  var buffer = ''\n  var atCarriageReturn\n  return preprocessor\n\n  function preprocessor(value, encoding, end) {\n    var chunks = []\n    var match\n    var next\n    var startPosition\n    var endPosition\n    var code\n    value = buffer + value.toString(encoding)\n    startPosition = 0\n    buffer = ''\n\n    if (start) {\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++\n      }\n\n      start = undefined\n    }\n\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition\n      match = search.exec(value)\n      endPosition = match ? match.index : value.length\n      code = value.charCodeAt(endPosition)\n\n      if (!match) {\n        buffer = value.slice(startPosition)\n        break\n      }\n\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3)\n        atCarriageReturn = undefined\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5)\n          atCarriageReturn = undefined\n        }\n\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition))\n          column += endPosition - startPosition\n        }\n\n        if (code === 0) {\n          chunks.push(65533)\n          column++\n        } else if (code === 9) {\n          next = Math.ceil(column / 4) * 4\n          chunks.push(-2)\n\n          while (column++ < next) 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\n      startPosition = endPosition + 1\n    }\n\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5)\n      if (buffer) chunks.push(buffer)\n      chunks.push(null)\n    }\n\n    return chunks\n  }\n}\n\nmodule.exports = preprocess\n","'use strict'\n\nmodule.exports = list\n\nvar wrap = require('../wrap')\nvar all = require('../all')\n\nfunction list(h, node) {\n  var props = {}\n  var name = node.ordered ? 'ol' : 'ul'\n  var items\n  var index = -1\n  var length\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    props.start = node.start\n  }\n\n  items = all(h, node)\n  length = items.length\n\n  // Like GitHub, add a class for custom styling.\n  while (++index < length) {\n    if (\n      items[index].properties.className &&\n      items[index].properties.className.indexOf('task-list-item') !== -1\n    ) {\n      props.className = ['contains-task-list']\n      break\n    }\n  }\n\n  return h(node, name, props, wrap(items, true))\n}\n","'use strict'\n\nfunction miniflat(value) {\n  return value === null || value === undefined\n    ? []\n    : 'length' in value\n    ? value\n    : [value]\n}\n\nmodule.exports = miniflat\n","'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\n\nmodule.exports = asciiPunctuation\n","'use strict'\n\nvar Info = require('./info')\nvar types = require('./types')\n\nmodule.exports = DefinedInfo\n\nDefinedInfo.prototype = new Info()\nDefinedInfo.prototype.defined = true\n\nvar checks = [\n  'boolean',\n  'booleanish',\n  'overloadedBoolean',\n  'number',\n  'commaSeparated',\n  'spaceSeparated',\n  'commaOrSpaceSeparated'\n]\nvar checksLength = checks.length\n\nfunction DefinedInfo(property, attribute, mask, space) {\n  var index = -1\n  var check\n\n  mark(this, 'space', space)\n\n  Info.call(this, property, attribute)\n\n  while (++index < checksLength) {\n    check = checks[index]\n    mark(this, check, (mask & types[check]) === types[check])\n  }\n}\n\nfunction mark(values, key, value) {\n  if (value) {\n    values[key] = value\n  }\n}\n","'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}\n\nfunction tokenizeContent(effects, ok) {\n  var previous\n  return start\n\n  function start(code) {\n    effects.enter('content')\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    })\n    return data(code)\n  }\n\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.check(\n        continuationConstruct,\n        contentContinue,\n        contentEnd\n      )(code)\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n\n  function contentEnd(code) {\n    effects.exit('chunkContent')\n    effects.exit('content')\n    return ok(code)\n  }\n\n  function contentContinue(code) {\n    effects.consume(code)\n    effects.exit('chunkContent')\n    previous = previous.next = effects.enter('chunkContent', {\n      contentType: 'content',\n      previous: previous\n    })\n    return data\n  }\n}\n\nfunction tokenizeContinuation(effects, ok, nok) {\n  var self = this\n  return startLookahead\n\n  function startLookahead(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, prefixed, 'linePrefix')\n  }\n\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    if (\n      self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ||\n      prefixSize(self.events, 'linePrefix') < 4\n    ) {\n      return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)\n    }\n\n    return ok(code)\n  }\n}\n\nmodule.exports = content\n","'use strict'\n\nmodule.exports = imageReference\n\nvar normalize = require('mdurl/encode')\nvar revert = require('../revert')\n\nfunction imageReference(h, node) {\n  var def = h.definition(node.identifier)\n  var props\n\n  if (!def) {\n    return revert(h, node)\n  }\n\n  props = {src: normalize(def.url || ''), alt: node.alt}\n\n  if (def.title !== null && def.title !== undefined) {\n    props.title = def.title\n  }\n\n  return h(node, 'img', props)\n}\n","'use strict'\n\nvar fromCharCode = require('../constant/from-char-code.js')\n\nfunction regexCheck(regex) {\n  return check\n\n  function check(code) {\n    return regex.test(fromCharCode(code))\n  }\n}\n\nmodule.exports = regexCheck\n","module.exports = checkEmphasis\n\nfunction checkEmphasis(context) {\n  var marker = context.options.emphasis || '*'\n\n  if (marker !== '*' && marker !== '_') {\n    throw new Error(\n      'Cannot serialize emphasis with `' +\n        marker +\n        '` for `options.emphasis`, expected `*`, or `_`'\n    )\n  }\n\n  return marker\n}\n","module.exports = text\n\nvar safe = require('../util/safe')\n\nfunction text(node, parent, context, safeOptions) {\n  return safe(context, node.value, safeOptions)\n}\n","module.exports = list\n\nvar flow = require('../util/container-flow')\n\nfunction list(node, _, context) {\n  var exit = context.enter('list')\n  var value = flow(node, context)\n  exit()\n  return value\n}\n","module.exports = checkQuote\n\nfunction checkQuote(context) {\n  var marker = context.options.quote || '\"'\n\n  if (marker !== '\"' && marker !== \"'\") {\n    throw new Error(\n      'Cannot serialize title with `' +\n        marker +\n        '` for `options.quote`, expected `\"`, or `\\'`'\n    )\n  }\n\n  return marker\n}\n","module.exports = imageReference\nimageReference.peek = imageReferencePeek\n\nvar association = require('../util/association')\nvar safe = require('../util/safe')\n\nfunction imageReference(node, _, context) {\n  var type = node.referenceType\n  var exit = context.enter('imageReference')\n  var subexit = context.enter('label')\n  var alt = safe(context, node.alt, {before: '[', after: ']'})\n  var value = '![' + alt + ']'\n  var reference\n  var stack\n\n  subexit()\n  // Hide the fact that we’re in phrasing, because escapes don’t work.\n  stack = context.stack\n  context.stack = []\n  subexit = context.enter('reference')\n  reference = safe(context, association(node), {before: '[', after: ']'})\n  subexit()\n  context.stack = stack\n  exit()\n\n  if (type === 'full' || !alt || alt !== reference) {\n    value += '[' + reference + ']'\n  } else if (type !== 'shortcut') {\n    value += '[]'\n  }\n\n  return value\n}\n\nfunction imageReferencePeek() {\n  return '!'\n}\n","module.exports = paragraph\n\nvar phrasing = require('../util/container-phrasing')\n\nfunction paragraph(node, _, context) {\n  var exit = context.enter('paragraph')\n  var subexit = context.enter('phrasing')\n  var value = phrasing(node, context, {before: '\\n', after: '\\n'})\n  subexit()\n  exit()\n  return value\n}\n","'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar unicodeWhitespace = regexCheck(/\\s/)\n\nmodule.exports = unicodeWhitespace\n","module.exports = phrasing\n\nfunction phrasing(parent, context, safeOptions) {\n  var children = parent.children || []\n  var results = []\n  var index = -1\n  var before = safeOptions.before\n  var after\n  var handle\n  var child\n\n  while (++index < children.length) {\n    child = children[index]\n\n    if (index + 1 < children.length) {\n      handle = context.handle.handlers[children[index + 1].type]\n      if (handle && handle.peek) handle = handle.peek\n      after = handle\n        ? handle(children[index + 1], parent, context, {\n            before: '',\n            after: ''\n          }).charAt(0)\n        : ''\n    } else {\n      after = safeOptions.after\n    }\n\n    // In some cases, html (text) can be found in phrasing right after an eol.\n    // When we’d serialize that, in most cases that would be seen as html\n    // (flow).\n    // As we can’t escape or so to prevent it from happening, we take a somewhat\n    // reasonable approach: replace that eol with a space.\n    // See: <https://github.com/syntax-tree/mdast-util-to-markdown/issues/15>\n    if (\n      results.length > 0 &&\n      (before === '\\r' || before === '\\n') &&\n      child.type === 'html'\n    ) {\n      results[results.length - 1] = results[results.length - 1].replace(\n        /(\\r?\\n|\\r)$/,\n        ' '\n      )\n      before = ' '\n    }\n\n    results.push(\n      context.handle(child, parent, context, {\n        before: before,\n        after: after\n      })\n    )\n\n    before = results[results.length - 1].slice(-1)\n  }\n\n  return results.join('')\n}\n","'use strict'\n\nmodule.exports = caseSensitiveTransform\n\nfunction caseSensitiveTransform(attributes, attribute) {\n  return attribute in attributes ? attributes[attribute] : attribute\n}\n","'use strict'\n\nvar toHast = require('mdast-util-to-hast')\nvar toHtml = require('hast-util-to-html')\nvar sanitize = require('hast-util-sanitize')\n\nmodule.exports = plugin\n\nfunction plugin(options) {\n  var settings = Object.assign({}, options || {})\n  let clean\n\n  if (typeof settings.sanitize === 'boolean') {\n    clean = settings.sanitize\n    settings.sanitize = undefined\n  }\n\n  if (typeof clean !== 'boolean') {\n    clean = true\n  }\n\n  this.Compiler = compiler\n\n  function compiler(node, file) {\n    var root = node && node.type && node.type === 'root'\n    var hast = toHast(node, {\n      allowDangerousHtml: !clean,\n      handlers: settings.handlers\n    })\n    var result\n\n    if (file.extname) {\n      file.extname = '.html'\n    }\n\n    if (clean) {\n      hast = sanitize(hast, settings.sanitize)\n    }\n\n    result = toHtml(\n      hast,\n      Object.assign({}, settings, {allowDangerousHtml: !clean})\n    )\n\n    // Add an eof eol.\n    if (root && result && /[^\\r\\n]/.test(result.charAt(result.length - 1))) {\n      result += '\\n'\n    }\n\n    return result\n  }\n}\n","'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')\n\nfunction fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding\n    encoding = undefined\n  }\n\n  return compiler(options)(\n    postprocess(\n      parser(options).document().write(preprocessor()(value, encoding, true))\n    )\n  )\n}\n\n// Note this compiler only understand complete buffering, not streaming.\nfunction compiler(options) {\n  var settings = options || {}\n  var config = configure(\n    {\n      transforms: [],\n      canContainEols: [\n        'emphasis',\n        'fragment',\n        'heading',\n        'paragraph',\n        'strong'\n      ],\n\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\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    },\n\n    settings.mdastExtensions || []\n  )\n\n  var data = {}\n\n  return compile\n\n  function compile(events) {\n    var tree = {type: 'root', children: []}\n    var stack = [tree]\n    var tokenStack = []\n    var listStack = []\n    var index = -1\n    var handler\n    var listStart\n\n    var context = {\n      stack: stack,\n      tokenStack: tokenStack,\n      config: config,\n      enter: enter,\n      exit: exit,\n      buffer: buffer,\n      resume: resume,\n      setData: setData,\n      getData: getData\n    }\n\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (\n        events[index][1].type === 'listOrdered' ||\n        events[index][1].type === 'listUnordered'\n      ) {\n        if (events[index][0] === 'enter') {\n          listStack.push(index)\n        } else {\n          listStart = listStack.pop(index)\n          index = prepareList(events, listStart, index)\n        }\n      }\n    }\n\n    index = -1\n\n    while (++index < events.length) {\n      handler = config[events[index][0]]\n\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(\n          assign({sliceSerialize: events[index][2].sliceSerialize}, context),\n          events[index][1]\n        )\n      }\n    }\n\n    if (tokenStack.length) {\n      throw new Error(\n        'Cannot close document, a token (`' +\n          tokenStack[tokenStack.length - 1].type +\n          '`, ' +\n          stringifyPosition({\n            start: tokenStack[tokenStack.length - 1].start,\n            end: tokenStack[tokenStack.length - 1].end\n          }) +\n          ') is still open'\n      )\n    }\n\n    // Figure out `root` position.\n    tree.position = {\n      start: point(\n        events.length ? events[0][1].start : {line: 1, column: 1, offset: 0}\n      ),\n\n      end: point(\n        events.length\n          ? events[events.length - 2][1].end\n          : {line: 1, column: 1, offset: 0}\n      )\n    }\n\n    index = -1\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree\n    }\n\n    return tree\n  }\n\n  function prepareList(events, start, length) {\n    var index = start - 1\n    var containerBalance = -1\n    var listSpread = false\n    var listItem\n    var tailIndex\n    var lineIndex\n    var tailEvent\n    var event\n    var firstBlankLineIndex\n    var atMarker\n\n    while (++index <= length) {\n      event = events[index]\n\n      if (\n        event[1].type === 'listUnordered' ||\n        event[1].type === 'listOrdered' ||\n        event[1].type === 'blockQuote'\n      ) {\n        if (event[0] === 'enter') {\n          containerBalance++\n        } else {\n          containerBalance--\n        }\n\n        atMarker = undefined\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (\n            listItem &&\n            !atMarker &&\n            !containerBalance &&\n            !firstBlankLineIndex\n          ) {\n            firstBlankLineIndex = index\n          }\n\n          atMarker = undefined\n        }\n      } else if (\n        event[1].type === 'linePrefix' ||\n        event[1].type === 'listItemValue' ||\n        event[1].type === 'listItemMarker' ||\n        event[1].type === 'listItemPrefix' ||\n        event[1].type === 'listItemPrefixWhitespace'\n      ) {\n        // Empty.\n      } else {\n        atMarker = undefined\n      }\n\n      if (\n        (!containerBalance &&\n          event[0] === 'enter' &&\n          event[1].type === 'listItemPrefix') ||\n        (containerBalance === -1 &&\n          event[0] === 'exit' &&\n          (event[1].type === 'listUnordered' ||\n            event[1].type === 'listOrdered'))\n      ) {\n        if (listItem) {\n          tailIndex = index\n          lineIndex = undefined\n\n          while (tailIndex--) {\n            tailEvent = events[tailIndex]\n\n            if (\n              tailEvent[1].type === 'lineEnding' ||\n              tailEvent[1].type === 'lineEndingBlank'\n            ) {\n              if (tailEvent[0] === 'exit') continue\n\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank'\n                listSpread = true\n              }\n\n              tailEvent[1].type = 'lineEnding'\n              lineIndex = tailIndex\n            } else if (\n              tailEvent[1].type === 'linePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefixWhitespace' ||\n              tailEvent[1].type === 'blockQuoteMarker' ||\n              tailEvent[1].type === 'listItemIndent'\n            ) {\n              // Empty\n            } else {\n              break\n            }\n          }\n\n          if (\n            firstBlankLineIndex &&\n            (!lineIndex || firstBlankLineIndex < lineIndex)\n          ) {\n            listItem._spread = true\n          }\n\n          // Fix position.\n          listItem.end = point(\n            lineIndex ? events[lineIndex][1].start : event[1].end\n          )\n\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\n          events.splice(index, 0, ['enter', listItem, event[2]])\n          index++\n          length++\n          firstBlankLineIndex = undefined\n          atMarker = true\n        }\n      }\n    }\n\n    events[start][1]._spread = listSpread\n    return length\n  }\n\n  function setData(key, value) {\n    data[key] = value\n  }\n\n  function getData(key) {\n    return data[key]\n  }\n\n  function point(d) {\n    return {line: d.line, column: d.column, offset: d.offset}\n  }\n\n  function opener(create, and) {\n    return open\n\n    function open(token) {\n      enter.call(this, create(token), token)\n      if (and) and.call(this, token)\n    }\n  }\n\n  function buffer() {\n    this.stack.push({type: 'fragment', 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 = {start: point(token.start)}\n    return node\n  }\n\n  function closer(and) {\n    return close\n\n    function close(token) {\n      if (and) and.call(this, token)\n      exit.call(this, token)\n    }\n  }\n\n  function exit(token) {\n    var node = this.stack.pop()\n    var open = this.tokenStack.pop()\n\n    if (!open) {\n      throw new Error(\n        'Cannot close `' +\n          token.type +\n          '` (' +\n          stringifyPosition({start: token.start, end: token.end}) +\n          '): it’s not open'\n      )\n    } else if (open.type !== token.type) {\n      throw new Error(\n        'Cannot close `' +\n          token.type +\n          '` (' +\n          stringifyPosition({start: token.start, end: token.end}) +\n          '): a different token (`' +\n          open.type +\n          '`, ' +\n          stringifyPosition({start: open.start, end: open.end}) +\n          ') is open'\n      )\n    }\n\n    node.position.end = point(token.end)\n    return node\n  }\n\n  function resume() {\n    return toString(this.stack.pop())\n  }\n\n  //\n  // Handlers.\n  //\n\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true)\n  }\n\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      this.stack[this.stack.length - 2].start = parseInt(\n        this.sliceSerialize(token),\n        10\n      )\n\n      setData('expectingFirstListItemValue')\n    }\n  }\n\n  function onexitcodefencedfenceinfo() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].lang = data\n  }\n\n  function onexitcodefencedfencemeta() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].meta = data\n  }\n\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (getData('flowCodeInside')) return\n    this.buffer()\n    setData('flowCodeInside', true)\n  }\n\n  function onexitcodefenced() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data.replace(\n      /^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g,\n      ''\n    )\n\n    setData('flowCodeInside')\n  }\n\n  function onexitcodeindented() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data\n  }\n\n  function onexitdefinitionlabelstring(token) {\n    // Discard label, use the source content instead.\n    var label = this.resume()\n    this.stack[this.stack.length - 1].label = label\n    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n  }\n\n  function onexitdefinitiontitlestring() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].title = data\n  }\n\n  function onexitdefinitiondestinationstring() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].url = data\n  }\n\n  function onexitatxheadingsequence(token) {\n    if (!this.stack[this.stack.length - 1].depth) {\n      this.stack[this.stack.length - 1].depth = this.sliceSerialize(\n        token\n      ).length\n    }\n  }\n\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true)\n  }\n\n  function onexitsetextheadinglinesequence(token) {\n    this.stack[this.stack.length - 1].depth =\n      this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2\n  }\n\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding')\n  }\n\n  function onenterdata(token) {\n    var siblings = this.stack[this.stack.length - 1].children\n    var tail = siblings[siblings.length - 1]\n\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text()\n      tail.position = {start: point(token.start)}\n      this.stack[this.stack.length - 1].children.push(tail)\n    }\n\n    this.stack.push(tail)\n  }\n\n  function onexitdata(token) {\n    var tail = this.stack.pop()\n    tail.value += this.sliceSerialize(token)\n    tail.position.end = point(token.end)\n  }\n\n  function onexitlineending(token) {\n    var context = this.stack[this.stack.length - 1]\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(\n        token.end\n      )\n\n      setData('atHardBreak')\n      return\n    }\n\n    if (\n      !getData('setextHeadingSlurpLineEnding') &&\n      config.canContainEols.indexOf(context.type) > -1\n    ) {\n      onenterdata.call(this, token)\n      onexitdata.call(this, token)\n    }\n  }\n\n  function onexithardbreak() {\n    setData('atHardBreak', true)\n  }\n\n  function onexithtmlflow() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data\n  }\n\n  function onexithtmltext() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data\n  }\n\n  function onexitcodetext() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].value = data\n  }\n\n  function onexitlink() {\n    var context = this.stack[this.stack.length - 1]\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\n    setData('referenceType')\n  }\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\n    setData('referenceType')\n  }\n\n  function onexitlabeltext(token) {\n    this.stack[this.stack.length - 2].identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n  }\n\n  function onexitlabel() {\n    var fragment = this.stack[this.stack.length - 1]\n    var value = this.resume()\n\n    this.stack[this.stack.length - 1].label = value\n\n    // Assume a reference.\n    setData('inReference', true)\n\n    if (this.stack[this.stack.length - 1].type === 'link') {\n      this.stack[this.stack.length - 1].children = fragment.children\n    } else {\n      this.stack[this.stack.length - 1].alt = value\n    }\n  }\n\n  function onexitresourcedestinationstring() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].url = data\n  }\n\n  function onexitresourcetitlestring() {\n    var data = this.resume()\n    this.stack[this.stack.length - 1].title = data\n  }\n\n  function onexitresource() {\n    setData('inReference')\n  }\n\n  function onenterreference() {\n    setData('referenceType', 'collapsed')\n  }\n\n  function onexitreferencestring(token) {\n    var label = this.resume()\n    this.stack[this.stack.length - 1].label = label\n    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n    setData('referenceType', 'full')\n  }\n\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type)\n  }\n\n  function onexitcharacterreferencevalue(token) {\n    var data = this.sliceSerialize(token)\n    var type = getData('characterReferenceType')\n    var value\n    var tail\n\n    if (type) {\n      value = safeFromInt(\n        data,\n        type === 'characterReferenceMarkerNumeric' ? 10 : 16\n      )\n\n      setData('characterReferenceType')\n    } else {\n      value = decode(data)\n    }\n\n    tail = this.stack.pop()\n    tail.value += value\n    tail.position.end = point(token.end)\n  }\n\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token)\n    this.stack[this.stack.length - 1].url = this.sliceSerialize(token)\n  }\n\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token)\n    this.stack[this.stack.length - 1].url =\n      'mailto:' + this.sliceSerialize(token)\n  }\n\n  //\n  // Creaters.\n  //\n\n  function blockQuote() {\n    return {type: 'blockquote', children: []}\n  }\n\n  function codeFlow() {\n    return {type: 'code', lang: null, meta: null, value: ''}\n  }\n\n  function codeText() {\n    return {type: 'inlineCode', value: ''}\n  }\n\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    }\n  }\n\n  function emphasis() {\n    return {type: 'emphasis', children: []}\n  }\n\n  function heading() {\n    return {type: 'heading', depth: undefined, children: []}\n  }\n\n  function hardBreak() {\n    return {type: 'break'}\n  }\n\n  function html() {\n    return {type: 'html', value: ''}\n  }\n\n  function image() {\n    return {type: 'image', title: null, url: '', alt: null}\n  }\n\n  function link() {\n    return {type: 'link', title: null, url: '', 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\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    }\n  }\n\n  function paragraph() {\n    return {type: 'paragraph', children: []}\n  }\n\n  function strong() {\n    return {type: 'strong', children: []}\n  }\n\n  function text() {\n    return {type: 'text', value: ''}\n  }\n\n  function thematicBreak() {\n    return {type: 'thematicBreak'}\n  }\n}\n\nfunction configure(config, extensions) {\n  var index = -1\n\n  while (++index < extensions.length) {\n    extension(config, extensions[index])\n  }\n\n  return config\n}\n\nfunction extension(config, extension) {\n  var key\n  var left\n\n  for (key in extension) {\n    left = own.call(config, key) ? config[key] : (config[key] = {})\n\n    if (key === 'canContainEols' || key === 'transforms') {\n      config[key] = [].concat(left, extension[key])\n    } else {\n      Object.assign(left, extension[key])\n    }\n  }\n}\n","\n'use strict';\n\n\nvar encodeCache = {};\n\n\n// Create a lookup array where anything but characters in `chars` string\n// and alphanumeric chars is percent-encoded.\n//\nfunction getEncodeCache(exclude) {\n  var i, ch, cache = encodeCache[exclude];\n  if (cache) { return cache; }\n\n  cache = encodeCache[exclude] = [];\n\n  for (i = 0; i < 128; i++) {\n    ch = String.fromCharCode(i);\n\n    if (/^[0-9a-z]$/i.test(ch)) {\n      // always allow unencoded alphanumeric characters\n      cache.push(ch);\n    } else {\n      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));\n    }\n  }\n\n  for (i = 0; i < exclude.length; i++) {\n    cache[exclude.charCodeAt(i)] = exclude[i];\n  }\n\n  return cache;\n}\n\n\n// Encode unsafe characters with percent-encoding, skipping already\n// encoded sequences.\n//\n//  - string       - string to encode\n//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)\n//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)\n//\nfunction encode(string, exclude, keepEscaped) {\n  var i, l, code, nextCode, cache,\n      result = '';\n\n  if (typeof exclude !== 'string') {\n    // encode(string, keepEscaped)\n    keepEscaped  = exclude;\n    exclude = encode.defaultChars;\n  }\n\n  if (typeof keepEscaped === 'undefined') {\n    keepEscaped = true;\n  }\n\n  cache = getEncodeCache(exclude);\n\n  for (i = 0, l = string.length; i < l; i++) {\n    code = string.charCodeAt(i);\n\n    if (keepEscaped && code === 0x25 /* % */ && i + 2 < l) {\n      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {\n        result += string.slice(i, i + 3);\n        i += 2;\n        continue;\n      }\n    }\n\n    if (code < 128) {\n      result += cache[code];\n      continue;\n    }\n\n    if (code >= 0xD800 && code <= 0xDFFF) {\n      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {\n        nextCode = string.charCodeAt(i + 1);\n        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {\n          result += encodeURIComponent(string[i] + string[i + 1]);\n          i++;\n          continue;\n        }\n      }\n      result += '%EF%BF%BD';\n      continue;\n    }\n\n    result += encodeURIComponent(string[i]);\n  }\n\n  return result;\n}\n\nencode.defaultChars   = \";/?:@&=+$,-_.!~*'()#\";\nencode.componentChars = \"-_.!~*'()\";\n\n\nmodule.exports = encode;\n","module.exports = blockquote\n\nvar flow = require('../util/container-flow')\nvar indentLines = require('../util/indent-lines')\n\nfunction blockquote(node, _, context) {\n  var exit = context.enter('blockquote')\n  var value = indentLines(flow(node, context), map)\n  exit()\n  return value\n}\n\nfunction map(line, index, blank) {\n  return '>' + (blank ? '' : ' ') + line\n}\n","'use strict'\n\nvar markdownSpace = require('../character/markdown-space.js')\n\nfunction spaceFactory(effects, ok, type, max) {\n  var limit = max ? max - 1 : Infinity\n  var size = 0\n  return start\n\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n\n    return ok(code)\n  }\n\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n\n    effects.exit(type)\n    return ok(code)\n  }\n}\n\nmodule.exports = spaceFactory\n","'use strict'\n\nvar caseSensitiveTransform = require('./case-sensitive-transform')\n\nmodule.exports = caseInsensitiveTransform\n\nfunction caseInsensitiveTransform(attributes, property) {\n  return caseSensitiveTransform(attributes, property.toLowerCase())\n}\n","'use strict'\n\nvar types = require('./util/types')\nvar create = require('./util/create')\nvar caseSensitiveTransform = require('./util/case-sensitive-transform')\n\nvar boolean = types.boolean\nvar number = types.number\nvar spaceSeparated = types.spaceSeparated\nvar commaSeparated = types.commaSeparated\nvar commaOrSpaceSeparated = types.commaOrSpaceSeparated\n\nmodule.exports = create({\n  space: 'svg',\n  attributes: {\n    accentHeight: 'accent-height',\n    alignmentBaseline: 'alignment-baseline',\n    arabicForm: 'arabic-form',\n    baselineShift: 'baseline-shift',\n    capHeight: 'cap-height',\n    className: 'class',\n    clipPath: 'clip-path',\n    clipRule: 'clip-rule',\n    colorInterpolation: 'color-interpolation',\n    colorInterpolationFilters: 'color-interpolation-filters',\n    colorProfile: 'color-profile',\n    colorRendering: 'color-rendering',\n    crossOrigin: 'crossorigin',\n    dataType: 'datatype',\n    dominantBaseline: 'dominant-baseline',\n    enableBackground: 'enable-background',\n    fillOpacity: 'fill-opacity',\n    fillRule: 'fill-rule',\n    floodColor: 'flood-color',\n    floodOpacity: 'flood-opacity',\n    fontFamily: 'font-family',\n    fontSize: 'font-size',\n    fontSizeAdjust: 'font-size-adjust',\n    fontStretch: 'font-stretch',\n    fontStyle: 'font-style',\n    fontVariant: 'font-variant',\n    fontWeight: 'font-weight',\n    glyphName: 'glyph-name',\n    glyphOrientationHorizontal: 'glyph-orientation-horizontal',\n    glyphOrientationVertical: 'glyph-orientation-vertical',\n    hrefLang: 'hreflang',\n    horizAdvX: 'horiz-adv-x',\n    horizOriginX: 'horiz-origin-x',\n    horizOriginY: 'horiz-origin-y',\n    imageRendering: 'image-rendering',\n    letterSpacing: 'letter-spacing',\n    lightingColor: 'lighting-color',\n    markerEnd: 'marker-end',\n    markerMid: 'marker-mid',\n    markerStart: 'marker-start',\n    navDown: 'nav-down',\n    navDownLeft: 'nav-down-left',\n    navDownRight: 'nav-down-right',\n    navLeft: 'nav-left',\n    navNext: 'nav-next',\n    navPrev: 'nav-prev',\n    navRight: 'nav-right',\n    navUp: 'nav-up',\n    navUpLeft: 'nav-up-left',\n    navUpRight: 'nav-up-right',\n    onAbort: 'onabort',\n    onActivate: 'onactivate',\n    onAfterPrint: 'onafterprint',\n    onBeforePrint: 'onbeforeprint',\n    onBegin: 'onbegin',\n    onCancel: 'oncancel',\n    onCanPlay: 'oncanplay',\n    onCanPlayThrough: 'oncanplaythrough',\n    onChange: 'onchange',\n    onClick: 'onclick',\n    onClose: 'onclose',\n    onCopy: 'oncopy',\n    onCueChange: 'oncuechange',\n    onCut: 'oncut',\n    onDblClick: 'ondblclick',\n    onDrag: 'ondrag',\n    onDragEnd: 'ondragend',\n    onDragEnter: 'ondragenter',\n    onDragExit: 'ondragexit',\n    onDragLeave: 'ondragleave',\n    onDragOver: 'ondragover',\n    onDragStart: 'ondragstart',\n    onDrop: 'ondrop',\n    onDurationChange: 'ondurationchange',\n    onEmptied: 'onemptied',\n    onEnd: 'onend',\n    onEnded: 'onended',\n    onError: 'onerror',\n    onFocus: 'onfocus',\n    onFocusIn: 'onfocusin',\n    onFocusOut: 'onfocusout',\n    onHashChange: 'onhashchange',\n    onInput: 'oninput',\n    onInvalid: 'oninvalid',\n    onKeyDown: 'onkeydown',\n    onKeyPress: 'onkeypress',\n    onKeyUp: 'onkeyup',\n    onLoad: 'onload',\n    onLoadedData: 'onloadeddata',\n    onLoadedMetadata: 'onloadedmetadata',\n    onLoadStart: 'onloadstart',\n    onMessage: 'onmessage',\n    onMouseDown: 'onmousedown',\n    onMouseEnter: 'onmouseenter',\n    onMouseLeave: 'onmouseleave',\n    onMouseMove: 'onmousemove',\n    onMouseOut: 'onmouseout',\n    onMouseOver: 'onmouseover',\n    onMouseUp: 'onmouseup',\n    onMouseWheel: 'onmousewheel',\n    onOffline: 'onoffline',\n    onOnline: 'ononline',\n    onPageHide: 'onpagehide',\n    onPageShow: 'onpageshow',\n    onPaste: 'onpaste',\n    onPause: 'onpause',\n    onPlay: 'onplay',\n    onPlaying: 'onplaying',\n    onPopState: 'onpopstate',\n    onProgress: 'onprogress',\n    onRateChange: 'onratechange',\n    onRepeat: 'onrepeat',\n    onReset: 'onreset',\n    onResize: 'onresize',\n    onScroll: 'onscroll',\n    onSeeked: 'onseeked',\n    onSeeking: 'onseeking',\n    onSelect: 'onselect',\n    onShow: 'onshow',\n    onStalled: 'onstalled',\n    onStorage: 'onstorage',\n    onSubmit: 'onsubmit',\n    onSuspend: 'onsuspend',\n    onTimeUpdate: 'ontimeupdate',\n    onToggle: 'ontoggle',\n    onUnload: 'onunload',\n    onVolumeChange: 'onvolumechange',\n    onWaiting: 'onwaiting',\n    onZoom: 'onzoom',\n    overlinePosition: 'overline-position',\n    overlineThickness: 'overline-thickness',\n    paintOrder: 'paint-order',\n    panose1: 'panose-1',\n    pointerEvents: 'pointer-events',\n    referrerPolicy: 'referrerpolicy',\n    renderingIntent: 'rendering-intent',\n    shapeRendering: 'shape-rendering',\n    stopColor: 'stop-color',\n    stopOpacity: 'stop-opacity',\n    strikethroughPosition: 'strikethrough-position',\n    strikethroughThickness: 'strikethrough-thickness',\n    strokeDashArray: 'stroke-dasharray',\n    strokeDashOffset: 'stroke-dashoffset',\n    strokeLineCap: 'stroke-linecap',\n    strokeLineJoin: 'stroke-linejoin',\n    strokeMiterLimit: 'stroke-miterlimit',\n    strokeOpacity: 'stroke-opacity',\n    strokeWidth: 'stroke-width',\n    tabIndex: 'tabindex',\n    textAnchor: 'text-anchor',\n    textDecoration: 'text-decoration',\n    textRendering: 'text-rendering',\n    typeOf: 'typeof',\n    underlinePosition: 'underline-position',\n    underlineThickness: 'underline-thickness',\n    unicodeBidi: 'unicode-bidi',\n    unicodeRange: 'unicode-range',\n    unitsPerEm: 'units-per-em',\n    vAlphabetic: 'v-alphabetic',\n    vHanging: 'v-hanging',\n    vIdeographic: 'v-ideographic',\n    vMathematical: 'v-mathematical',\n    vectorEffect: 'vector-effect',\n    vertAdvY: 'vert-adv-y',\n    vertOriginX: 'vert-origin-x',\n    vertOriginY: 'vert-origin-y',\n    wordSpacing: 'word-spacing',\n    writingMode: 'writing-mode',\n    xHeight: 'x-height',\n    // These were camelcased in Tiny. Now lowercased in SVG 2\n    playbackOrder: 'playbackorder',\n    timelineBegin: 'timelinebegin'\n  },\n  transform: caseSensitiveTransform,\n  properties: {\n    about: commaOrSpaceSeparated,\n    accentHeight: number,\n    accumulate: null,\n    additive: null,\n    alignmentBaseline: null,\n    alphabetic: number,\n    amplitude: number,\n    arabicForm: null,\n    ascent: number,\n    attributeName: null,\n    attributeType: null,\n    azimuth: number,\n    bandwidth: null,\n    baselineShift: null,\n    baseFrequency: null,\n    baseProfile: null,\n    bbox: null,\n    begin: null,\n    bias: number,\n    by: null,\n    calcMode: null,\n    capHeight: number,\n    className: spaceSeparated,\n    clip: null,\n    clipPath: null,\n    clipPathUnits: null,\n    clipRule: null,\n    color: null,\n    colorInterpolation: null,\n    colorInterpolationFilters: null,\n    colorProfile: null,\n    colorRendering: null,\n    content: null,\n    contentScriptType: null,\n    contentStyleType: null,\n    crossOrigin: null,\n    cursor: null,\n    cx: null,\n    cy: null,\n    d: null,\n    dataType: null,\n    defaultAction: null,\n    descent: number,\n    diffuseConstant: number,\n    direction: null,\n    display: null,\n    dur: null,\n    divisor: number,\n    dominantBaseline: null,\n    download: boolean,\n    dx: null,\n    dy: null,\n    edgeMode: null,\n    editable: null,\n    elevation: number,\n    enableBackground: null,\n    end: null,\n    event: null,\n    exponent: number,\n    externalResourcesRequired: null,\n    fill: null,\n    fillOpacity: number,\n    fillRule: null,\n    filter: null,\n    filterRes: null,\n    filterUnits: null,\n    floodColor: null,\n    floodOpacity: null,\n    focusable: null,\n    focusHighlight: null,\n    fontFamily: null,\n    fontSize: null,\n    fontSizeAdjust: null,\n    fontStretch: null,\n    fontStyle: null,\n    fontVariant: null,\n    fontWeight: null,\n    format: null,\n    fr: null,\n    from: null,\n    fx: null,\n    fy: null,\n    g1: commaSeparated,\n    g2: commaSeparated,\n    glyphName: commaSeparated,\n    glyphOrientationHorizontal: null,\n    glyphOrientationVertical: null,\n    glyphRef: null,\n    gradientTransform: null,\n    gradientUnits: null,\n    handler: null,\n    hanging: number,\n    hatchContentUnits: null,\n    hatchUnits: null,\n    height: null,\n    href: null,\n    hrefLang: null,\n    horizAdvX: number,\n    horizOriginX: number,\n    horizOriginY: number,\n    id: null,\n    ideographic: number,\n    imageRendering: null,\n    initialVisibility: null,\n    in: null,\n    in2: null,\n    intercept: number,\n    k: number,\n    k1: number,\n    k2: number,\n    k3: number,\n    k4: number,\n    kernelMatrix: commaOrSpaceSeparated,\n    kernelUnitLength: null,\n    keyPoints: null, // SEMI_COLON_SEPARATED\n    keySplines: null, // SEMI_COLON_SEPARATED\n    keyTimes: null, // SEMI_COLON_SEPARATED\n    kerning: null,\n    lang: null,\n    lengthAdjust: null,\n    letterSpacing: null,\n    lightingColor: null,\n    limitingConeAngle: number,\n    local: null,\n    markerEnd: null,\n    markerMid: null,\n    markerStart: null,\n    markerHeight: null,\n    markerUnits: null,\n    markerWidth: null,\n    mask: null,\n    maskContentUnits: null,\n    maskUnits: null,\n    mathematical: null,\n    max: null,\n    media: null,\n    mediaCharacterEncoding: null,\n    mediaContentEncodings: null,\n    mediaSize: number,\n    mediaTime: null,\n    method: null,\n    min: null,\n    mode: null,\n    name: null,\n    navDown: null,\n    navDownLeft: null,\n    navDownRight: null,\n    navLeft: null,\n    navNext: null,\n    navPrev: null,\n    navRight: null,\n    navUp: null,\n    navUpLeft: null,\n    navUpRight: null,\n    numOctaves: null,\n    observer: null,\n    offset: null,\n    onAbort: null,\n    onActivate: null,\n    onAfterPrint: null,\n    onBeforePrint: null,\n    onBegin: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnd: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFocusIn: null,\n    onFocusOut: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onMouseWheel: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRepeat: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onShow: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onZoom: null,\n    opacity: null,\n    operator: null,\n    order: null,\n    orient: null,\n    orientation: null,\n    origin: null,\n    overflow: null,\n    overlay: null,\n    overlinePosition: number,\n    overlineThickness: number,\n    paintOrder: null,\n    panose1: null,\n    path: null,\n    pathLength: number,\n    patternContentUnits: null,\n    patternTransform: null,\n    patternUnits: null,\n    phase: null,\n    ping: spaceSeparated,\n    pitch: null,\n    playbackOrder: null,\n    pointerEvents: null,\n    points: null,\n    pointsAtX: number,\n    pointsAtY: number,\n    pointsAtZ: number,\n    preserveAlpha: null,\n    preserveAspectRatio: null,\n    primitiveUnits: null,\n    propagate: null,\n    property: commaOrSpaceSeparated,\n    r: null,\n    radius: null,\n    referrerPolicy: null,\n    refX: null,\n    refY: null,\n    rel: commaOrSpaceSeparated,\n    rev: commaOrSpaceSeparated,\n    renderingIntent: null,\n    repeatCount: null,\n    repeatDur: null,\n    requiredExtensions: commaOrSpaceSeparated,\n    requiredFeatures: commaOrSpaceSeparated,\n    requiredFonts: commaOrSpaceSeparated,\n    requiredFormats: commaOrSpaceSeparated,\n    resource: null,\n    restart: null,\n    result: null,\n    rotate: null,\n    rx: null,\n    ry: null,\n    scale: null,\n    seed: null,\n    shapeRendering: null,\n    side: null,\n    slope: null,\n    snapshotTime: null,\n    specularConstant: number,\n    specularExponent: number,\n    spreadMethod: null,\n    spacing: null,\n    startOffset: null,\n    stdDeviation: null,\n    stemh: null,\n    stemv: null,\n    stitchTiles: null,\n    stopColor: null,\n    stopOpacity: null,\n    strikethroughPosition: number,\n    strikethroughThickness: number,\n    string: null,\n    stroke: null,\n    strokeDashArray: commaOrSpaceSeparated,\n    strokeDashOffset: null,\n    strokeLineCap: null,\n    strokeLineJoin: null,\n    strokeMiterLimit: number,\n    strokeOpacity: number,\n    strokeWidth: null,\n    style: null,\n    surfaceScale: number,\n    syncBehavior: null,\n    syncBehaviorDefault: null,\n    syncMaster: null,\n    syncTolerance: null,\n    syncToleranceDefault: null,\n    systemLanguage: commaOrSpaceSeparated,\n    tabIndex: number,\n    tableValues: null,\n    target: null,\n    targetX: number,\n    targetY: number,\n    textAnchor: null,\n    textDecoration: null,\n    textRendering: null,\n    textLength: null,\n    timelineBegin: null,\n    title: null,\n    transformBehavior: null,\n    type: null,\n    typeOf: commaOrSpaceSeparated,\n    to: null,\n    transform: null,\n    u1: null,\n    u2: null,\n    underlinePosition: number,\n    underlineThickness: number,\n    unicode: null,\n    unicodeBidi: null,\n    unicodeRange: null,\n    unitsPerEm: number,\n    values: null,\n    vAlphabetic: number,\n    vMathematical: number,\n    vectorEffect: null,\n    vHanging: number,\n    vIdeographic: number,\n    version: null,\n    vertAdvY: number,\n    vertOriginX: number,\n    vertOriginY: number,\n    viewBox: null,\n    viewTarget: null,\n    visibility: null,\n    width: null,\n    widths: null,\n    wordSpacing: null,\n    writingMode: null,\n    x: null,\n    x1: null,\n    x2: null,\n    xChannelSelector: null,\n    xHeight: number,\n    y: null,\n    y1: null,\n    y2: null,\n    yChannelSelector: null,\n    z: null,\n    zoomAndPan: null\n  }\n})\n","module.exports = require('./lib')\n","module.exports = linkReference\nlinkReference.peek = linkReferencePeek\n\nvar association = require('../util/association')\nvar phrasing = require('../util/container-phrasing')\nvar safe = require('../util/safe')\n\nfunction linkReference(node, _, context) {\n  var type = node.referenceType\n  var exit = context.enter('linkReference')\n  var subexit = context.enter('label')\n  var text = phrasing(node, context, {before: '[', after: ']'})\n  var value = '[' + text + ']'\n  var reference\n  var stack\n\n  subexit()\n  // Hide the fact that we’re in phrasing, because escapes don’t work.\n  stack = context.stack\n  context.stack = []\n  subexit = context.enter('reference')\n  reference = safe(context, association(node), {before: '[', after: ']'})\n  subexit()\n  context.stack = stack\n  exit()\n\n  if (type === 'full' || !text || text !== reference) {\n    value += '[' + reference + ']'\n  } else if (type !== 'shortcut') {\n    value += '[]'\n  }\n\n  return value\n}\n\nfunction linkReferencePeek() {\n  return '['\n}\n","'use strict'\n\nvar xtend = require('xtend')\nvar Schema = require('./schema')\n\nmodule.exports = merge\n\nfunction merge(definitions) {\n  var length = definitions.length\n  var property = []\n  var normal = []\n  var index = -1\n  var info\n  var space\n\n  while (++index < length) {\n    info = definitions[index]\n    property.push(info.property)\n    normal.push(info.normal)\n    space = info.space\n  }\n\n  return new Schema(\n    xtend.apply(null, property),\n    xtend.apply(null, normal),\n    space\n  )\n}\n","'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')\n\nfunction parse(options) {\n  var settings = options || {}\n  var parser = {\n    defined: [],\n    constructs: combineExtensions(\n      [constructs].concat(miniflat(settings.extensions))\n    ),\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(text.string),\n    text: create(text.text)\n  }\n  return parser\n\n  function create(initializer) {\n    return creator\n\n    function creator(from) {\n      return createTokenizer(parser, initializer, from)\n    }\n  }\n}\n\nmodule.exports = parse\n","'use strict'\n\nvar splice = [].splice\n\nmodule.exports = splice\n","'use strict'\n\nObject.defineProperty(exports, '__esModule', {value: true})\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar factorySpace = require('../tokenize/factory-space.js')\n\nvar tokenize = initializeContent\n\nfunction initializeContent(effects) {\n  var contentStart = effects.attempt(\n    this.parser.constructs.contentInitial,\n    afterContentStartConstruct,\n    paragraphInitial\n  )\n  var previous\n  return contentStart\n\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, contentStart, 'linePrefix')\n  }\n\n  function paragraphInitial(code) {\n    effects.enter('paragraph')\n    return lineStart(code)\n  }\n\n  function lineStart(code) {\n    var token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous: previous\n    })\n\n    if (previous) {\n      previous.next = token\n    }\n\n    previous = token\n    return data(code)\n  }\n\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText')\n      effects.exit('paragraph')\n      effects.consume(code)\n      return\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      effects.exit('chunkText')\n      return lineStart\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n}\n\nexports.tokenize = tokenize\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownSpace = require('../character/markdown-space.js')\nvar factorySpace = require('./factory-space.js')\n\nfunction whitespaceFactory(effects, ok) {\n  var seen\n  return start\n\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      seen = true\n      return start\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        start,\n        seen ? 'linePrefix' : 'lineSuffix'\n      )(code)\n    }\n\n    return ok(code)\n  }\n}\n\nmodule.exports = whitespaceFactory\n","'use strict'\n\nvar subtokenize = require('./util/subtokenize.js')\n\nfunction postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n\n  return events\n}\n\nmodule.exports = postprocess\n","'use strict'\n\nmodule.exports = paragraph\n\nvar all = require('../all')\n\nfunction paragraph(h, node) {\n  return h(node, 'p', all(h, node))\n}\n","'use strict'\n\nfunction markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\n}\n\nmodule.exports = markdownSpace\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\n  if (startIndex === endIndex) {\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]\n  } else {\n    view = chunks.slice(startIndex, endIndex)\n\n    if (startBufferIndex > -1) {\n      view[0] = view[0].slice(startBufferIndex)\n    }\n\n    if (endBufferIndex > 0) {\n      view.push(chunks[endIndex].slice(0, endBufferIndex))\n    }\n  }\n\n  return view\n}\n\nmodule.exports = sliceChunks\n","'use strict'\n\nvar visit = require('unist-util-visit')\n\nmodule.exports = getDefinitionFactory\n\nvar own = {}.hasOwnProperty\n\n// Get a definition in `node` by `identifier`.\nfunction getDefinitionFactory(node, options) {\n  return getterFactory(gather(node, options))\n}\n\n// Gather all definitions in `node`\nfunction gather(node) {\n  var cache = {}\n\n  if (!node || !node.type) {\n    throw new Error('mdast-util-definitions expected node')\n  }\n\n  visit(node, 'definition', ondefinition)\n\n  return cache\n\n  function ondefinition(definition) {\n    var id = normalise(definition.identifier)\n    if (!own.call(cache, id)) {\n      cache[id] = definition\n    }\n  }\n}\n\n// Factory to get a node from the given definition-cache.\nfunction getterFactory(cache) {\n  return getter\n\n  // Get a node from the bound definition-cache.\n  function getter(identifier) {\n    var id = identifier && normalise(identifier)\n    return id && own.call(cache, id) ? cache[id] : null\n  }\n}\n\nfunction normalise(identifier) {\n  return identifier.toUpperCase()\n}\n","'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')\n\nvar htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n}\n\nfunction tokenizeHtmlText(effects, ok, nok) {\n  var self = this\n  var marker\n  var buffer\n  var index\n  var returnState\n  return start\n\n  function start(code) {\n    effects.enter('htmlText')\n    effects.enter('htmlTextData')\n    effects.consume(code)\n    return open\n  }\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationOpen\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instruction\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    return nok(code)\n  }\n\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentOpen\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpen\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return declaration\n    }\n\n    return nok(code)\n  }\n\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentStart\n    }\n\n    return nok(code)\n  }\n\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentStartDash\n    }\n\n    return comment(code)\n  }\n\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    return comment(code)\n  }\n\n  function comment(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = comment\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return comment\n  }\n\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return end\n    }\n\n    return comment(code)\n  }\n\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length ? cdata : cdataOpen\n    }\n\n    return nok(code)\n  }\n\n  function cdata(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = cdata\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return cdata\n  }\n\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = declaration\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return declaration\n  }\n\n  function instruction(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instructionClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = instruction\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return instruction\n  }\n\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code)\n  }\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return nok(code)\n  }\n\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return tagCloseBetween(code)\n  }\n\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagCloseBetween\n    }\n\n    return end(code)\n  }\n\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return end\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenBetween\n    }\n\n    return end(code)\n  }\n\n  function tagOpenAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    return tagOpenAttributeNameAfter(code)\n  }\n\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeNameAfter\n    }\n\n    return tagOpenBetween(code)\n  }\n\n  function tagOpenAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return tagOpenAttributeValueQuoted\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    effects.consume(code)\n    marker = undefined\n    return tagOpenAttributeValueUnquoted\n  }\n\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return tagOpenAttributeValueQuotedAfter\n    }\n\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueQuoted\n  }\n\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n\n  function tagOpenAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueUnquoted\n  } // We can’t have blank lines in content, so no need to worry about empty\n  // tokens.\n\n  function atLineEnding(code) {\n    effects.exit('htmlTextData')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(\n      effects,\n      afterPrefix,\n      'linePrefix',\n      self.parser.constructs.disable.null.indexOf('codeIndented') > -1\n        ? undefined\n        : 4\n    )\n  }\n\n  function afterPrefix(code) {\n    effects.enter('htmlTextData')\n    return returnState(code)\n  }\n\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code)\n      effects.exit('htmlTextData')\n      effects.exit('htmlText')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = htmlText\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar markdownSpace = require('../character/markdown-space.js')\nvar factorySpace = require('./factory-space.js')\n\nvar thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n}\n\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  var size = 0\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter('thematicBreak')\n    marker = code\n    return atBreak(code)\n  }\n\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence')\n      return sequence(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code)\n    }\n\n    if (size < 3 || (code !== null && !markdownLineEnding(code))) {\n      return nok(code)\n    }\n\n    effects.exit('thematicBreak')\n    return ok(code)\n  }\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      size++\n      return sequence\n    }\n\n    effects.exit('thematicBreakSequence')\n    return atBreak(code)\n  }\n}\n\nmodule.exports = thematicBreak\n","'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')\n\nfunction _interopDefaultLegacy(e) {\n  return e && typeof e === 'object' && 'default' in e ? e : {default: e}\n}\n\nvar decodeEntity__default = /*#__PURE__*/ _interopDefaultLegacy(decodeEntity)\n\nvar characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n}\n\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  var self = this\n  var size = 0\n  var max\n  var test\n  return start\n\n  function start(code) {\n    effects.enter('characterReference')\n    effects.enter('characterReferenceMarker')\n    effects.consume(code)\n    effects.exit('characterReferenceMarker')\n    return open\n  }\n\n  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerNumeric')\n      return numeric\n    }\n\n    effects.enter('characterReferenceValue')\n    max = 31\n    test = asciiAlphanumeric\n    return value(code)\n  }\n\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter('characterReferenceMarkerHexadecimal')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerHexadecimal')\n      effects.enter('characterReferenceValue')\n      max = 6\n      test = asciiHexDigit\n      return value\n    }\n\n    effects.enter('characterReferenceValue')\n    max = 7\n    test = asciiDigit\n    return value(code)\n  }\n\n  function value(code) {\n    var token\n\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue')\n\n      if (\n        test === asciiAlphanumeric &&\n        !decodeEntity__default['default'](self.sliceSerialize(token))\n      ) {\n        return nok(code)\n      }\n\n      effects.enter('characterReferenceMarker')\n      effects.consume(code)\n      effects.exit('characterReferenceMarker')\n      effects.exit('characterReference')\n      return ok\n    }\n\n    if (test(code) && size++ < max) {\n      effects.consume(code)\n      return value\n    }\n\n    return nok(code)\n  }\n}\n\nmodule.exports = characterReference\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')\n\nvar list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n}\nvar listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n}\nvar indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n\nfunction tokenizeListStart(effects, ok, nok) {\n  var self = this\n  var initialSize = prefixSize(self.events, 'linePrefix')\n  var size = 0\n  return start\n\n  function start(code) {\n    var kind =\n      self.containerState.type ||\n      (code === 42 || code === 43 || code === 45\n        ? 'listUnordered'\n        : 'listOrdered')\n\n    if (\n      kind === 'listUnordered'\n        ? !self.containerState.marker || code === self.containerState.marker\n        : asciiDigit(code)\n    ) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind\n        effects.enter(kind, {\n          _container: true\n        })\n      }\n\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix')\n        return code === 42 || code === 45\n          ? effects.check(thematicBreak, nok, atMarker)(code)\n          : atMarker(code)\n      }\n\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix')\n        effects.enter('listItemValue')\n        return inside(code)\n      }\n    }\n\n    return nok(code)\n  }\n\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code)\n      return inside\n    }\n\n    if (\n      (!self.interrupt || size < 2) &&\n      (self.containerState.marker\n        ? code === self.containerState.marker\n        : code === 41 || code === 46)\n    ) {\n      effects.exit('listItemValue')\n      return atMarker(code)\n    }\n\n    return nok(code)\n  }\n\n  function atMarker(code) {\n    effects.enter('listItemMarker')\n    effects.consume(code)\n    effects.exit('listItemMarker')\n    self.containerState.marker = self.containerState.marker || code\n    return effects.check(\n      partialBlankLine, // Can’t be empty when interrupting.\n      self.interrupt ? nok : onBlank,\n      effects.attempt(\n        listItemPrefixWhitespaceConstruct,\n        endOfPrefix,\n        otherPrefix\n      )\n    )\n  }\n\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true\n    initialSize++\n    return endOfPrefix(code)\n  }\n\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter('listItemPrefixWhitespace')\n      effects.consume(code)\n      effects.exit('listItemPrefixWhitespace')\n      return endOfPrefix\n    }\n\n    return nok(code)\n  }\n\n  function endOfPrefix(code) {\n    self.containerState.size =\n      initialSize + sizeChunks(self.sliceStream(effects.exit('listItemPrefix')))\n    return ok(code)\n  }\n}\n\nfunction tokenizeListContinuation(effects, ok, nok) {\n  var self = this\n  self.containerState._closeFlow = undefined\n  return effects.check(partialBlankLine, onBlank, notBlank)\n\n  function onBlank(code) {\n    self.containerState.furtherBlankLines =\n      self.containerState.furtherBlankLines ||\n      self.containerState.initialBlankLine // We have a blank line.\n    // Still, try to consume at most the items size.\n\n    return factorySpace(\n      effects,\n      ok,\n      'listItemIndent',\n      self.containerState.size + 1\n    )(code)\n  }\n\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined\n      return notInCurrentItem(code)\n    }\n\n    self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)\n  }\n\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true // As we’re closing flow, we’re no longer interrupting.\n\n    self.interrupt = undefined\n    return factorySpace(\n      effects,\n      effects.attempt(list, ok, nok),\n      'linePrefix',\n      self.parser.constructs.disable.null.indexOf('codeIndented') > -1\n        ? undefined\n        : 4\n    )(code)\n  }\n}\n\nfunction tokenizeIndent(effects, ok, nok) {\n  var self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemIndent',\n    self.containerState.size + 1\n  )\n\n  function afterPrefix(code) {\n    return prefixSize(self.events, 'listItemIndent') ===\n      self.containerState.size\n      ? ok(code)\n      : nok(code)\n  }\n}\n\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type)\n}\n\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  var self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemPrefixWhitespace',\n    self.parser.constructs.disable.null.indexOf('codeIndented') > -1\n      ? undefined\n      : 4 + 1\n  )\n\n  function afterPrefix(code) {\n    return markdownSpace(code) ||\n      !prefixSize(self.events, 'listItemPrefixWhitespace')\n      ? nok(code)\n      : ok(code)\n  }\n}\n\nmodule.exports = list\n","'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\n    ? shallow(from)\n    : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }\n  var columnStart = {}\n  var resolveAllConstructs = []\n  var chunks = []\n  var stack = []\n\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\n  function write(slice) {\n    chunks = chunkedPush(chunks, slice)\n    main() // Exit if we’re not done, resolve might change stuff.\n\n    if (chunks[chunks.length - 1] !== null) {\n      return []\n    }\n\n    addResult(initialize, 0) // Otherwise, resolve, and exit.\n\n    context.events = resolveAll(resolveAllConstructs, context.events, context)\n    return context.events\n  } //\n  // Tools.\n  //\n\n  function sliceSerialize(token) {\n    return serializeChunks(sliceStream(token))\n  }\n\n  function sliceStream(token) {\n    return sliceChunks(chunks, token)\n  }\n\n  function now() {\n    return shallow(point)\n  }\n\n  function skip(value) {\n    columnStart[value.line] = value.column\n    accountForPotentialSkip()\n  } //\n  // State management.\n  //\n  // Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n  // `consume`).\n  // Here is where we walk through the chunks, which either include strings of\n  // several characters, or numerical character codes.\n  // The reason to do this in a loop instead of a call is so the stack can\n  // drain.\n\n  function main() {\n    var chunkIndex\n    var chunk\n\n    while (point._index < chunks.length) {\n      chunk = chunks[point._index] // If we’re in a buffer chunk, loop through it.\n\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index\n\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0\n        }\n\n        while (\n          point._index === chunkIndex &&\n          point._bufferIndex < chunk.length\n        ) {\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\n        ? handleListOfConstructs(miniflat(constructs))\n        : handleMapOfConstructs\n\n      function handleMapOfConstructs(code) {\n        if (code in constructs || null in constructs) {\n          return handleListOfConstructs(\n            constructs.null\n              ? /* c8 ignore next */\n                miniflat(constructs[code]).concat(miniflat(constructs.null))\n              : constructs[code]\n          )(code)\n        }\n\n        return bogusState(code)\n      }\n\n      function handleListOfConstructs(list) {\n        listOfConstructs = list\n        constructIndex = 0\n        return handleConstruct(list[constructIndex])\n      }\n\n      function handleConstruct(construct) {\n        return start\n\n        function start(code) {\n          // To do: not nede to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store()\n          currentConstruct = construct\n\n          if (!construct.partial) {\n            context.currentConstruct = construct\n          }\n\n          if (\n            construct.name &&\n            context.parser.constructs.disable.null.indexOf(construct.name) > -1\n          ) {\n            return nok()\n          }\n\n          return construct.tokenize.call(\n            fields ? assign({}, context, fields) : context,\n            effects,\n            ok,\n            nok\n          )(code)\n        }\n      }\n\n      function ok(code) {\n        onreturn(currentConstruct, info)\n        return returnState\n      }\n\n      function nok(code) {\n        info.restore()\n\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex])\n        }\n\n        return bogusState\n      }\n    }\n  }\n\n  function addResult(construct, from) {\n    if (construct.resolveAll && resolveAllConstructs.indexOf(construct) < 0) {\n      resolveAllConstructs.push(construct)\n    }\n\n    if (construct.resolve) {\n      chunkedSplice(\n        context.events,\n        from,\n        context.events.length - from,\n        construct.resolve(context.events.slice(from), context)\n      )\n    }\n\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context)\n    }\n  }\n\n  function store() {\n    var startPoint = now()\n    var startPrevious = context.previous\n    var startCurrentConstruct = context.currentConstruct\n    var startEventsIndex = context.events.length\n    var startStack = Array.from(stack)\n    return {\n      restore: restore,\n      from: startEventsIndex\n    }\n\n    function restore() {\n      point = startPoint\n      context.previous = startPrevious\n      context.currentConstruct = startCurrentConstruct\n      context.events.length = startEventsIndex\n      stack = startStack\n      accountForPotentialSkip()\n    }\n  }\n\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line]\n      point.offset += columnStart[point.line] - 1\n    }\n  }\n}\n\nmodule.exports = createTokenizer\n","module.exports = heading\n\nvar repeat = require('repeat-string')\nvar formatHeadingAsSetext = require('../util/format-heading-as-setext')\nvar phrasing = require('../util/container-phrasing')\n\nfunction heading(node, _, context) {\n  var rank = Math.max(Math.min(6, node.depth || 1), 1)\n  var exit\n  var subexit\n  var value\n  var sequence\n\n  if (formatHeadingAsSetext(node, context)) {\n    exit = context.enter('headingSetext')\n    subexit = context.enter('phrasing')\n    value = phrasing(node, context, {before: '\\n', after: '\\n'})\n    subexit()\n    exit()\n\n    return (\n      value +\n      '\\n' +\n      repeat(\n        rank === 1 ? '=' : '-',\n        // The whole size…\n        value.length -\n          // Minus the position of the character after the last EOL (or\n          // 0 if there is none)…\n          (Math.max(value.lastIndexOf('\\r'), value.lastIndexOf('\\n')) + 1)\n      )\n    )\n  }\n\n  sequence = repeat('#', rank)\n  exit = context.enter('headingAtx')\n  subexit = context.enter('phrasing')\n  value = phrasing(node, context, {before: '# ', after: '\\n'})\n  value = value ? sequence + ' ' + value : sequence\n  if (context.options.closeAtx) {\n    value += ' ' + sequence\n  }\n\n  subexit()\n  exit()\n\n  return value\n}\n","module.exports = hardBreak\n\nvar patternInScope = require('../util/pattern-in-scope')\n\nfunction hardBreak(node, _, context, safe) {\n  var index = -1\n\n  while (++index < context.unsafe.length) {\n    // If we can’t put eols in this construct (setext headings, tables), use a\n    // space instead.\n    if (\n      context.unsafe[index].character === '\\n' &&\n      patternInScope(context.stack, context.unsafe[index])\n    ) {\n      return /[ \\t]/.test(safe.before) ? '' : ' '\n    }\n  }\n\n  return '\\\\\\n'\n}\n","module.exports = patternCompile\n\nfunction patternCompile(pattern) {\n  var before\n  var after\n\n  if (!pattern._compiled) {\n    before = pattern.before ? '(?:' + pattern.before + ')' : ''\n    after = pattern.after ? '(?:' + pattern.after + ')' : ''\n\n    if (pattern.atBreak) {\n      before = '[\\\\r\\\\n][\\\\t ]*' + before\n    }\n\n    pattern._compiled = new RegExp(\n      (before ? '(' + before + ')' : '') +\n        (/[|\\\\{}()[\\]^$+*?.-]/.test(pattern.character) ? '\\\\' : '') +\n        pattern.character +\n        (after || ''),\n      'g'\n    )\n  }\n\n  return pattern._compiled\n}\n","'use strict'\n\nvar labelEnd = require('./label-end.js')\n\nvar labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n}\n\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  var self = this\n  return start\n\n  function start(code) {\n    effects.enter('labelImage')\n    effects.enter('labelImageMarker')\n    effects.consume(code)\n    effects.exit('labelImageMarker')\n    return open\n  }\n\n  function open(code) {\n    if (code === 91) {\n      effects.enter('labelMarker')\n      effects.consume(code)\n      effects.exit('labelMarker')\n      effects.exit('labelImage')\n      return after\n    }\n\n    return nok(code)\n  }\n\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 &&\n      /* c8 ignore next */\n      '_hiddenFootnoteSupport' in self.parser.constructs\n      ? /* c8 ignore next */\n        nok(code)\n      : ok(code)\n  }\n}\n\nmodule.exports = labelStartImage\n","'use strict'\n\nvar merge = require('./lib/util/merge')\nvar xlink = require('./lib/xlink')\nvar xml = require('./lib/xml')\nvar xmlns = require('./lib/xmlns')\nvar aria = require('./lib/aria')\nvar html = require('./lib/html')\n\nmodule.exports = merge([xml, xlink, xmlns, aria, html])\n","'use strict'\n\nvar regexCheck = require('../util/regex-check.js')\n\nvar asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\n\nmodule.exports = asciiAtext\n","'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}\n\nmodule.exports = asciiControl\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\nvar factorySpace = require('./factory-space.js')\n\nfunction titleFactory(effects, ok, nok, type, markerType, stringType) {\n  var marker\n  return start\n\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    marker = code === 40 ? 41 : code\n    return atFirstTitleBreak\n  }\n\n  function atFirstTitleBreak(code) {\n    if (code === marker) {\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    effects.enter(stringType)\n    return atTitleBreak(code)\n  }\n\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType)\n      return atFirstTitleBreak(marker)\n    }\n\n    if (code === null) {\n      return nok(code)\n    } // Note: blank lines can’t exist in content.\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, atTitleBreak, 'linePrefix')\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return title(code)\n  }\n\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      return atTitleBreak(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? titleEscape : title\n  }\n\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code)\n      return title\n    }\n\n    return title(code)\n  }\n}\n\nmodule.exports = titleFactory\n","module.exports = checkStrong\n\nfunction checkStrong(context) {\n  var marker = context.options.strong || '*'\n\n  if (marker !== '*' && marker !== '_') {\n    throw new Error(\n      'Cannot serialize strong with `' +\n        marker +\n        '` for `options.strong`, expected `*`, or `_`'\n    )\n  }\n\n  return marker\n}\n","'use strict'\n\nObject.defineProperty(exports, '__esModule', {value: true})\n\nvar assign = require('../constant/assign.js')\nvar shallow = require('../util/shallow.js')\n\nvar text = initializeFactory('text')\nvar string = initializeFactory('string')\nvar resolver = {\n  resolveAll: createResolver()\n}\n\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(\n      field === 'text' ? resolveAllLineSuffixes : undefined\n    )\n  }\n\n  function initializeText(effects) {\n    var self = this\n    var constructs = this.parser.constructs[field]\n    var text = effects.attempt(constructs, start, notText)\n    return start\n\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code)\n    }\n\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code)\n        return\n      }\n\n      effects.enter('data')\n      effects.consume(code)\n      return data\n    }\n\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data')\n        return text(code)\n      } // Data.\n\n      effects.consume(code)\n      return data\n    }\n\n    function atBreak(code) {\n      var list = constructs[code]\n      var index = -1\n\n      if (code === null) {\n        return true\n      }\n\n      if (list) {\n        while (++index < list.length) {\n          if (\n            !list[index].previous ||\n            list[index].previous.call(self, self.previous)\n          ) {\n            return true\n          }\n        }\n      }\n    }\n  }\n}\n\nfunction createResolver(extraResolver) {\n  return resolveAllText\n\n  function resolveAllText(events, context) {\n    var index = -1\n    var enter // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === 'data') {\n          enter = index\n          index++\n        }\n      } else if (!events[index] || events[index][1].type !== 'data') {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end\n          events.splice(enter + 2, index - enter - 2)\n          index = enter + 2\n        }\n\n        enter = undefined\n      }\n    }\n\n    return extraResolver ? extraResolver(events, context) : events\n  }\n} // A rather ugly set of instructions which again looks at chunks in the input\n// stream.\n// The reason to do this here is that it is *much* faster to parse in reverse.\n// And that we can’t hook into `null` to split the line suffix before an EOF.\n// To do: figure out if we can make this into a clean utility, or even in core.\n// As it will be useful for GFMs literal autolink extension (and maybe even\n// tables?)\n\nfunction resolveAllLineSuffixes(events, context) {\n  var eventIndex = -1\n  var chunks\n  var data\n  var chunk\n  var index\n  var bufferIndex\n  var size\n  var tabs\n  var token\n\n  while (++eventIndex <= events.length) {\n    if (\n      (eventIndex === events.length ||\n        events[eventIndex][1].type === 'lineEnding') &&\n      events[eventIndex - 1][1].type === 'data'\n    ) {\n      data = events[eventIndex - 1][1]\n      chunks = context.sliceStream(data)\n      index = chunks.length\n      bufferIndex = -1\n      size = 0\n      tabs = undefined\n\n      while (index--) {\n        chunk = chunks[index]\n\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length\n\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++\n            bufferIndex--\n          }\n\n          if (bufferIndex) break\n          bufferIndex = -1\n        } // Number\n        else if (chunk === -2) {\n          tabs = true\n          size++\n        } else if (chunk === -1);\n        else {\n          // Replacement character, exit.\n          index++\n          break\n        }\n      }\n\n      if (size) {\n        token = {\n          type:\n            eventIndex === events.length || tabs || size < 2\n              ? 'lineSuffix'\n              : '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\n              ? bufferIndex\n              : data.start._bufferIndex + bufferIndex\n          },\n          end: shallow(data.end)\n        }\n        data.end = shallow(token.start)\n\n        if (data.start.offset === data.end.offset) {\n          assign(data, token)\n        } else {\n          events.splice(\n            eventIndex,\n            0,\n            ['enter', token, context],\n            ['exit', token, context]\n          )\n          eventIndex += 2\n        }\n      }\n\n      eventIndex++\n    }\n  }\n\n  return events\n}\n\nexports.resolver = resolver\nexports.string = string\nexports.text = text\n","module.exports = thematicBreak\n\nvar repeat = require('repeat-string')\nvar checkRepeat = require('../util/check-rule-repeat')\nvar checkRule = require('../util/check-rule')\n\nfunction thematicBreak(node, parent, context) {\n  var value = repeat(\n    checkRule(context) + (context.options.ruleSpaces ? ' ' : ''),\n    checkRepeat(context)\n  )\n\n  return context.options.ruleSpaces ? value.slice(0, -1) : value\n}\n","'use strict'\n\nmodule.exports = footnoteReference\n\nvar u = require('unist-builder')\n\nfunction footnoteReference(h, node) {\n  var footnoteOrder = h.footnoteOrder\n  var identifier = String(node.identifier)\n\n  if (footnoteOrder.indexOf(identifier) === -1) {\n    footnoteOrder.push(identifier)\n  }\n\n  return h(node.position, 'sup', {id: 'fnref-' + identifier}, [\n    h(node, 'a', {href: '#fn-' + identifier, className: ['footnote-ref']}, [\n      u('text', node.label || identifier)\n    ])\n  ])\n}\n","'use strict'\n\nmodule.exports = strikethrough\n\nvar all = require('../all')\n\nfunction strikethrough(h, node) {\n  return h(node, 'del', all(h, node))\n}\n","module.exports = definition\n\nvar association = require('../util/association')\nvar checkQuote = require('../util/check-quote')\nvar safe = require('../util/safe')\n\nfunction definition(node, _, context) {\n  var marker = checkQuote(context)\n  var suffix = marker === '\"' ? 'Quote' : 'Apostrophe'\n  var exit = context.enter('definition')\n  var subexit = context.enter('label')\n  var value =\n    '[' + safe(context, association(node), {before: '[', after: ']'}) + ']: '\n\n  subexit()\n\n  if (\n    // If there’s no url, or…\n    !node.url ||\n    // If there’s whitespace, enclosed is prettier.\n    /[ \\t\\r\\n]/.test(node.url)\n  ) {\n    subexit = context.enter('destinationLiteral')\n    value += '<' + safe(context, node.url, {before: '<', after: '>'}) + '>'\n  } else {\n    // No whitespace, raw is prettier.\n    subexit = context.enter('destinationRaw')\n    value += safe(context, node.url, {before: ' ', after: ' '})\n  }\n\n  subexit()\n\n  if (node.title) {\n    subexit = context.enter('title' + suffix)\n    value +=\n      ' ' +\n      marker +\n      safe(context, node.title, {before: marker, after: marker}) +\n      marker\n    subexit()\n  }\n\n  exit()\n\n  return value\n}\n","'use strict'\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js')\n\nvar codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous: previous\n}\n\nfunction resolveCodeText(events) {\n  var tailExitIndex = events.length - 4\n  var headEnterIndex = 3\n  var index\n  var enter // If we start and end with an EOL or a space.\n\n  if (\n    (events[headEnterIndex][1].type === 'lineEnding' ||\n      events[headEnterIndex][1].type === 'space') &&\n    (events[tailExitIndex][1].type === 'lineEnding' ||\n      events[tailExitIndex][1].type === 'space')\n  ) {\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 =\n          '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\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index\n      }\n    } else if (\n      index === tailExitIndex ||\n      events[index][1].type === 'lineEnding'\n    ) {\n      events[enter][1].type = 'codeTextData'\n\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end\n        events.splice(enter + 2, index - enter - 2)\n        tailExitIndex -= index - enter - 2\n        index = enter + 2\n      }\n\n      enter = undefined\n    }\n  }\n\n  return events\n}\n\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return (\n    code !== 96 ||\n    this.events[this.events.length - 1][1].type === 'characterEscape'\n  )\n}\n\nfunction tokenizeCodeText(effects, ok, nok) {\n  var sizeOpen = 0\n  var size\n  var token\n  return start\n\n  function start(code) {\n    effects.enter('codeText')\n    effects.enter('codeTextSequence')\n    return openingSequence(code)\n  }\n\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code)\n      sizeOpen++\n      return openingSequence\n    }\n\n    effects.exit('codeTextSequence')\n    return gap(code)\n  }\n\n  function gap(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code)\n    } // Closing fence?\n    // Could also be data.\n\n    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\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 (\n      code === null ||\n      code === 32 ||\n      code === 96 ||\n      markdownLineEnding(code)\n    ) {\n      effects.exit('codeTextData')\n      return gap(code)\n    }\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}\n\nmodule.exports = codeText\n","module.exports = checkBullet\n\nfunction checkBullet(context) {\n  var marker = context.options.bullet || '*'\n\n  if (marker !== '*' && marker !== '+' && marker !== '-') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        marker +\n        '` for `options.bullet`, expected `*`, `+`, or `-`'\n    )\n  }\n\n  return marker\n}\n","'use strict'\n\nvar normalize = require('mdurl/encode')\nvar all = require('../all')\n\nmodule.exports = link\n\nfunction link(h, node) {\n  var props = {href: normalize(node.url)}\n\n  if (node.title !== null && node.title !== undefined) {\n    props.title = node.title\n  }\n\n  return h(node, 'a', props, all(h, node))\n}\n","'use strict'\n\n// chunks (replacement characters, tabs, or line endings).\n\nfunction movePoint(point, offset) {\n  point.column += offset\n  point.offset += offset\n  point._bufferIndex += offset\n  return point\n}\n\nmodule.exports = movePoint\n"],"sourceRoot":""}