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