{"version":3,"sources":["webpack://grundium-ltd-website/./node_modules/bail/index.js","webpack://grundium-ltd-website/./node_modules/classnames/index.js","webpack://grundium-ltd-website/./node_modules/extend/index.js","webpack://grundium-ltd-website/./node_modules/is-buffer/index.js","webpack://grundium-ltd-website/./node_modules/mdast-add-list-metadata/index.js","webpack://grundium-ltd-website/./node_modules/mdast-util-from-markdown/dist/index.js","webpack://grundium-ltd-website/./node_modules/mdast-util-from-markdown/index.js","webpack://grundium-ltd-website/./node_modules/mdast-util-to-string/index.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/character/ascii-alpha.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/character/ascii-alphanumeric.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/character/ascii-atext.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/character/ascii-control.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/character/ascii-digit.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/character/ascii-hex-digit.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/character/ascii-punctuation.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/character/markdown-line-ending-or-space.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/character/markdown-line-ending.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/character/markdown-space.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/character/unicode-punctuation.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/character/unicode-whitespace.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/constant/assign.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/constant/from-char-code.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/constant/has-own-property.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/constant/html-block-names.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/constant/html-raw-names.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/constant/splice.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/constant/unicode-punctuation-regex.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/constructs.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/initialize/content.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/initialize/document.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/initialize/flow.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/initialize/text.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/parse.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/postprocess.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/preprocess.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/attention.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/autolink.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/block-quote.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/character-escape.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/character-reference.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/code-fenced.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/code-indented.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/code-text.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/content.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/definition.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/factory-destination.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/factory-label.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/factory-space.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/factory-title.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/factory-whitespace.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/hard-break-escape.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/heading-atx.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/html-flow.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/html-text.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/label-end.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/label-start-image.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/label-start-link.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/line-ending.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/list.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/partial-blank-line.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/setext-underline.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/tokenize/thematic-break.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/chunked-push.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/chunked-splice.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/classify-character.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/combine-extensions.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/create-tokenizer.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/miniflat.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/move-point.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/normalize-identifier.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/prefix-size.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/regex-check.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/resolve-all.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/safe-from-int.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/serialize-chunks.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/shallow.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/size-chunks.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/slice-chunks.js","webpack://grundium-ltd-website/./node_modules/micromark/dist/util/subtokenize.js","webpack://grundium-ltd-website/./node_modules/parse-entities/decode-entity.browser.js","webpack://grundium-ltd-website/./node_modules/react-is/cjs/react-is.production.min.js","webpack://grundium-ltd-website/./node_modules/react-is/index.js","webpack://grundium-ltd-website/./node_modules/react-markdown/lib/ast-to-react.js","webpack://grundium-ltd-website/./node_modules/react-markdown/lib/get-definitions.js","webpack://grundium-ltd-website/./node_modules/react-markdown/lib/plugins/disallow-node.js","webpack://grundium-ltd-website/./node_modules/react-markdown/lib/plugins/naive-html.js","webpack://grundium-ltd-website/./node_modules/react-markdown/lib/react-markdown.js","webpack://grundium-ltd-website/./node_modules/react-markdown/lib/renderers.js","webpack://grundium-ltd-website/./node_modules/react-markdown/lib/symbols.js","webpack://grundium-ltd-website/./node_modules/react-markdown/lib/uri-transformer.js","webpack://grundium-ltd-website/./node_modules/react-markdown/lib/wrap-table-rows.js","webpack://grundium-ltd-website/./node_modules/react-markdown/node_modules/is-plain-obj/index.js","webpack://grundium-ltd-website/./node_modules/react-markdown/node_modules/remark-parse/index.js","webpack://grundium-ltd-website/./node_modules/react-markdown/node_modules/unified/index.js","webpack://grundium-ltd-website/./node_modules/trough/index.js","webpack://grundium-ltd-website/./node_modules/trough/wrap.js","webpack://grundium-ltd-website/./node_modules/unist-util-is/convert.js","webpack://grundium-ltd-website/./node_modules/unist-util-stringify-position/index.js","webpack://grundium-ltd-website/./node_modules/unist-util-visit-parents/index.js","webpack://grundium-ltd-website/./node_modules/unist-util-visit/index.js","webpack://grundium-ltd-website/./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/color.browser.js","webpack://grundium-ltd-website/./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js","webpack://grundium-ltd-website/./node_modules/vfile-message/index.js","webpack://grundium-ltd-website/./node_modules/vfile/index.js","webpack://grundium-ltd-website/./node_modules/vfile/lib/core.js","webpack://grundium-ltd-website/./node_modules/vfile/lib/index.js","webpack://grundium-ltd-website/./node_modules/vfile/lib/minpath.browser.js","webpack://grundium-ltd-website/./node_modules/vfile/lib/minproc.browser.js","webpack://grundium-ltd-website/./src/components/Footer.js","webpack://grundium-ltd-website/./src/utils/utils.js","webpack://grundium-ltd-website/./src/assets/img/quotes.svg"],"names":["module","exports","err","hasOwn","hasOwnProperty","classNames","classes","i","arguments","length","arg","argType","push","Array","isArray","inner","apply","key","call","join","default","Object","prototype","toStr","toString","defineProperty","gOPD","getOwnPropertyDescriptor","arr","isPlainObject","obj","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","options","name","enumerable","configurable","value","newValue","writable","getProperty","extend","src","copy","copyIsArray","clone","deep","isBuffer","visitWithParents","ast","listNode","parents","n","depth","type","children","child","index","ordered","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","tree","tokenStack","listStack","context","stack","resume","setData","getData","prepareList","pop","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","node","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","concat","all","values","result","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","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","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","parent","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","getPrototypeOf","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","visitor","one","visitParents","CONTINUE","SKIP","EXIT","reverse","color","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","rand","useStaticQuery","nowYear","Date","getFullYear","quotes","nodes","quote","random","round","blogs","products","address","address1","address2","email","linkedIn","rel","facebook","twitter","quotesImg","author","to","product","active","slug","id","blog","date","randomInteger","min","floor","getCookie","cookie","row","startsWith","console","warn"],"mappings":"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","file":"3e8f227f64a588792c62563ddef0a5f04a82e39d-c23c009d5d09a3fc3df6.js","sourcesContent":["'use strict';\n\nmodule.exports = bail;\n\nfunction bail(err) {\n  if (err) {\n    throw err;\n  }\n}","/*!\n  Copyright (c) 2017 Jed Watson.\n  Licensed under the MIT License (MIT), see\n  http://jedwatson.github.io/classnames\n*/\n\n/* global define */\n(function () {\n  'use strict';\n\n  var hasOwn = {}.hasOwnProperty;\n\n  function classNames() {\n    var classes = [];\n\n    for (var i = 0; i < arguments.length; i++) {\n      var arg = arguments[i];\n      if (!arg) continue;\n      var argType = typeof arg;\n\n      if (argType === 'string' || argType === 'number') {\n        classes.push(arg);\n      } else if (Array.isArray(arg) && arg.length) {\n        var inner = classNames.apply(null, arg);\n\n        if (inner) {\n          classes.push(inner);\n        }\n      } else if (argType === 'object') {\n        for (var key in arg) {\n          if (hasOwn.call(arg, key) && arg[key]) {\n            classes.push(key);\n          }\n        }\n      }\n    }\n\n    return classes.join(' ');\n  }\n\n  if (typeof module !== 'undefined' && module.exports) {\n    classNames.default = classNames;\n    module.exports = classNames;\n  } else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n    // register as 'classnames', consistent with npm package name\n    define('classnames', [], function () {\n      return classNames;\n    });\n  } else {\n    window.classNames = classNames;\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};","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\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 || 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 || code > 126 && code < 160 || code > 55295 && code < 57344 || 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 = function (value) {\n  if (Object.prototype.toString.call(value) !== '[object Object]') {\n    return false;\n  }\n\n  var prototype = Object.getPrototypeOf(value);\n  return prototype === null || prototype === Object.prototype;\n};","'use strict';\n\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 && (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}","'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 = 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}","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\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 || 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}","import React from \"react\"\nimport quotesImg from \"../assets/img/quotes.svg\"\n// import Image from \"gatsby-image\"\n// import { Link } from \"gatsby\"\nimport { graphql, Link, useStaticQuery } from \"gatsby\"\n// import SocialLinks from \"../constants/socialLinks\"\n// ...GatsbyImageSharpFluid\n// import {\n//   FaLinkedinIn,\n//   FaFacebookF,\n//   FaTwitter,\n//   // FaInstagram,\n//   FaMapMarkerAlt,\n//   FaEnvelope,\n//   // FaPhone,\n// } from \"react-icons/fa\"\n\nfunction randomQuote(list) {\n  let rand = 0 - 0.5 + Math.random() * list.length;\n  return list[Math.round(rand)];\n}\n\nconst Footer = () => {\n\n  const data = useStaticQuery(graphql`\n  {\n    settings: strapiSettings {\n      address {\n        address1\n        address2\n      }\n      email\n      facebook\n      linkedIn\n      twitter\n      companyName\n    }\n    quotes: allStrapiQuotes {\n      nodes {\n        text\n        author\n      }\n    }\n    blogs: allStrapiBlogs(sort: {fields: date, order: DESC}, filter: {hidden: {ne: true}}, limit: 3) {\n      nodes {\n        date(formatString: \"MMMM Do, YYYY\")\n        category\n        id\n        slug\n        title\n      }\n    }\n    products: allStrapiProducts{\n      nodes {\n        id\n        new\n        active\n        slug\n        title\n      }\n    }\n  }\n`);\nconst nowYear = new Date().getFullYear();\nconst settings = data.settings;\nconst quotes = data.quotes.nodes;\nconst quote = randomQuote(quotes);\nconst blogs = data.blogs.nodes;\nconst products = data.products.nodes;\n\n  return (\n    <section className=\"gs-footer\">\n      <div className=\"gs-sect__in gs-container\">\n        <div className=\"gs-footer-columns fww\">\n\n          <div className=\"gs-footer-column fl1 mb2 mr1\">\n            <h3 className=\"\">CONTACTS</h3>\n            <p className=\"mb05\">\n              <a\n                href=\"https://goo.gl/maps/pfBJ9aW2iFvz52tm8\"\n                target=\"blanc\"\n                className=\"gs-footer-link gs-footer-link--street gs-color-yellow\"\n              >\n                <span>\n                {settings.address.address1}, <br />\n                {settings.address.address2}\n                </span>\n              </a>\n            </p>\n            <p className=\"mb1\">\n              <a\n                href={\"mailto:\"+settings.email}\n                target=\"blanc\"\n                className=\"gs-footer-link gs-color-yellow\"\n              >\n                {settings.email}\n              </a>\n            </p>\n          </div>\n          <div className=\"gs-footer-column fl1 mb2 mr1\">\n            <h3 className=\"\">FOLLOW US</h3>\n            <p className=\"df fdc mb1\">\n              <a href={settings.linkedIn} target=\"_blank\" rel=\"noreferrer\" className=\"gs-footer-link\">\n                <span className=\"label\">LinkedIn</span>\n              </a>\n              <a href={settings.facebook} target=\"_blank\" rel=\"noreferrer\" className=\"gs-footer-link\">\n                <span className=\"label\">Facebook</span>\n              </a>\n              {/* <a className=\"gs-footer-link\">\n                <FaInstagram className=\"gs-footer-link__icon gs-footer-link__icon--social\" />\n                <span className=\"label\">Instagram</span>\n              </a> */}\n              <a href={settings.twitter} target=\"_blank\" rel=\"noreferrer\" className=\"gs-footer-link\">\n                <span className=\"label\">Twitter</span>\n              </a>\n            </p>\n          </div>\n\n          <div className=\"gs-footer-column fl1 mb2\">\n            <h3 className=\"\">QUOTE OF THE DAY</h3>\n            <div className=\"gs-footer-quote mb1\">\n              \n              <div className=\"gs-footer-quote__sign\"><img src={quotesImg} alt=\"Quotes\"/></div>\n              <div className=\"gs-footer-quote__text mb1\">\n                {quote.text}\n              </div>\n              <div className=\"gs-footer-quote__author fwb\">– {quote.author}</div>\n            </div>\n          </div>\n          \n          </div>\n          <div className=\"gs-footer-columns fww\">\n            <div className=\"gs-footer-column fl1 mb2 mr1\">\n              <h3 className=\"\">LINKS</h3>\n              <div className=\"mb1\">\n                <Link key=\"Home\" to=\"/\" className=\"gs-footer-link\">Home</Link>\n                {\n                  products.filter(product=>product.active).map(product => {\n                    // console.log(product.id);\n                    return <Link to={\"/\"+product.slug} key={product.id} className=\"gs-footer-link\">{product.title}</Link>\n                  })\n                }\n                <Link key=\"News\" to=\"/news\" className=\"gs-footer-link\">News</Link>\n                <Link key=\"videos\" to=\"/videos\" className=\"gs-footer-link\">Videos</Link>\n                <Link key=\"Solutions\" to=\"/solutions\" className=\"gs-footer-link\">Solutions</Link>\n                <Link key=\"Company\" to=\"/company\" className=\"gs-footer-link\">Company</Link>\n                <Link key=\"Contact\" to=\"/contact\" className=\"gs-footer-link\">Contact</Link>\n              </div>\n            </div>\n            <div className=\"gs-footer-column fl2 mb2\">\n              <h3 className=\"\">LATEST NEWS</h3>\n              <div className=\"mb1\">\n                {\n                  blogs.map(blog => {\n                    // console.log(blog.id);\n                    return <Link key={blog.id} to={`/blogs/${blog.slug}`} className=\"gs-footer-link\">\n                    <div>\n                      <span className=\"fw300 fz08\">{blog.date}</span>\n                      <h5 className=\"mb0\">{blog.title}</h5>\n                    </div>\n                  </Link>\n                  })\n                }\n              </div>\n            </div>\n        </div>\n        <div className=\"gs-footer-copyright\">\n          © Grundium Ltd {nowYear}. All rights reserved. &nbsp;\n          <a\n            href=\"/privacy\"\n            target=\"blanc\"\n            className=\"gs-color-yellow\"\n          >\n            Privacy Policy\n          </a>\n        </div>\n      </div>\n    </section>\n  )\n}\n\nexport default Footer\n","export function randomInteger(min, max) {\n    let rand = min + Math.random() * (max + 1 - min);\n    return Math.floor(rand);\n  }\n\nexport function encode(data){\n    return Object.keys(data)\n        .map(key => encodeURIComponent(key) + \"=\" + encodeURIComponent(data[key]))\n        .join(\"&\");\n  }\n\n// export function setCookie(cname, cvalue, exdays) {\n//     var d = new Date();\n//     d.setTime(d.getTime() + (exdays * 24 * 60 * 60 * 1000));\n//     var expires = \"expires=\"+d.toUTCString();\n//     document.cookie = cname + \"=\" + cvalue + \";\" + expires + \";path=/\";\n//   }\n  \n// export function getCookie(cname) {\n//     var name = cname + \"=\";\n//     var ca = document.cookie.split(';');\n//     for(var i = 0; i < ca.length; i++) {\n//       var c = ca[i];\n//       while (c.charAt(0) === ' ') {\n//         c = c.substring(1);\n//       }\n//       if (c.indexOf(name) === 0) {\n//         return c.substring(name.length, c.length);\n//       }\n//     }\n//     return \"\";\n//   }\n\n// export function getCookieRegex(name) {\n//   var v = document.cookie.match('(^|;) ?' + name + '=([^;]*)(;|$)');\n//   return v ? v[2] : null;\n// };\n\nexport function getCookie(name) {\n  try {\n    return document.cookie\n      .split(\"; \")\n      .find(row => row.startsWith(`${name}=`))\n      .split(\"=\")[1];\n  } catch (e) {\n    console.warn(`No cookie with name: ${name} found!`);\n  }\n}","export default \"data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB2aWV3Qm94PSIwIDAgNzkgODAiIHZlcnNpb249IjEuMSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayI+CiAgICA8dGl0bGU+4oCY4oCYPC90aXRsZT4KICAgIDxnIGlkPSJxdW90ZXMiIHN0cm9rZT0ibm9uZSIgc3Ryb2tlLXdpZHRoPSIxIiBmaWxsPSIjZmVjMjAwIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiPgogICAgICAgIDxwYXRoIGQ9Ik0zNS40LDc5LjMgTDM1LjQsNDUuNyBMMTkuNSw0NS43IEMxOS41LDM0LjMgMjAuNjUsMjUuOTUgMjIuOTUsMjAuNjUgQzI1LjI1LDE1LjM1IDI5LjUsMTIuNCAzNS43LDExLjggTDM1LjcsMTEuOCBMMzAsMC4xIEMxOSwwLjUgMTEuMyw1LjEgNi45LDEzLjkgQzIuNSwyMi43IDAuMywzNC44IDAuMyw1MC4yIEwwLjMsNTAuMiBMMC4zLDc5LjMgTDM1LjQsNzkuMyBaIE03Ny44LDc5LjMgTDc3LjgsNDUuNyBMNjEuOSw0NS43IEM2MS45LDM0LjMgNjMuMDUsMjUuOTUgNjUuMzUsMjAuNjUgQzY3LjY1LDE1LjM1IDcxLjksMTIuNCA3OC4xLDExLjggTDc4LjEsMTEuOCBMNzIuNCwwLjEgQzYxLjQsMC41IDUzLjcsNS4xIDQ5LjMsMTMuOSBDNDQuOSwyMi43IDQyLjcsMzQuOCA0Mi43LDUwLjIgTDQyLjcsNTAuMiBMNDIuNyw3OS4zIEw3Ny44LDc5LjMgWiIgaWQ9InF1b3RlcyIgZmlsbD0iaW5oZXJpdCIgZmlsbC1ydWxlPSJub256ZXJvIj48L3BhdGg+CiAgICA8L2c+Cjwvc3ZnPg==\""],"sourceRoot":""}