{"version":3,"sources":["webpack://switch-website/./node_modules/bail/index.js","webpack://switch-website/./node_modules/ccount/index.js","webpack://switch-website/./node_modules/escape-string-regexp/index.js","webpack://switch-website/./node_modules/extend/index.js","webpack://switch-website/./node_modules/is-buffer/index.js","webpack://switch-website/./node_modules/is-plain-obj/index.js","webpack://switch-website/./node_modules/markdown-table/index.js","webpack://switch-website/./node_modules/mdast-add-list-metadata/index.js","webpack://switch-website/./node_modules/mdast-add-list-metadata/node_modules/unist-util-visit-parents/index.js","webpack://switch-website/./node_modules/mdast-util-find-and-replace/index.js","webpack://switch-website/./node_modules/mdast-util-from-markdown/dist/index.js","webpack://switch-website/./node_modules/mdast-util-from-markdown/index.js","webpack://switch-website/./node_modules/mdast-util-gfm-autolink-literal/from-markdown.js","webpack://switch-website/./node_modules/mdast-util-gfm-autolink-literal/to-markdown.js","webpack://switch-website/./node_modules/mdast-util-gfm-strikethrough/from-markdown.js","webpack://switch-website/./node_modules/mdast-util-gfm-strikethrough/to-markdown.js","webpack://switch-website/./node_modules/mdast-util-gfm-table/from-markdown.js","webpack://switch-website/./node_modules/mdast-util-gfm-table/to-markdown.js","webpack://switch-website/./node_modules/mdast-util-gfm-task-list-item/from-markdown.js","webpack://switch-website/./node_modules/mdast-util-gfm-task-list-item/to-markdown.js","webpack://switch-website/./node_modules/mdast-util-gfm/from-markdown.js","webpack://switch-website/./node_modules/mdast-util-gfm/to-markdown.js","webpack://switch-website/./node_modules/mdast-util-to-markdown/lib/configure.js","webpack://switch-website/./node_modules/mdast-util-to-markdown/lib/handle/inline-code.js","webpack://switch-website/./node_modules/mdast-util-to-markdown/lib/handle/list-item.js","webpack://switch-website/./node_modules/mdast-util-to-markdown/lib/util/check-bullet.js","webpack://switch-website/./node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js","webpack://switch-website/./node_modules/mdast-util-to-markdown/lib/util/container-flow.js","webpack://switch-website/./node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js","webpack://switch-website/./node_modules/mdast-util-to-markdown/lib/util/indent-lines.js","webpack://switch-website/./node_modules/mdast-util-to-markdown/lib/util/pattern-compile.js","webpack://switch-website/./node_modules/mdast-util-to-string/index.js","webpack://switch-website/./node_modules/micromark-extension-gfm-autolink-literal/index.js","webpack://switch-website/./node_modules/micromark-extension-gfm-autolink-literal/syntax.js","webpack://switch-website/./node_modules/micromark-extension-gfm-strikethrough/index.js","webpack://switch-website/./node_modules/micromark-extension-gfm-table/index.js","webpack://switch-website/./node_modules/micromark-extension-gfm-table/syntax.js","webpack://switch-website/./node_modules/micromark-extension-gfm-task-list-item/index.js","webpack://switch-website/./node_modules/micromark-extension-gfm-task-list-item/syntax.js","webpack://switch-website/./node_modules/micromark-extension-gfm/index.js","webpack://switch-website/./node_modules/micromark-extension-gfm/syntax.js","webpack://switch-website/./node_modules/micromark/dist/character/ascii-alpha.js","webpack://switch-website/./node_modules/micromark/dist/character/ascii-alphanumeric.js","webpack://switch-website/./node_modules/micromark/dist/character/ascii-atext.js","webpack://switch-website/./node_modules/micromark/dist/character/ascii-control.js","webpack://switch-website/./node_modules/micromark/dist/character/ascii-digit.js","webpack://switch-website/./node_modules/micromark/dist/character/ascii-hex-digit.js","webpack://switch-website/./node_modules/micromark/dist/character/ascii-punctuation.js","webpack://switch-website/./node_modules/micromark/dist/character/markdown-line-ending-or-space.js","webpack://switch-website/./node_modules/micromark/dist/character/markdown-line-ending.js","webpack://switch-website/./node_modules/micromark/dist/character/markdown-space.js","webpack://switch-website/./node_modules/micromark/dist/character/unicode-punctuation.js","webpack://switch-website/./node_modules/micromark/dist/character/unicode-whitespace.js","webpack://switch-website/./node_modules/micromark/dist/constant/assign.js","webpack://switch-website/./node_modules/micromark/dist/constant/from-char-code.js","webpack://switch-website/./node_modules/micromark/dist/constant/has-own-property.js","webpack://switch-website/./node_modules/micromark/dist/constant/html-block-names.js","webpack://switch-website/./node_modules/micromark/dist/constant/html-raw-names.js","webpack://switch-website/./node_modules/micromark/dist/constant/splice.js","webpack://switch-website/./node_modules/micromark/dist/constant/unicode-punctuation-regex.js","webpack://switch-website/./node_modules/micromark/dist/constructs.js","webpack://switch-website/./node_modules/micromark/dist/initialize/content.js","webpack://switch-website/./node_modules/micromark/dist/initialize/document.js","webpack://switch-website/./node_modules/micromark/dist/initialize/flow.js","webpack://switch-website/./node_modules/micromark/dist/initialize/text.js","webpack://switch-website/./node_modules/micromark/dist/parse.js","webpack://switch-website/./node_modules/micromark/dist/postprocess.js","webpack://switch-website/./node_modules/micromark/dist/preprocess.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/attention.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/autolink.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/block-quote.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/character-escape.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/character-reference.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/code-fenced.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/code-indented.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/code-text.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/content.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/definition.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/factory-destination.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/factory-label.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/factory-space.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/factory-title.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/factory-whitespace.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/hard-break-escape.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/heading-atx.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/html-flow.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/html-text.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/label-end.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/label-start-image.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/label-start-link.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/line-ending.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/list.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/partial-blank-line.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/setext-underline.js","webpack://switch-website/./node_modules/micromark/dist/tokenize/thematic-break.js","webpack://switch-website/./node_modules/micromark/dist/util/chunked-push.js","webpack://switch-website/./node_modules/micromark/dist/util/chunked-splice.js","webpack://switch-website/./node_modules/micromark/dist/util/classify-character.js","webpack://switch-website/./node_modules/micromark/dist/util/combine-extensions.js","webpack://switch-website/./node_modules/micromark/dist/util/create-tokenizer.js","webpack://switch-website/./node_modules/micromark/dist/util/miniflat.js","webpack://switch-website/./node_modules/micromark/dist/util/move-point.js","webpack://switch-website/./node_modules/micromark/dist/util/normalize-identifier.js","webpack://switch-website/./node_modules/micromark/dist/util/prefix-size.js","webpack://switch-website/./node_modules/micromark/dist/util/regex-check.js","webpack://switch-website/./node_modules/micromark/dist/util/resolve-all.js","webpack://switch-website/./node_modules/micromark/dist/util/safe-from-int.js","webpack://switch-website/./node_modules/micromark/dist/util/serialize-chunks.js","webpack://switch-website/./node_modules/micromark/dist/util/shallow.js","webpack://switch-website/./node_modules/micromark/dist/util/size-chunks.js","webpack://switch-website/./node_modules/micromark/dist/util/slice-chunks.js","webpack://switch-website/./node_modules/micromark/dist/util/subtokenize.js","webpack://switch-website/./node_modules/parse-entities/decode-entity.browser.js","webpack://switch-website/./node_modules/react-markdown/lib/ast-to-react.js","webpack://switch-website/./node_modules/react-markdown/lib/get-definitions.js","webpack://switch-website/./node_modules/react-markdown/lib/plugins/disallow-node.js","webpack://switch-website/./node_modules/react-markdown/lib/plugins/naive-html.js","webpack://switch-website/./node_modules/react-markdown/lib/react-markdown.js","webpack://switch-website/./node_modules/react-markdown/lib/renderers.js","webpack://switch-website/./node_modules/react-markdown/lib/symbols.js","webpack://switch-website/./node_modules/react-markdown/lib/uri-transformer.js","webpack://switch-website/./node_modules/react-markdown/lib/wrap-table-rows.js","webpack://switch-website/./node_modules/react-markdown/node_modules/remark-parse/index.js","webpack://switch-website/./node_modules/react-markdown/node_modules/unified/index.js","webpack://switch-website/./node_modules/remark-gfm/index.js","webpack://switch-website/./node_modules/repeat-string/index.js","webpack://switch-website/./node_modules/trough/index.js","webpack://switch-website/./node_modules/trough/wrap.js","webpack://switch-website/./node_modules/unist-util-is/convert.js","webpack://switch-website/./node_modules/unist-util-stringify-position/index.js","webpack://switch-website/./node_modules/unist-util-visit-parents/color.browser.js","webpack://switch-website/./node_modules/unist-util-visit-parents/index.js","webpack://switch-website/./node_modules/unist-util-visit/index.js","webpack://switch-website/./node_modules/vfile-message/index.js","webpack://switch-website/./node_modules/vfile/index.js","webpack://switch-website/./node_modules/vfile/lib/core.js","webpack://switch-website/./node_modules/vfile/lib/index.js","webpack://switch-website/./node_modules/vfile/lib/minpath.browser.js","webpack://switch-website/./node_modules/vfile/lib/minproc.browser.js","webpack://switch-website/./src/components/common/SEO.js","webpack://switch-website/./src/helpers/constants/learn.js","webpack://switch-website/./src/helpers/hooks/useSiteMetaData.js","webpack://switch-website/./src/components/common/Markdown2React.js","webpack://switch-website/./src/components/common/ShareContentButtons.js","webpack://switch-website/./src/components/learn/blog-post/BlogPostWrapper.js","webpack://switch-website/./src/components/learn/blog-post/Hero.js","webpack://switch-website/./src/templates/blog-post.js","webpack://switch-website/./src/images/download.svg","webpack://switch-website/./src/images/learn/filters/article.svg","webpack://switch-website/./src/images/learn/filters/blog.svg","webpack://switch-website/./src/images/learn/filters/case-study.svg","webpack://switch-website/./src/images/learn/filters/latest.svg","webpack://switch-website/./src/images/learn/filters/podcast.svg","webpack://switch-website/./src/images/learn/filters/report.svg","webpack://switch-website/./src/images/learn/filters/webinar.svg","webpack://switch-website/./src/images/learn/filters/whitepaper.svg","webpack://switch-website/./src/images/geometric-pattern-bg.png"],"names":["module","exports","err","source","character","index","value","String","count","Error","indexOf","length","string","TypeError","replace","hasOwn","Object","prototype","hasOwnProperty","toStr","toString","defineProperty","gOPD","getOwnPropertyDescriptor","isArray","arr","Array","call","isPlainObject","obj","key","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","options","name","enumerable","configurable","newValue","writable","getProperty","extend","src","copy","copyIsArray","clone","arguments","i","deep","isBuffer","getPrototypeOf","repeat","table","cells","columnIndex","columnLength","largest","size","cell","lines","line","before","after","code","settings","padding","start","delimiterStart","end","delimiterEnd","align","concat","alignDelimiters","alignments","stringLength","defaultStringLength","rowIndex","rowLength","cellMatrix","sizeMatrix","row","sizes","longestCellByColumn","mostCellsPerRow","undefined","push","toAlignment","colon","r","Math","max","splice","space","join","trailingWhitespace","charCodeAt","visitWithParents","ast","listNode","parents","n","depth","type","children","child","ordered","tree","visitor","stack","one","node","result","parent","pop","all","find","schema","exec","search","handlerFactory","pairs","pair","handler","position","match","subhandler","nodes","lastIndex","apply","input","slice","global","unshift","toExpression","toFunction","toPairs","visit","convert","escape","ignored","ignore","grandparent","RegExp","encoding","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","tokenStack","listStack","context","resume","setData","getData","prepareList","own","assign","sliceSerialize","stringifyPosition","point","column","offset","tailIndex","lineIndex","tailEvent","event","firstBlankLineIndex","atMarker","containerBalance","listSpread","_spread","d","create","and","open","token","this","close","parseInt","lang","meta","identifier","normalizeIdentifier","toLowerCase","title","url","siblings","tail","text","referenceType","fragment","alt","safeFromInt","decode","spread","checked","compiler","postprocess","parser","document","write","preprocessor","left","ccount","findAndReplace","unicodePunctuation","unicodeWhitespace","enterLiteralAutolinkValue","findUrl","$0","protocol","domain","path","parts","prefix","previous","test","split","isCorrectDomain","closingParenIndex","openingParens","closingParens","trail","splitUrl","findEmail","atext","email","literalAutolink","literalAutolinkEmail","literalAutolinkHttp","literalAutolinkWww","inConstruct","notInConstruct","unsafe","strikethrough","phrasing","handleDelete","_","handlers","delete","peek","enterCell","$1","_align","tableData","tableHeader","tableRow","defaultInlineCode","markdownTable","tableCellPadding","tablePipeAlign","around","atBreak","serializeData","subexit","handleTableRowAsData","handleTableAsData","tableCell","handleTableCell","inlineCode","matrix","exitCheck","taskListCheckValueChecked","taskListCheckValueUnchecked","firstParaghraph","head","shift","defaultListItem","autolinkLiteral","taskListItem","right","base","patternCompile","pattern","expression","sequence","charAt","bullet","checkBullet","listItemIndent","checkListItemIndent","incrementListMarker","ceil","indentLines","flow","blank","marker","style","results","handle","between","Number","safeOptions","map","eol","_compiled","values","asciiAlpha","asciiAlphanumeric","asciiControl","markdownLineEnding","www","tokenize","effects","ok","nok","consume","w2","w3","dot","partial","hasUnderscoreInLastSegment","hasUnderscoreInLastLastSegment","check","namedCharacterReference","done","punctuationContinuation","punctuation","balance","inPath","continuedPunctuation","parenAtPathEnd","pathEnd","trailingPunctuation","inside","wwwAutolink","self","previousWww","attempt","httpAutolink","previousHttp","t1","t2","p","s","slash1","slash2","emailAutolink","hasDot","gfmAtext","previousEmail","dotContinuation","dashOrUnderscoreContinuation","afterDashOrUnderscore","_balanced","single","singleTilde","tokenizer","more","classifyCharacter","_open","_close","resolveAll","nextEvents","shallow","chunkedSplice","constructs","insideSpan","null","removeRemainingSequences","seenDelimiter","hasDash","tableHeaderCount","cellDividerHead","inCellContentHead","cellBreakHead","setextUnderlineMini","createSpace","rowStartDelimiter","atRowEndHead","inWhitespaceHead","inCellContentEscapeHead","atDelimiterRowBreak","rowEndDelimiter","inWhitespaceDelimiter","inFillerDelimiter","afterLeftAlignment","afterRightAlignment","tableClose","nextPrefixedOrBlank","tableContinue","bodyStart","rowStartBody","cellDividerBody","inCellContentBody","cellBreakBody","tableBodyClose","tableBodyContinue","atRowEndBody","inWhitespaceBody","inCellContentEscapeBody","resolve","inHead","inDelimiterRow","inRow","content","contentStart","contentEnd","cellStart","contentType","interruptible","whitespace","markdownLineEndingOrSpace","spaceFactory","prefixSize","tasklistCheck","_gfmTasklistFirstContentOfListItem","spaceThenNonSpace","combine","tasklist","regexCheck","asciiAtext","asciiDigit","asciiHexDigit","asciiPunctuation","unicodePunctuationRegex","fromCharCode","text$1","attention","headingAtx","labelEnd","labelStartImage","labelStartLink","setextUnderline","contentInitial","flowInitial","resolver","disable","factorySpace","lineStart","next","partialBlankLine","inspectResult","childFlow","childToken","continued","inspectConstruct","subcontinued","inspectStart","containerState","continuation","inspectContinue","inspectLess","currentConstruct","concrete","flowContinue","inspectDone","interrupt","containerConstruct","inspectFlowEnd","_closeFlow","lazy","lazyFlowConstruct","inspectLazy","flowEnd","documentContinue","documentContinued","flowStart","containerContinue","exitContainers","now","_tokenizer","continueFlow","documentAfterPeek","defineSkip","sliceStream","initial","afterConstruct","initializeFactory","createResolver","field","notText","resolveAllLineSuffixes","extraResolver","chunks","chunk","bufferIndex","tabs","eventIndex","_index","_bufferIndex","combineExtensions","createTokenizer","miniflat","defined","initializer","from","subtokenize","atCarriageReturn","startPosition","endPosition","chunkedPush","movePoint","group","openingSequence","closingSequence","use","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","markdownSpace","_container","decodeEntity","_interopDefaultLegacy","e","default","decodeEntity__default","numeric","closingFenceConstruct","closingSequenceStart","sizeOpen","closingSequenceEnd","initialPrefix","sequenceOpen","infoOpen","openAfter","info","infoAfter","contentContinue","indentedContentConstruct","afterPrefix","gap","tailExitIndex","headEnterIndex","continuationConstruct","prefixed","factoryDestination","factoryLabel","factoryWhitespace","factoryTitle","labelAfter","titleConstruct","literalType","literalMarkerType","rawType","stringType","limit","Infinity","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","markerType","labelEscape","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","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","_inactive","balanced","afterLabelEnd","resourceConstruct","fullReferenceConstruct","collapsedReferenceConstruct","media","_used","destinationAfter","afterLabel","sizeChunks","initialSize","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","furtherBlankLines","notInCurrentItem","indentConstruct","items","remove","parameters","chunkStart","hook","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","atTab","object","view","startIndex","startBufferIndex","endIndex","endBufferIndex","subcontent","stream","entered","adjust","startPositions","childEvents","jumps","gaps","isInFirstContentOfListItem","otherIndex","otherEvent","subevents","_movePreviousLineEndings","el","characters","char","entity","createElement","innerHTML","textContent","React","xtend","ReactIs","astToReact","renderer","renderers","pos","isValidElementType","nodeProps","getNodeProps","resolveChildren","childNode","props","opts","isSimpleRenderer","Fragment","sourcePos","rawSourcePos","sourcePosition","includeNodeIndex","parentChildCount","ref","definitions","assignDefined","className","nodeKey","level","loose","listItemLoose","listLoose","reduce","array","unwrapParagraphs","getListItemChildren","language","inline","linkTarget","href","transformLinkUri","transformImageUri","columnAlignment","isHeader","tag","isBlock","allowDangerousHtml","escapeHtml","skipHtml","parsedChildren","element","Children","toArray","cloneElement","mergeNodeChildren","attrs","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","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","linkReference","imageReference","bind","tableHead","tableBody","textAlign","coreProps","root","checkbox","readOnly","dangerous","dangerouslySetInnerHTML","__html","virtualHtml","parsedHtml","Symbol","protocols","uri","trim","first","wrap","Parser","doc","fromMarkdown","bail","plain","trough","vfile","frozen","attachers","transformers","namespace","freezeIndex","assertUnfrozen","freeze","addPlugin","addList","addPreset","plugin","entry","file","assertParser","newable","stringify","Compiler","assertCompiler","assertNode","run","complete","assertDone","error","process","processSync","destination","transformer","cb","Promise","executor","reject","pipeline","ctx","contents","asyncName","warningIssued","syntax","toMarkdown","blockTokenizers","visitors","console","warn","cache","res","str","num","substr","fns","middleware","fn","params","callback","invoked","then","Boolean","typeFactory","tests","checks","any","anyFactory","allFactory","visitParents","color","CONTINUE","SKIP","EXIT","reverse","step","is","factory","displayName","subresult","grandparents","toResult","VMessagePrototype","VMessage","proto","reason","origin","range","location","parseOrigin","message","ruleId","fatal","proc","VFile","order","prop","messages","history","cwd","assertPart","part","sep","assertNonEmpty","assertPath","get","set","dirname","basename","extname","stem","fail","normalize","absolute","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","lastIndexOf","normalizeString","JSON","ext","firstNonSlashEnd","seenNonSlash","extIndex","unmatchedSlash","startDot","startPart","preDotState","joined","SEO","ogTitle","description","isArticle","pathname","useLocation","siteMetadata","useSiteMetadata","defaultTitle","titleTemplate","defaultDescription","defaultImage","siteUrl","seo","Helmet","property","newsletterPost","articlePostTypeFilter","blogPostTypeFilter","caseStudyPostTypeFilter","podcastPostTypeFilter","webinarPostTypeFilter","postTypeFilters","Trans","icon","orderedFilters","blogFiltersSchema","operator","useStaticQuery","site","headingElementsMatch","H1","H2","H3","H4","H5","H6","gfm","singleQuote","StyledMarkdown2React","Link","colors","fontWeights","P","images","contentImages","Element","G","as","getImage","childImageSharp","StyledShareContainer","h5BaseStyle","ShareContentButtons","displayText","shareUrl","shareText","t","useTranslation","facebookShare","linkedinShare","twitterShare","rel","StyledBlogPostWrapper","ContentContainer","fonts","breakpoints","BlogPostWrapper","extraInfo","StyledBlogPostHero","heroBaseStyle","backgroundImageStyles","post","downloadLink","to","extra","localFile","publicURL","gaLabel","download","css","feature_image","blog_tags","sub_title","embeddedContentElement","EmbeddedVideo","EmbeddedPodcast","StyledExtraInfo","ExtraInfo","pageUrl","P2","blog_post_author","publish_date","BlogPostBody","ContactSalesCTAStyles","BlogPostBackground","GeometricPatternBackground","useContext","ContrastContext","setContrast","strapiBlogPost","EmbeddedElement","postDescription","embeddedElement","iframeSource","endOfPageCTA","linkText","cssStyles","getSrc","content_images","Download","Article","Blog","CaseStudy","Latest","Podcast","Report","Webinar","Whitepaper"],"mappings":";mHAEAA,EAAOC,QAEP,SAAcC,GACZ,GAAIA,EACF,MAAMA,I,+BCJVF,EAAOC,QAEP,SAAgBE,EAAQC,GACtB,IAEIC,EAFAC,EAAQC,OAAOJ,GACfK,EAAQ,EAGZ,GAAyB,iBAAdJ,EACT,MAAM,IAAIK,MAAM,sBAGlBJ,EAAQC,EAAMI,QAAQN,GAEtB,MAAkB,IAAXC,GACLG,IACAH,EAAQC,EAAMI,QAAQN,EAAWC,EAAQD,EAAUO,QAGrD,OAAOH,I,+BClBTR,EAAOC,QAAU,SAAUW,GACzB,GAAsB,iBAAXA,EACT,MAAM,IAAIC,UAAU,qBAKtB,OAAOD,EAAOE,QAAQ,sBAAuB,QAAQA,QAAQ,KAAM,W,+BCPrE,IAAIC,EAASC,OAAOC,UAAUC,eAC1BC,EAAQH,OAAOC,UAAUG,SACzBC,EAAiBL,OAAOK,eACxBC,EAAON,OAAOO,yBAEdC,EAAU,SAAiBC,GAC7B,MAA6B,mBAAlBC,MAAMF,QACRE,MAAMF,QAAQC,GAGI,mBAApBN,EAAMQ,KAAKF,IAGhBG,EAAgB,SAAuBC,GACzC,IAAKA,GAA2B,oBAApBV,EAAMQ,KAAKE,GACrB,OAAO,EAGT,IASIC,EATAC,EAAoBhB,EAAOY,KAAKE,EAAK,eACrCG,EAAmBH,EAAII,aAAeJ,EAAII,YAAYhB,WAAaF,EAAOY,KAAKE,EAAII,YAAYhB,UAAW,iBAE9G,GAAIY,EAAII,cAAgBF,IAAsBC,EAC5C,OAAO,EAOT,IAAKF,KAAOD,GAIZ,YAAsB,IAARC,GAAuBf,EAAOY,KAAKE,EAAKC,IAIpDI,EAAc,SAAqBC,EAAQC,GACzCf,GAAmC,cAAjBe,EAAQC,KAC5BhB,EAAec,EAAQC,EAAQC,KAAM,CACnCC,YAAY,EACZC,cAAc,EACdjC,MAAO8B,EAAQI,SACfC,UAAU,IAGZN,EAAOC,EAAQC,MAAQD,EAAQI,UAK/BE,EAAc,SAAqBb,EAAKQ,GAC1C,GAAa,cAATA,EAAsB,CACxB,IAAKtB,EAAOY,KAAKE,EAAKQ,GACpB,OACK,GAAIf,EAGT,OAAOA,EAAKO,EAAKQ,GAAM/B,MAI3B,OAAOuB,EAAIQ,IAGbrC,EAAOC,QAAU,SAAS0C,IACxB,IAAIP,EAASC,EAAMO,EAAKC,EAAMC,EAAaC,EACvCZ,EAASa,UAAU,GACnBC,EAAI,EACJtC,EAASqC,UAAUrC,OACnBuC,GAAO,EAaX,IAXsB,kBAAXf,IACTe,EAAOf,EACPA,EAASa,UAAU,IAAM,GAEzBC,EAAI,IAGQ,MAAVd,GAAoC,iBAAXA,GAAyC,mBAAXA,KACzDA,EAAS,IAGJc,EAAItC,IAAUsC,EAGnB,GAAe,OAFfb,EAAUY,UAAUC,IAIlB,IAAKZ,KAAQD,EACXQ,EAAMF,EAAYP,EAAQE,GAGtBF,KAFJU,EAAOH,EAAYN,EAASC,MAItBa,GAAQL,IAASjB,EAAciB,KAAUC,EAActB,EAAQqB,MAC7DC,GACFA,GAAc,EACdC,EAAQH,GAAOpB,EAAQoB,GAAOA,EAAM,IAEpCG,EAAQH,GAAOhB,EAAcgB,GAAOA,EAAM,GAI5CV,EAAYC,EAAQ,CAClBE,KAAMA,EACNG,SAAUG,EAAOO,EAAMH,EAAOF,WAEP,IAATA,GAChBX,EAAYC,EAAQ,CAClBE,KAAMA,EACNG,SAAUK,KAStB,OAAOV,I,kBCnHTnC,EAAOC,QAAU,SAAkB4B,GACjC,OAAc,MAAPA,GAAkC,MAAnBA,EAAII,aAA2D,mBAA7BJ,EAAII,YAAYkB,UAA2BtB,EAAII,YAAYkB,SAAStB,K,+BCL9H7B,EAAOC,QAAU,SAAUK,GACzB,GAA8C,oBAA1CU,OAAOC,UAAUG,SAASO,KAAKrB,GACjC,OAAO,EAGT,IAAIW,EAAYD,OAAOoC,eAAe9C,GACtC,OAAqB,OAAdW,GAAsBA,IAAcD,OAAOC,Y,mCCNpD,IAAIoC,EAAS,EAAQ,OAErBrD,EAAOC,QAgBP,SAAuBqD,EAAOlB,GAC5B,IAgBImB,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EA1BAC,EAAW9B,GAAW,GACtB+B,GAA+B,IAArBD,EAASC,QACnBC,GAAoC,IAA5BF,EAASG,eACjBC,GAAgC,IAA1BJ,EAASK,aACfC,GAASN,EAASM,OAAS,IAAIC,SAC/BC,GAA+C,IAA7BR,EAASQ,gBAC3BC,EAAa,GACbC,EAAeV,EAASU,cAAgBC,EACxCC,GAAY,EACZC,EAAYzB,EAAM3C,OAClBqE,EAAa,GACbC,EAAa,GACbC,EAAM,GACNC,EAAQ,GACRC,EAAsB,GACtBC,EAAkB,EActB,OAASP,EAAWC,GAAW,CAW7B,IAVAxB,EAAQD,EAAMwB,GACdtB,GAAe,EACfC,EAAeF,EAAM5C,OACrBuE,EAAM,GACNC,EAAQ,GAEJ1B,EAAe4B,IACjBA,EAAkB5B,KAGXD,EAAcC,GAwJRnD,EAvJIiD,EAAMC,GAAvBI,EAwJGtD,QAAwC,GAAKC,OAAOD,IAtJ/B,IAApBoE,IACFf,EAAOiB,EAAahB,GACpBuB,EAAM3B,GAAeG,QAGL2B,KAFhB5B,EAAU0B,EAAoB5B,KAEDG,EAAOD,KAClC0B,EAAoB5B,GAAeG,IAIvCuB,EAAIK,KAAK3B,GAGXoB,EAAWF,GAAYI,EACvBD,EAAWH,GAAYK,EAuI3B,IAAmB7E,EAhIjB,GAHAkD,GAAe,EACfC,EAAe4B,EAEM,iBAAVb,GAAsB,WAAYA,EAC3C,OAAShB,EAAcC,GACrBkB,EAAWnB,GAAegC,EAAYhB,EAAMhB,SAK9C,IAFAS,EAAOuB,EAAYhB,KAEVhB,EAAcC,GACrBkB,EAAWnB,GAAeS,EAK9BT,GAAe,EACfC,EAAe4B,EACfH,EAAM,GACNC,EAAQ,GAER,OAAS3B,EAAcC,GACrBQ,EAAOU,EAAWnB,GAClBO,EAAS,GACTC,EAAQ,GAzFJ,MA2FAC,EACFF,EAAS0B,EACAxB,IAASyB,EAClB1B,EAAQyB,EA/FN,KAgGOxB,IACTF,EAAS0B,EACTzB,EAAQyB,GAIV9B,EAAOe,EAAkBiB,KAAKC,IAAI,EAAGR,EAAoB5B,GAAeO,EAAOpD,OAASqD,EAAMrD,QAAU,EACxGiD,EAAOG,EAASV,EA9GT,IA8GsBM,GAAQK,GAEb,IAApBU,KACFf,EAAOI,EAAOpD,OAASgD,EAAOK,EAAMrD,QAEzByE,EAAoB5B,KAC7B4B,EAAoB5B,GAAeG,GAGrCwB,EAAM3B,GAAeG,GAGvBuB,EAAI1B,GAAeI,EAIrBoB,EAAWa,OAAO,EAAG,EAAGX,GACxBD,EAAWY,OAAO,EAAG,EAAGV,GACxBL,GAAY,EACZC,EAAYC,EAAWrE,OACvBkD,EAAQ,GAER,OAASiB,EAAWC,GAAW,CAO7B,IANAG,EAAMF,EAAWF,GACjBK,EAAQF,EAAWH,GACnBtB,GAAe,EACfC,EAAe4B,EACfvB,EAAO,KAEEN,EAAcC,GACrBG,EAAOsB,EAAI1B,IAAgB,GAC3BO,EAAS,GACTC,EAAQ,IAEgB,IAApBU,IACFf,EAAOyB,EAAoB5B,IAAgB2B,EAAM3B,IAAgB,IACjES,EAAOU,EAAWnB,MAELkC,EACX3B,EAASV,EAAOyC,EAAOnC,GA9IzB,KA+IWM,EACLN,EAAO,GAAM,GACfI,EAASV,EAAOyC,EAAOnC,EAAO,GAC9BK,EAAQD,IAERA,EAASV,EAAOyC,EAAOnC,EAAO,EAAI,IAClCK,EAAQX,EAAOyC,EAAOnC,EAAO,EAAI,KAGnCK,EAAQX,EAAOyC,EAAOnC,KAIZ,IAAVS,GAAkC,IAAhBZ,GACpBM,EAAKyB,KAlKK,MAqKI,IAAZpB,IAEkB,IAApBO,GAAsC,KAATd,IAA2B,IAAVQ,GAAkC,IAAhBZ,GAChEM,EAAKyB,KAAKO,IAGY,IAApBpB,GACFZ,EAAKyB,KAAKxB,GAGZD,EAAKyB,KAAK3B,IAEc,IAApBc,GACFZ,EAAKyB,KAAKvB,IAGI,IAAZG,GACFL,EAAKyB,KAAKO,IAGA,IAARxB,GAAgBd,IAAgBC,EAAe,GACjDK,EAAKyB,KA1LK,KA8LdzB,EAAOA,EAAKiC,KAAK,KAEL,IAARzB,IACFR,EAAOA,EAAKhD,QAAQkF,EAAoB,KAG1CnC,EAAM0B,KAAKzB,GAGb,OAAOD,EAAMkC,KA1MA,OAHf,IAAIC,EAAqB,MAErBF,EAAQ,IAGRL,EAAQ,IAQRC,EAAI,IAuMR,SAASb,EAAoBvE,GAC3B,OAAOA,EAAMK,OAGf,SAAS6E,EAAYlF,GACnB,IAAI2D,EAAwB,iBAAV3D,EAAqBA,EAAM2F,WAAW,GAlNlD,EAmNN,OAjNM,KAiNChC,GA9MD,MA8MeA,EA9Mf,IAFA,KAgNgCA,GAAcA,IAASyB,EAAIA,EAlN3D,KAkN+DzB,GA/M/D,KA+M6EA,EA/M7E,GAJA,I,sBCZR,IAAIiC,EAAmB,EAAQ,OAyB/BlG,EAAOC,QAvBP,WACE,OAAO,SAAUkG,GAkBf,OAjBAD,EAAiBC,EAAK,QAAQ,SAAUC,EAAUC,GAChD,IACIpD,EACAqD,EAFAC,EAAQ,EAIZ,IAAKtD,EAAI,EAAGqD,EAAID,EAAQ1F,OAAQsC,EAAIqD,EAAGrD,IACb,SAApBoD,EAAQpD,GAAGuD,OAAiBD,GAAS,GAG3C,IAAKtD,EAAI,EAAGqD,EAAIF,EAASK,SAAS9F,OAAQsC,EAAIqD,EAAGrD,IAAK,CACpD,IAAIyD,EAAQN,EAASK,SAASxD,GAC9ByD,EAAMrG,MAAQ4C,EACdyD,EAAMC,QAAUP,EAASO,QAG3BP,EAASG,MAAQA,KAEZJ,K,+BClBXnG,EAAOC,QAGP,SAAsB2G,EAAMJ,EAAMK,GAChC,IAAIC,EAAQ,GAEQ,mBAATN,IACTK,EAAUL,EACVA,EAAO,MAMT,SAASO,EAAIC,GACX,IAAIC,EAMJ,OAJKT,GAAQQ,EAAKR,OAASA,IACzBS,EAASJ,EAAQG,EAAMF,EAAMrC,WAG3BuC,EAAKP,WAAuB,IAAXQ,EASvB,SAAaR,EAAUS,GACrB,IAEIR,EAFA/F,EAAS8F,EAAS9F,OAClBN,GAAS,EAEbyG,EAAMvB,KAAK2B,GAEX,OAAS7G,EAAQM,GAGf,IAFA+F,EAAQD,EAASpG,MAEW,IAAf0G,EAAIL,GACf,OAAO,EAKX,OADAI,EAAMK,OACC,EAvBEC,CAAIJ,EAAKP,SAAUO,GAGrBC,EAdTF,EAAIH,K,mCCZN5G,EAAOC,QAUP,SAAwB2G,EAAMS,EAAMvG,EAASsB,GAC3C,IAAI8B,EACAoD,EAEgB,iBAATD,GAAqBA,GAA6B,mBAAdA,EAAKE,KAClDD,EAAS,CAAC,CAACD,EAAMvG,KAEjBwG,EAASD,EACTjF,EAAUtB,GAKZ,OADA0G,EAAOZ,EADP1C,EAAW9B,GAAW,GAItB,SAASqF,EAAeC,GACtB,IAAIC,EAAOD,EAAM,GACjB,OAAOE,EAEP,SAASA,EAAQZ,EAAME,GACrB,IAKIW,EACAC,EACAC,EACAzH,EARA+G,EAAOM,EAAK,GACZ7G,EAAU6G,EAAK,GACfK,EAAQ,GACR5D,EAAQ,EACR/D,EAAQ6G,EAAOT,SAAS/F,QAAQsG,GAQpC,IAHAK,EAAKY,UAAY,EACjBH,EAAQT,EAAKE,KAAKP,EAAK1G,OAEhBwH,IACLD,EAAWC,EAAMzH,OAMH,KALdC,EAAQQ,EAAQoH,MAAM,KAAM,GAAGzD,OAAOqD,EAAO,CAC3CzH,MAAOyH,EAAMzH,MACb8H,MAAOL,EAAMK,YAIT/D,IAAUyD,GACZG,EAAMzC,KAAK,CACTiB,KAAM,OACNlG,MAAO0G,EAAK1G,MAAM8H,MAAMhE,EAAOyD,KAId,iBAAVvH,GAAsBA,EAAMK,OAAS,IAC9CL,EAAQ,CACNkG,KAAM,OACNlG,MAAOA,IAIPA,IACF0H,EAAQ,GAAGvD,OAAOuD,EAAO1H,IAG3B8D,EAAQyD,EAAWC,EAAM,GAAGnH,QAGzB0G,EAAKgB,SAIVP,EAAQT,EAAKE,KAAKP,EAAK1G,OAkBzB,QAfiBgF,IAAbuC,GACFG,EAAQ,CAAChB,GACT3G,MAEI+D,EAAQ4C,EAAK1G,MAAMK,QACrBqH,EAAMzC,KAAK,CACTiB,KAAM,OACNlG,MAAO0G,EAAK1G,MAAM8H,MAAMhE,KAI5B4D,EAAMM,QAAQjI,EAAO,GACrBwF,EAAOqC,MAAMhB,EAAOT,SAAUuB,IAG5BN,EAAM/G,OAAS,EAIjB,IAHAoH,EAAaN,EAAeC,EAAMU,MAAM,IACxCP,GAAY,IAEHA,EAAWG,EAAMrH,QAGN,UAFlBqG,EAAOgB,EAAMH,IAEJrB,KACPuB,EAAWf,EAAME,GAEjBM,EAAOR,EAAM9C,EAAU6D,GAK7B,OAAO1H,EAAQ2H,EAAMrH,OAAS,GAtFX8G,CAoHzB,SAAiBH,GACf,IACIxF,EACAzB,EAFA4G,EAAS,GAIb,GAAsB,iBAAXK,EACT,MAAM,IAAI7G,MAAM,sCAGlB,GAAI,WAAY6G,EAGd,IAFAjH,GAAS,IAEAA,EAAQiH,EAAO3G,QACtBsG,EAAO1B,KAAK,CAACgD,EAAajB,EAAOjH,GAAO,IAAKmI,EAAWlB,EAAOjH,GAAO,WAGxE,IAAKyB,KAAOwF,EACVL,EAAO1B,KAAK,CAACgD,EAAazG,GAAM0G,EAAWlB,EAAOxF,MAItD,OAAOmF,EAzI+BwB,CAAQnB,KACvCV,GArBT,IAAI8B,EAAQ,EAAQ,OAEhBC,EAAU,EAAQ,OAElBC,EAAS,EAAQ,OAEjB/C,EAAS,GAAGA,OAyGhB,SAAS2B,EAAOZ,EAAM1C,EAAU0D,GAC9B,IAAIiB,EAAUF,EAAQzE,EAAS4E,QAAU,IAGzC,OADAJ,EAAM9B,EAAM,QAGZ,SAAiBI,EAAMX,GACrB,IACIa,EACA6B,EAFA1I,GAAS,EAIb,OAASA,EAAQgG,EAAQ1F,QAAQ,CAG/B,GAFAuG,EAASb,EAAQhG,GAEbwI,EAAQ3B,EAAQ6B,EAAcA,EAAYtC,SAAS/F,QAAQwG,QAAU5B,EAAWyD,GAClF,OAGFA,EAAc7B,EAGhB,OAAOU,EAAQZ,EAAM+B,MAnBV,GA+Cf,SAASR,EAAalB,GACpB,MAAuB,iBAATA,EAAoB,IAAI2B,OAAOJ,EAAOvB,GAAO,KAAOA,EAGpE,SAASmB,EAAW1H,GAClB,MAA0B,mBAAZA,EAAyBA,EAEvC,WACE,OAAOA,K,mCC1KXd,EAAOC,QAsBP,SAAsBK,EAAO2I,EAAU7G,GACb,iBAAb6G,IACT7G,EAAU6G,EACVA,OAAW3D,GAGb,OAIF,SAAkBlD,GAChB,IAAI8B,EAAW9B,GAAW,GACtB8G,EA6sBN,SAAmBA,EAAQC,GACzB,IAAI9I,GAAS,EAEb,OAASA,EAAQ8I,EAAWxI,QAC1ByI,EAAUF,EAAQC,EAAW9I,IAG/B,OAAO6I,EAptBMG,CAAU,CACrBC,WAAY,GACZC,eAAgB,CAAC,WAAY,WAAY,UAAW,YAAa,UACjEC,MAAO,CACLC,SAAUC,EAAOC,IACjBC,iBAAkBC,EAClBC,cAAeD,EACfE,WAAYL,EAAOM,IACnBC,WAAYP,EAAOO,IACnBC,gBAAiBL,EACjBM,mBAAoBN,EACpBO,WAAYV,EAAOW,IACnBC,oBAAqBC,EACrBC,oBAAqBD,EACrBE,aAAcf,EAAOW,GAAUE,GAC/BG,SAAUhB,EAAOgB,GAAUH,GAC3BI,aAAcd,EACde,KAAMf,EACNgB,cAAehB,EACfiB,WAAYpB,EAAOoB,IACnBC,4BAA6BR,EAC7BS,sBAAuBT,EACvBU,sBAAuBV,EACvBW,SAAUxB,EAAOwB,IACjBC,gBAAiBzB,EAAO0B,IACxBC,kBAAmB3B,EAAO0B,IAC1BE,SAAU5B,EAAO6B,GAAMhB,GACvBiB,aAAc3B,EACd4B,SAAU/B,EAAO6B,GAAMhB,GACvBmB,aAAc7B,EACd8B,MAAOjC,EAAOiC,IACdC,MAAOrB,EACPZ,KAAMD,EAAOC,IACbkC,SAAUnC,EAAOmC,IACjBC,cAAeC,EACfC,YAAatC,EAAOuC,GAAMC,GAC1BC,cAAezC,EAAOuC,IACtBG,UAAW1C,EAAO0C,IAClBC,UAAWC,EACXC,gBAAiBhC,EACjBiC,0BAA2BjC,EAC3BkC,oBAAqBlC,EACrBmC,cAAehD,EAAOM,IACtB2C,OAAQjD,EAAOiD,IACfC,cAAelD,EAAOkD,KAExBC,KAAM,CACJ9C,WAAY+C,IACZC,mBAAoBC,EACpBvD,SAAUqD,IACVhD,cAAemD,GACfrD,iBAAkBsD,GAClBjD,WAAY6C,IACZK,qBAAsBC,EACtBC,oCAAqCC,EACrCC,gCAAiCD,EACjCE,wBAAyBC,GACzBrD,WAAY0C,EAAOY,GACnBC,gBAAiBC,EACjBtD,oBAAqBuD,EACrBrD,oBAAqBsD,EACrBjD,cAAeuC,EACf3C,aAAcqC,EAAOiB,GACrBrD,SAAUoC,EAAOkB,GACjBrD,aAAcyC,EACdxC,KAAMwC,EACNtC,WAAYgC,IACZ/B,4BAA6BkD,EAC7BjD,sBAAuBkD,EACvBjD,sBAAuBkD,EACvBjD,SAAU4B,IACV3B,gBAAiB2B,EAAOsB,GACxB/C,kBAAmByB,EAAOsB,GAC1B9C,SAAUwB,EAAOuB,GACjB7C,aAAc4B,EACd3B,SAAUqB,EAAOwB,GACjB5C,aAAc0B,EACdzB,MAAOmB,EAAOyB,GACd3C,MAAO4C,EACPC,UAAWC,EACXC,WAAYC,EACZjF,KAAMmD,EAAO+B,GACbhD,SAAUiB,IACVd,YAAac,IACbX,cAAeW,IACfV,UAAWU,IACXP,gBAAiBuC,EACjBtC,0BAA2BuC,EAC3BtC,oBAAqBuC,EACrBC,SAAUC,EACVxC,cAAeI,EAAOqC,GACtBC,0BAA2BC,EAC3BC,kBAAmBC,EACnB5C,OAAQG,IACRF,cAAeE,MAEhB5I,EAASsL,iBAAmB,IAC3B5E,EAAO,GACX,OAAO6E,EAEP,SAASA,EAAQC,GAuBf,IAtBA,IAQI9H,EARAhB,EAAO,CACTJ,KAAM,OACNC,SAAU,IAGRkJ,EAAa,GACbC,EAAY,GACZvP,GAAS,EAGTwP,EAAU,CACZ/I,MAPU,CAACF,GAQX+I,WAAYA,EACZzG,OAAQA,EACRM,MAAOA,EACPqD,KAAMA,EACNtC,OAAQA,EACRuF,OAAQA,EACRC,QAASA,EACTC,QAASA,KAGF3P,EAAQqP,EAAO/O,QAGQ,gBAA1B+O,EAAOrP,GAAO,GAAGmG,MAAoD,kBAA1BkJ,EAAOrP,GAAO,GAAGmG,OACrC,UAArBkJ,EAAOrP,GAAO,GAChBuP,EAAUrK,KAAKlF,GAGfA,EAAQ4P,EAAYP,EADRE,EAAUzI,IAAI9G,GACaA,IAO7C,IAFAA,GAAS,IAEAA,EAAQqP,EAAO/O,QACtBiH,EAAUsB,EAAOwG,EAAOrP,GAAO,IAE3B6P,EAAIvO,KAAKiG,EAAS8H,EAAOrP,GAAO,GAAGmG,OACrCoB,EAAQ8H,EAAOrP,GAAO,GAAGmG,MAAM7E,KAAKwO,EAAO,CACzCC,eAAgBV,EAAOrP,GAAO,GAAG+P,gBAChCP,GAAUH,EAAOrP,GAAO,IAI/B,GAAIsP,EAAWhP,OACb,MAAM,IAAIF,MAAM,oCAAsCkP,EAAWA,EAAWhP,OAAS,GAAG6F,KAAO,MAAQ6J,EAAkB,CACvHjM,MAAOuL,EAAWA,EAAWhP,OAAS,GAAGyD,MACzCE,IAAKqL,EAAWA,EAAWhP,OAAS,GAAG2D,MACpC,mBAkBP,IAdAsC,EAAKiB,SAAW,CACdzD,MAAOkM,EAAMZ,EAAO/O,OAAS+O,EAAO,GAAG,GAAGtL,MAAQ,CAChDN,KAAM,EACNyM,OAAQ,EACRC,OAAQ,IAEVlM,IAAKgM,EAAMZ,EAAO/O,OAAS+O,EAAOA,EAAO/O,OAAS,GAAG,GAAG2D,IAAM,CAC5DR,KAAM,EACNyM,OAAQ,EACRC,OAAQ,KAGZnQ,GAAS,IAEAA,EAAQ6I,EAAOI,WAAW3I,QACjCiG,EAAOsC,EAAOI,WAAWjJ,GAAOuG,IAASA,EAG3C,OAAOA,EAGT,SAASqJ,EAAYP,EAAQtL,EAAOzD,GAYlC,IAXA,IAGIkL,EACA4E,EACAC,EACAC,EACAC,EACAC,EACAC,EATAzQ,EAAQ+D,EAAQ,EAChB2M,GAAoB,EACpBC,GAAa,IASR3Q,GAASM,GAwBhB,GArBsB,mBAFtBiQ,EAAQlB,EAAOrP,IAEL,GAAGmG,MAA8C,gBAAlBoK,EAAM,GAAGpK,MAA4C,eAAlBoK,EAAM,GAAGpK,MAClE,UAAboK,EAAM,GACRG,IAEAA,IAGFD,OAAWxL,GACgB,oBAAlBsL,EAAM,GAAGpK,KACD,UAAboK,EAAM,MACJ/E,GAAaiF,GAAaC,GAAqBF,IACjDA,EAAsBxQ,GAGxByQ,OAAWxL,GAEc,eAAlBsL,EAAM,GAAGpK,MAA2C,kBAAlBoK,EAAM,GAAGpK,MAA8C,mBAAlBoK,EAAM,GAAGpK,MAA+C,mBAAlBoK,EAAM,GAAGpK,MAA+C,6BAAlBoK,EAAM,GAAGpK,OAErKsK,OAAWxL,IAGRyL,GAAiC,UAAbH,EAAM,IAAoC,mBAAlBA,EAAM,GAAGpK,OAAmD,IAAtBuK,GAAwC,SAAbH,EAAM,KAAoC,kBAAlBA,EAAM,GAAGpK,MAA8C,gBAAlBoK,EAAM,GAAGpK,MAAyB,CAC/M,GAAIqF,EAAU,CAIZ,IAHA4E,EAAYpQ,EACZqQ,OAAYpL,EAELmL,KAGL,GAA0B,gBAF1BE,EAAYjB,EAAOe,IAEL,GAAGjK,MAA+C,oBAAtBmK,EAAU,GAAGnK,KAA4B,CACjF,GAAqB,SAAjBmK,EAAU,GAAe,SAEzBD,IACFhB,EAAOgB,GAAW,GAAGlK,KAAO,kBAC5BwK,GAAa,GAGfL,EAAU,GAAGnK,KAAO,aACpBkK,EAAYD,OACP,GAA0B,eAAtBE,EAAU,GAAGnK,MAA+C,qBAAtBmK,EAAU,GAAGnK,MAAqD,+BAAtBmK,EAAU,GAAGnK,MAA+D,qBAAtBmK,EAAU,GAAGnK,MAAqD,mBAAtBmK,EAAU,GAAGnK,KAE1M,MAIAqK,KAAyBH,GAAaG,EAAsBH,KAC9D7E,EAASoF,SAAU,GAIrBpF,EAASvH,IAAMgM,EAAMI,EAAYhB,EAAOgB,GAAW,GAAGtM,MAAQwM,EAAM,GAAGtM,KACvEoL,EAAO7J,OAAO6K,GAAarQ,EAAO,EAAG,CAAC,OAAQwL,EAAU+E,EAAM,KAC9DvQ,IACAM,IAIoB,mBAAlBiQ,EAAM,GAAGpK,OACXqF,EAAW,CACTrF,KAAM,WACNyK,SAAS,EACT7M,MAAOkM,EAAMM,EAAM,GAAGxM,QAExBsL,EAAO7J,OAAOxF,EAAO,EAAG,CAAC,QAASwL,EAAU+E,EAAM,KAClDvQ,IACAM,IACAkQ,OAAsBvL,EACtBwL,GAAW,GAMjB,OADApB,EAAOtL,GAAO,GAAG6M,QAAUD,EACpBrQ,EAGT,SAASoP,EAAQjO,EAAKxB,GACpBsK,EAAK9I,GAAOxB,EAGd,SAAS0P,EAAQlO,GACf,OAAO8I,EAAK9I,GAGd,SAASwO,EAAMY,GACb,MAAO,CACLpN,KAAMoN,EAAEpN,KACRyM,OAAQW,EAAEX,OACVC,OAAQU,EAAEV,QAId,SAAS9G,EAAOyH,EAAQC,GACtB,OAAOC,EAEP,SAASA,EAAKC,GACZ9H,EAAM7H,KAAK4P,KAAMJ,EAAOG,GAAQA,GAC5BF,GAAKA,EAAIzP,KAAK4P,KAAMD,IAI5B,SAAS/G,IACPgH,KAAKzK,MAAMvB,KAAK,CACdiB,KAAM,WACNC,SAAU,KAId,SAAS+C,EAAMxC,EAAMsK,GAOnB,OANAC,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAG8F,SAASlB,KAAKyB,GAChDuK,KAAKzK,MAAMvB,KAAKyB,GAChBuK,KAAK5B,WAAWpK,KAAK+L,GACrBtK,EAAKa,SAAW,CACdzD,MAAOkM,EAAMgB,EAAMlN,QAEd4C,EAGT,SAAS8F,EAAOsE,GACd,OAAOI,EAEP,SAASA,EAAMF,GACTF,GAAKA,EAAIzP,KAAK4P,KAAMD,GACxBzE,EAAKlL,KAAK4P,KAAMD,IAIpB,SAASzE,EAAKyE,GACZ,IAAItK,EAAOuK,KAAKzK,MAAMK,MAClBkK,EAAOE,KAAK5B,WAAWxI,MAE3B,IAAKkK,EACH,MAAM,IAAI5Q,MAAM,iBAAmB6Q,EAAM9K,KAAO,MAAQ6J,EAAkB,CACxEjM,MAAOkN,EAAMlN,MACbE,IAAKgN,EAAMhN,MACR,oBACA,GAAI+M,EAAK7K,OAAS8K,EAAM9K,KAC7B,MAAM,IAAI/F,MAAM,iBAAmB6Q,EAAM9K,KAAO,MAAQ6J,EAAkB,CACxEjM,MAAOkN,EAAMlN,MACbE,IAAKgN,EAAMhN,MACR,0BAA4B+M,EAAK7K,KAAO,MAAQ6J,EAAkB,CACrEjM,MAAOiN,EAAKjN,MACZE,IAAK+M,EAAK/M,MACP,aAIP,OADA0C,EAAKa,SAASvD,IAAMgM,EAAMgB,EAAMhN,KACzB0C,EAGT,SAAS8I,IACP,OAAO1O,EAASmQ,KAAKzK,MAAMK,OAM7B,SAAS+E,IACP6D,EAAQ,+BAA+B,GAGzC,SAAShE,EAAqBuF,GACxBtB,EAAQ,iCACVuB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGyD,MAAQqN,SAASF,KAAKnB,eAAekB,GAAQ,IAC/EvB,EAAQ,gCAIZ,SAASlC,IACP,IAAIjD,EAAO2G,KAAKzB,SAChByB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAG+Q,KAAO9G,EAG3C,SAASkD,IACP,IAAIlD,EAAO2G,KAAKzB,SAChByB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGgR,KAAO/G,EAG3C,SAASgD,IAEHoC,EAAQ,oBACZuB,KAAKhH,SACLwF,EAAQ,kBAAkB,IAG5B,SAASrC,IACP,IAAI9C,EAAO2G,KAAKzB,SAChByB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGL,MAAQsK,EAAK9J,QAAQ,2BAA4B,IACnFiP,EAAQ,kBAGV,SAAShC,IACP,IAAInD,EAAO2G,KAAKzB,SAChByB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGL,MAAQsK,EAG5C,SAASsD,EAA4BoD,GAEnC,IAAI1F,EAAQ2F,KAAKzB,SACjByB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGiL,MAAQA,EAC1C2F,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGiR,WAAaC,EAAoBN,KAAKnB,eAAekB,IAAQQ,cAGjG,SAAS3D,IACP,IAAIvD,EAAO2G,KAAKzB,SAChByB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGoR,MAAQnH,EAG5C,SAASqD,IACP,IAAIrD,EAAO2G,KAAKzB,SAChByB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGqR,IAAMpH,EAG1C,SAASoC,EAAyBsE,GAC3BC,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAG4F,QACrCgL,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAG4F,MAAQgL,KAAKnB,eAAekB,GAAO3Q,QAIzE,SAAS4O,IACPQ,EAAQ,gCAAgC,GAG1C,SAASV,EAAgCiC,GACvCC,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAG4F,MAAqD,KAA7CgL,KAAKnB,eAAekB,GAAOrL,WAAW,GAAY,EAAI,EAGlG,SAASkJ,IACPY,EAAQ,gCAGV,SAASlG,EAAYyH,GACnB,IAAIW,EAAWV,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAG8F,SAC7CyL,EAAOD,EAASA,EAAStR,OAAS,GAEjCuR,GAAsB,SAAdA,EAAK1L,QAEhB0L,EAAOC,MACFtK,SAAW,CACdzD,MAAOkM,EAAMgB,EAAMlN,QAErBmN,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAG8F,SAASlB,KAAK2M,IAGlDX,KAAKzK,MAAMvB,KAAK2M,GAGlB,SAAS9E,EAAWkE,GAClB,IAAIY,EAAOX,KAAKzK,MAAMK,MACtB+K,EAAK5R,OAASiR,KAAKnB,eAAekB,GAClCY,EAAKrK,SAASvD,IAAMgM,EAAMgB,EAAMhN,KAGlC,SAASsK,EAAiB0C,GACxB,IAAIzB,EAAU0B,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAE7C,GAAIqP,EAAQ,eAGV,OAFAH,EAAQpJ,SAASoJ,EAAQpJ,SAAS9F,OAAS,GAAGkH,SAASvD,IAAMgM,EAAMgB,EAAMhN,UACzEyL,EAAQ,gBAILC,EAAQ,iCAAmC9G,EAAOK,eAAe7I,QAAQmP,EAAQrJ,OAAS,IAC7FqD,EAAYlI,KAAK4P,KAAMD,GACvBlE,EAAWzL,KAAK4P,KAAMD,IAI1B,SAASlD,IACP2B,EAAQ,eAAe,GAGzB,SAAS1B,IACP,IAAIzD,EAAO2G,KAAKzB,SAChByB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGL,MAAQsK,EAG5C,SAAS0D,IACP,IAAI1D,EAAO2G,KAAKzB,SAChByB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGL,MAAQsK,EAG5C,SAASoD,IACP,IAAIpD,EAAO2G,KAAKzB,SAChByB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGL,MAAQsK,EAG5C,SAASiE,IACP,IAAIgB,EAAU0B,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAEzCqP,EAAQ,gBACVH,EAAQrJ,MAAQ,YAChBqJ,EAAQuC,cAAgBpC,EAAQ,kBAAoB,kBAC7CH,EAAQmC,WACRnC,EAAQkC,eAERlC,EAAQ+B,kBACR/B,EAAQjE,aACRiE,EAAQuC,eAGjBrC,EAAQ,iBAGV,SAASxB,IACP,IAAIsB,EAAU0B,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAEzCqP,EAAQ,gBACVH,EAAQrJ,MAAQ,YAChBqJ,EAAQuC,cAAgBpC,EAAQ,kBAAoB,kBAC7CH,EAAQmC,WACRnC,EAAQkC,eAERlC,EAAQ+B,kBACR/B,EAAQjE,aACRiE,EAAQuC,eAGjBrC,EAAQ,iBAGV,SAASrB,EAAgB4C,GACvBC,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGiR,WAAaC,EAAoBN,KAAKnB,eAAekB,IAAQQ,cAGjG,SAAStD,IACP,IAAI6D,EAAWd,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAC1CL,EAAQiR,KAAKzB,SACjByB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGiL,MAAQtL,EAE1CyP,EAAQ,eAAe,GAEwB,SAA3CwB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAG6F,KACpC+K,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAG8F,SAAW4L,EAAS5L,SAEtD8K,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAG2R,IAAMhS,EAI5C,SAASyO,IACP,IAAInE,EAAO2G,KAAKzB,SAChByB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGqR,IAAMpH,EAG1C,SAASoE,IACP,IAAIpE,EAAO2G,KAAKzB,SAChByB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGoR,MAAQnH,EAG5C,SAASsE,IACPa,EAAQ,eAGV,SAASzD,IACPyD,EAAQ,gBAAiB,aAG3B,SAASjB,EAAsBwC,GAC7B,IAAI1F,EAAQ2F,KAAKzB,SACjByB,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGiL,MAAQA,EAC1C2F,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGiR,WAAaC,EAAoBN,KAAKnB,eAAekB,IAAQQ,cAC/F/B,EAAQ,gBAAiB,QAG3B,SAASzC,EAA+BgE,GACtCvB,EAAQ,yBAA0BuB,EAAM9K,MAG1C,SAASiH,GAA8B6D,GACrC,IAEIhR,EACA4R,EAHAtH,EAAO2G,KAAKnB,eAAekB,GAC3B9K,EAAOwJ,EAAQ,0BAIfxJ,GACFlG,EAAQiS,EAAY3H,EAAe,oCAATpE,EAA6C,GAAK,IAC5EuJ,EAAQ,2BAERzP,EAAQkS,EAAO5H,IAGjBsH,EAAOX,KAAKzK,MAAMK,OACb7G,OAASA,EACd4R,EAAKrK,SAASvD,IAAMgM,EAAMgB,EAAMhN,KAGlC,SAAS4I,GAAuBoE,GAC9BlE,EAAWzL,KAAK4P,KAAMD,GACtBC,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGqR,IAAMT,KAAKnB,eAAekB,GAG9D,SAASrE,GAAoBqE,GAC3BlE,EAAWzL,KAAK4P,KAAMD,GACtBC,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGqR,IAAM,UAAYT,KAAKnB,eAAekB,GAM1E,SAASrH,KACP,MAAO,CACLzD,KAAM,aACNC,SAAU,IAId,SAAS4D,KACP,MAAO,CACL7D,KAAM,OACNkL,KAAM,KACNC,KAAM,KACNrR,MAAO,IAIX,SAASoK,KACP,MAAO,CACLlE,KAAM,aACNlG,MAAO,IAIX,SAASwK,KACP,MAAO,CACLtE,KAAM,aACNoL,WAAY,GACZhG,MAAO,KACPmG,MAAO,KACPC,IAAK,IAIT,SAAS9G,KACP,MAAO,CACL1E,KAAM,WACNC,SAAU,IAId,SAASuD,KACP,MAAO,CACLxD,KAAM,UACND,WAAOjB,EACPmB,SAAU,IAId,SAAS2E,KACP,MAAO,CACL5E,KAAM,SAIV,SAAS+E,KACP,MAAO,CACL/E,KAAM,OACNlG,MAAO,IAIX,SAASqL,KACP,MAAO,CACLnF,KAAM,QACNuL,MAAO,KACPC,IAAK,GACLM,IAAK,MAIT,SAAS3I,KACP,MAAO,CACLnD,KAAM,OACNuL,MAAO,KACPC,IAAK,GACLvL,SAAU,IAId,SAASwF,GAAKqF,GACZ,MAAO,CACL9K,KAAM,OACNG,QAAwB,gBAAf2K,EAAM9K,KACfpC,MAAO,KACPqO,OAAQnB,EAAML,QACdxK,SAAU,IAId,SAASoF,GAASyF,GAChB,MAAO,CACL9K,KAAM,WACNiM,OAAQnB,EAAML,QACdyB,QAAS,KACTjM,SAAU,IAId,SAAS2F,KACP,MAAO,CACL5F,KAAM,YACNC,SAAU,IAId,SAASkG,KACP,MAAO,CACLnG,KAAM,SACNC,SAAU,IAId,SAAS0L,KACP,MAAO,CACL3L,KAAM,OACNlG,MAAO,IAIX,SAASsM,KACP,MAAO,CACLpG,KAAM,kBA9sBHmM,CAASvQ,EAATuQ,CAAkBC,EAAYC,EAAOzQ,GAAS0Q,WAAWC,MAAMC,IAAe1S,EAAO2I,GAAU,OA1BxG,IAAI7H,EAAW,EAAQ,OAEnB+O,EAAS,EAAQ,MAEjBD,EAAM,EAAQ,OAEd2B,EAAsB,EAAQ,MAE9BU,EAAc,EAAQ,OAEtBM,EAAS,EAAQ,OAEjBG,EAAe,EAAQ,OAEvBJ,EAAc,EAAQ,OAEtBJ,EAAS,EAAQ,OAEjBnC,EAAoB,EAAQ,MAquBhC,SAASjH,EAAUF,EAAQE,GACzB,IAAItH,EACAmR,EAEJ,IAAKnR,KAAOsH,EACV6J,EAAO/C,EAAIvO,KAAKuH,EAAQpH,GAAOoH,EAAOpH,GAAOoH,EAAOpH,GAAO,GAE/C,mBAARA,GAAoC,eAARA,EAC9BoH,EAAOpH,GAAO,GAAG2C,OAAOwO,EAAM7J,EAAUtH,IAExCd,OAAOmP,OAAO8C,EAAM7J,EAAUtH,M,mCCnwBpC9B,EAAOC,QAAU,EAAjB,Q,sBCFA,IAAIiT,EAAS,EAAQ,OAEjBC,EAAiB,EAAQ,OAEzBC,EAAqB,EAAQ,OAE7BC,EAAoB,EAAQ,OAyBhC,SAASC,EAA0BhC,GACjCC,KAAKrI,OAAOM,MAAMI,iBAAiBjI,KAAK4P,KAAMD,GA0BhD,SAASiC,EAAQC,EAAIC,EAAUC,EAAQC,EAAM7L,GAC3C,IACI8L,EACA3M,EAFA4M,EAAS,GAIb,QAAKC,EAAShM,KAKV,MAAMiM,KAAKN,KACbC,EAASD,EAAWC,EACpBD,EAAW,GACXI,EAAS,aA8Cb,SAAyBH,GACvB,IAAIE,EAAQF,EAAOM,MAAM,KAEzB,GAAIJ,EAAMjT,OAAS,GAAKiT,EAAMA,EAAMjT,OAAS,KAAO,IAAIoT,KAAKH,EAAMA,EAAMjT,OAAS,MAAQ,aAAaoT,KAAKH,EAAMA,EAAMjT,OAAS,MAAQiT,EAAMA,EAAMjT,OAAS,KAAO,IAAIoT,KAAKH,EAAMA,EAAMjT,OAAS,MAAQ,aAAaoT,KAAKH,EAAMA,EAAMjT,OAAS,KAChP,OAAO,EAGT,OAAO,EAlDFsT,CAAgBP,QAIrBE,EAiDF,SAAkB5B,GAChB,IACIkC,EACAC,EACAC,EAHAC,EAAQ,sBAAsB9M,KAAKyK,GAKvC,GAAIqC,EAOF,IANArC,EAAMA,EAAI5J,MAAM,EAAGiM,EAAMhU,OAEzB6T,GADAG,EAAQA,EAAM,IACY3T,QAAQ,KAClCyT,EAAgBjB,EAAOlB,EAAK,KAC5BoC,EAAgBlB,EAAOlB,EAAK,MAEE,IAAvBkC,GAA4BC,EAAgBC,GACjDpC,GAAOqC,EAAMjM,MAAM,EAAG8L,EAAoB,GAE1CA,GADAG,EAAQA,EAAMjM,MAAM8L,EAAoB,IACdxT,QAAQ,KAClC0T,IAIJ,MAAO,CAACpC,EAAKqC,GAtELC,CAASZ,EAASC,IACf,KACX1M,EAAS,CACPT,KAAM,OACNuL,MAAO,KACPC,IAAK6B,EAASJ,EAAWG,EAAM,GAC/BnN,SAAU,CAAC,CACTD,KAAM,OACNlG,MAAOmT,EAAWG,EAAM,MAIxBA,EAAM,KACR3M,EAAS,CAACA,EAAQ,CAChBT,KAAM,OACNlG,MAAOsT,EAAM,MAIV3M,KAGT,SAASsN,EAAUf,EAAIgB,EAAO5I,EAAO9D,GAEnC,SAAKgM,EAAShM,GAAO,IAAS,QAAQiM,KAAKnI,KAIpC,CACLpF,KAAM,OACNuL,MAAO,KACPC,IAAK,UAAYwC,EAAQ,IAAM5I,EAC/BnF,SAAU,CAAC,CACTD,KAAM,OACNlG,MAAOkU,EAAQ,IAAM5I,KAuC3B,SAASkI,EAAShM,EAAO2M,GACvB,IAAIxQ,EAAO6D,EAAMK,MAAMlC,WAAW6B,EAAMzH,MAAQ,GAChD,OAAQ4D,GAASA,GAAQoP,EAAkBpP,IAASmP,EAAmBnP,OAAYwQ,GAAkB,KAATxQ,GAjJ9FhE,EAAQqJ,WAAa,CA4CrB,SAAsC1C,GACpCuM,EAAevM,EAAM,CAAC,CAAC,iDAAkD2M,GAAU,CAAC,mCAAoCgB,IAAa,CACnIzL,OAAQ,CAAC,OAAQ,qBA7CrB7I,EAAQuJ,MAAQ,CACdkL,gBAYF,SAA8BpD,GAC5BC,KAAK/H,MAAM,CACThD,KAAM,OACNuL,MAAO,KACPC,IAAK,GACLvL,SAAU,IACT6K,IAjBHqD,qBAAsBrB,EACtBsB,oBAAqBtB,EACrBuB,mBAAoBvB,GAEtBrT,EAAQ4M,KAAO,CACb6H,gBAgCF,SAA6BpD,GAC3BC,KAAK1E,KAAKyE,IAhCVqD,qBA2BF,SAAkCrD,GAChCC,KAAKrI,OAAO2D,KAAK/C,cAAcnI,KAAK4P,KAAMD,IA3B1CsD,oBAiBF,SAAiCtD,GAC/BC,KAAKrI,OAAO2D,KAAKjD,iBAAiBjI,KAAK4P,KAAMD,IAjB7CuD,mBAoBF,SAAgCvD,GAC9BC,KAAKrI,OAAO2D,KAAKjC,KAAKjJ,KAAK4P,KAAMD,GACjCC,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGqR,IAAM,UAAYT,KAAKnB,eAAekB,M,oBCzC1E,IAAIwD,EAAc,WACdC,EAAiB,CAAC,WAAY,OAAQ,QAAS,SACnD9U,EAAQ+U,OAAS,CAAC,CAChB5U,UAAW,IACX2D,OAAQ,aACRC,MAAO,YACP8Q,YAAaA,EACbC,eAAgBA,GACf,CACD3U,UAAW,IACX2D,OAAQ,OACRC,MAAO,YACP8Q,YAAaA,EACbC,eAAgBA,GACf,CACD3U,UAAW,IACX2D,OAAQ,OACRC,MAAO,MACP8Q,YAAaA,EACbC,eAAgBA,K,oBCnBlB9U,EAAQsJ,eAAiB,CAAC,UAC1BtJ,EAAQuJ,MAAQ,CACdyL,cAMF,SAA4B3D,GAC1BC,KAAK/H,MAAM,CACThD,KAAM,SACNC,SAAU,IACT6K,KARLrR,EAAQ4M,KAAO,CACboI,cAUF,SAA2B3D,GACzBC,KAAK1E,KAAKyE,M,sBChBZ,IAAI4D,EAAW,EAAQ,OAWvB,SAASC,EAAanO,EAAMoO,EAAGvF,GAC7B,IAAIhD,EAAOgD,EAAQrG,MAAM,YACrBlJ,EAAQ4U,EAASlO,EAAM6I,EAAS,CAClC9L,OAAQ,IACRC,MAAO,MAGT,OADA6I,IACO,KAAOvM,EAAQ,KAhBxBL,EAAQ+U,OAAS,CAAC,CAChB5U,UAAW,IACX0U,YAAa,aAEf7U,EAAQoV,SAAW,CACjBC,OAAQH,GAEVA,EAAaI,KAYb,WACE,MAAO,M,oBCaT,SAAS1I,EAAKyE,GACZC,KAAK1E,KAAKyE,GAGZ,SAASkE,EAAUlE,GACjBC,KAAK/H,MAAM,CACThD,KAAM,YACNC,SAAU,IACT6K,GAgBL,SAASxQ,EAAQ0S,EAAIiC,GAEnB,MAAc,MAAPA,EAAaA,EAAKjC,EA7D3BvT,EAAQuJ,MAAQ,CACdlG,MAaF,SAAoBgO,GAClBC,KAAK/H,MAAM,CACThD,KAAM,QACNhC,MAAO8M,EAAMoE,OACbjP,SAAU,IACT6K,GACHC,KAAKxB,QAAQ,WAAW,IAlBxB4F,UAAWH,EACXI,YAAaJ,EACbK,SAwBF,SAAkBvE,GAChBC,KAAK/H,MAAM,CACThD,KAAM,WACNC,SAAU,IACT6K,KA1BLrR,EAAQ4M,KAAO,CACbnC,SAyCF,SAAsB4G,GACpB,IAAIhR,EAAQiR,KAAKzB,SAEbyB,KAAKvB,QAAQ,aACf1P,EAAQA,EAAMQ,QAAQ,aAAcA,IAGtCyQ,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAGL,MAAQA,EAC1CiR,KAAK1E,KAAKyE,IAhDVhO,MAeF,SAAmBgO,GACjBC,KAAK1E,KAAKyE,GACVC,KAAKxB,QAAQ,YAhBb4F,UAAW9I,EACX+I,YAAa/I,EACbgJ,SAAUhJ,I,sBCXZ,IAAIqI,EAAW,EAAQ,OAEnBY,EAAoB,EAAQ,OAE5BC,EAAgB,EAAQ,OAE5B/V,EAAOC,QAEP,SAAoBmC,GAClB,IAAI8B,EAAW9B,GAAW,GACtB+B,EAAUD,EAAS8R,iBACnBtR,EAAkBR,EAAS+R,eAC3BrR,EAAeV,EAASU,aACxBsR,EAAS/R,EAAU,IAAM,IAC7B,MAAO,CACL6Q,OAAQ,CAAC,CACP5U,UAAW,KACX0U,YAAa,aACZ,CACD1U,UAAW,KACX0U,YAAa,aAGf,CACEqB,SAAS,EACT/V,UAAW,IACX4D,MAAO,WAET,CACE5D,UAAW,IACX0U,YAAa,aAGf,CACEqB,SAAS,EACT/V,UAAW,IACX4D,MAAO,KAMT,CACEmS,SAAS,EACT/V,UAAW,IACX4D,MAAO,UAETqR,SAAU,CACR/R,MAOJ,SAAqB0D,EAAMoO,EAAGvF,GAC5B,OAAOuG,EAgCT,SAA2BpP,EAAM6I,GAC/B,IAAIpJ,EAAWO,EAAKP,SAChBpG,GAAS,EACTM,EAAS8F,EAAS9F,OAClBsG,EAAS,GACToP,EAAUxG,EAAQrG,MAAM,SAE5B,OAASnJ,EAAQM,GACfsG,EAAO5G,GAASiW,EAAqB7P,EAASpG,GAAQwP,GAIxD,OADAwG,IACOpP,EA5CcsP,CAAkBvP,EAAM6I,GAAU7I,EAAKxC,QAP1DqR,SAaJ,SAAwB7O,EAAMoO,EAAGvF,GAC/B,IAEIvP,EAAQ8V,EAAc,CAFhBE,EAAqBtP,EAAM6I,KAGrC,OAAOvP,EAAM8H,MAAM,EAAG9H,EAAMI,QAAQ,QAhBlC8V,UAAWC,EACXC,WAmEJ,SAA6B1P,EAAME,EAAQ2I,GACzC,IAAIvP,EAAQwV,EAAkB9O,EAAME,EAAQ2I,IAEA,IAAxCA,EAAQ/I,MAAMpG,QAAQ,eACxBJ,EAAQA,EAAMQ,QAAQ,MAAO,SAG/B,OAAOR,KAxDT,SAASmW,EAAgBzP,EAAMoO,EAAGvF,GAChC,IAAIhD,EAAOgD,EAAQrG,MAAM,aACrBlJ,EAAQ4U,EAASlO,EAAM6I,EAAS,CAClC9L,OAAQmS,EACRlS,MAAOkS,IAGT,OADArJ,IACOvM,EAGT,SAAS8V,EAAcO,EAAQnS,GAC7B,OAAOuR,EAAcY,EAAQ,CAC3BnS,MAAOA,EACPE,gBAAiBA,EACjBP,QAASA,EACTS,aAAcA,IAmBlB,SAAS0R,EAAqBtP,EAAM6I,GAOlC,IANA,IAAIpJ,EAAWO,EAAKP,SAChBpG,GAAS,EACTM,EAAS8F,EAAS9F,OAClBsG,EAAS,GACToP,EAAUxG,EAAQrG,MAAM,cAEnBnJ,EAAQM,GACfsG,EAAO5G,GAASoW,EAAgBhQ,EAASpG,GAAQ2G,EAAM6I,GAIzD,OADAwG,IACOpP,K,oBC7GX,SAAS2P,EAAUtF,GAEjBC,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GAAG+R,QAAyB,8BAAfpB,EAAM9K,KARpDvG,EAAQ4M,KAAO,CACbgK,0BAA2BD,EAC3BE,4BAA6BF,EAC7BxK,UAQF,SAAuCkF,GACrC,IAKIyF,EALA7P,EAASqK,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GACxCqG,EAAOuK,KAAKzK,MAAMyK,KAAKzK,MAAMnG,OAAS,GACtCsR,EAAW/K,EAAOT,SAClBuQ,EAAOhQ,EAAKP,SAAS,GACrBpG,GAAS,EAGb,GAAI6G,GAA0B,aAAhBA,EAAOV,MAAiD,kBAAnBU,EAAOwL,SAAyBsE,GAAsB,SAAdA,EAAKxQ,KAAiB,CAC/G,OAASnG,EAAQ4R,EAAStR,QACxB,GAA6B,cAAzBsR,EAAS5R,GAAOmG,KAAsB,CACxCuQ,EAAkB9E,EAAS5R,GAC3B,MAIA0W,IAAoB/P,IAEtBgQ,EAAK1W,MAAQ0W,EAAK1W,MAAM8H,MAAM,GAEJ,IAAtB4O,EAAK1W,MAAMK,OACbqG,EAAKP,SAASwQ,SAEdD,EAAKnP,SAASzD,MAAMmM,SACpByG,EAAKnP,SAASzD,MAAMoM,SACpBxJ,EAAKa,SAASzD,MAAQpD,OAAOmP,OAAO,GAAI6G,EAAKnP,SAASzD,SAK5DmN,KAAK1E,KAAKyE,M,sBCzCZ,IAAI4F,EAAkB,EAAQ,OAE9BjX,EAAQ+U,OAAS,CAAC,CAChBmB,SAAS,EACT/V,UAAW,IACX4D,MAAO,UAET/D,EAAQoV,SAAW,CACjBxJ,SAGF,SAAkC7E,EAAME,EAAQ2I,GAC9C,IAAIvP,EAAQ4W,EAAgBlQ,EAAME,EAAQ2I,GACtCmH,EAAOhQ,EAAKP,SAAS,GAEG,kBAAjBO,EAAK0L,SAAyBsE,GAAsB,cAAdA,EAAKxQ,OACpDlG,EAAQA,EAAMQ,QAAQ,mCAKxB,SAAe0S,GACb,OAAOA,EAAK,KAAOxM,EAAK0L,QAAU,IAAM,KAAO,SAHjD,OAAOpS,K,sBCnBT,IAAI6W,EAAkB,EAAQ,OAE1BlC,EAAgB,EAAQ,OAExB3R,EAAQ,EAAQ,OAEhB8T,EAAe,EAAQ,OAEvBlH,EAAM,GAAGhP,eAkBb,SAASkI,EAAUF,EAAQE,GACzB,IAAItH,EACAmR,EACAoE,EAEJ,IAAKvV,KAAOsH,EACV6J,EAAO/C,EAAIvO,KAAKuH,EAAQpH,GAAOoH,EAAOpH,GAAOoH,EAAOpH,GAAO,GAC3DuV,EAAQjO,EAAUtH,GAEN,mBAARA,GAAoC,eAARA,EAC9BoH,EAAOpH,GAAO,GAAG2C,OAAOwO,EAAMoE,GAE9BrW,OAAOmP,OAAO8C,EAAMoE,GA7B1BrX,EAAOC,QAEP,SAAmBkJ,GACjB,IAAID,EAAS,CACXI,WAAY,GACZC,eAAgB,IAEd5I,EAASwI,EAAWxI,OACpBN,GAAS,EAEb,OAASA,EAAQM,GACfyI,EAAUF,EAAQC,EAAW9I,IAG/B,OAAO6I,EAdQG,CAAU,CAAC8N,EAAiBlC,EAAe3R,EAAO8T,K,sBCTnE,IAAID,EAAkB,EAAQ,OAE1BlC,EAAgB,EAAQ,OAExB3R,EAAQ,EAAQ,OAEhB8T,EAAe,EAAQ,OAEvB/N,EAAY,EAAQ,MAExBrJ,EAAOC,QAEP,SAAoBmC,GAClB,IAAI8G,EAASG,EAAU,CACrBgM,SAAU,GACVtP,KAAM,GACNiP,OAAQ,GACR5S,QAAS,IACR,CACD+G,WAAY,CAACgO,EAAiBlC,EAAe3R,EAAMlB,GAAUgV,KAE/D,OAAOpW,OAAOmP,OAAOjH,EAAO9G,QAAS,CACnCiT,SAAUnM,EAAOmM,SACjBtP,KAAMmD,EAAOnD,KACbiP,OAAQ9L,EAAO8L,W,iBCxBnBhV,EAAOC,QAEP,SAASoJ,EAAUiO,EAAMlO,GACvB,IACItH,EADAzB,GAAS,EAGb,GAAI+I,EAAUD,WACZ,OAAS9I,EAAQ+I,EAAUD,WAAWxI,QACpC0I,EAAUiO,EAAMlO,EAAUD,WAAW9I,IAIzC,IAAKyB,KAAOsH,EACE,eAARtH,IACe,WAARA,GAA4B,SAARA,EAC7BwV,EAAKxV,GAAOwV,EAAKxV,GAAK2C,OAAO2E,EAAUtH,IAAQ,IAC9B,aAARA,EACTwV,EAAKxV,GAAOd,OAAOmP,OAAOmH,EAAKxV,GAAMsH,EAAUtH,IAAQ,IAEvDwV,EAAKlV,QAAQN,GAAOsH,EAAUtH,IAIlC,OAAOwV,I,sBCvBTtX,EAAOC,QAAUyW,EACjBA,EAAWnB,KA0DX,WACE,MAAO,KAzDT,IAAIgC,EAAiB,EAAQ,OAE7B,SAASb,EAAW1P,EAAME,EAAQ2I,GAWhC,IAVA,IAGI2H,EACAC,EACA3P,EACAD,EANAvH,EAAQ0G,EAAK1G,OAAS,GACtBoX,EAAW,IACXrX,GAAS,EAQN,IAAI2I,OAAO,WAAa0O,EAAW,YAAY3D,KAAKzT,IACzDoX,GAAY,IAgBd,IAXI,WAAW3D,KAAKzT,KAAW,WAAWyT,KAAKzT,EAAMqX,OAAO,KAAO,WAAW5D,KAAKzT,EAAMqX,OAAOrX,EAAMK,OAAS,OAC7GL,EAAQ,IAAMA,EAAQ,OAUfD,EAAQwP,EAAQmF,OAAOrU,QAK9B,IAJA6W,EAAU3H,EAAQmF,OAAO3U,IAIZ8V,QAGb,IAFAsB,EAAaF,EAAeC,GAErB1P,EAAQ2P,EAAWlQ,KAAKjH,IAC7BuH,EAAWC,EAAMzH,MAEkB,KAA/BC,EAAM2F,WAAW4B,IAEiB,KAAnCvH,EAAM2F,WAAW4B,EAAW,IAG3BA,IAGJvH,EAAQA,EAAM8H,MAAM,EAAGP,GAAY,IAAMvH,EAAM8H,MAAMN,EAAMzH,MAAQ,GAIvE,OAAOqX,EAAWpX,EAAQoX,I,sBCxD5B1X,EAAOC,QAYP,SAAkB+G,EAAME,EAAQ2I,GAC9B,IAEIlM,EACArD,EACAuM,EAJA+K,EAASC,EAAYhI,GACrBiI,EAAiBC,EAAoBlI,GAKrC3I,GAAUA,EAAOP,UACnBiR,GAAU1Q,EAAO9C,OAAS,EAAI8C,EAAO9C,MAAQ,KAA8C,IAAxCyL,EAAQzN,QAAQ4V,oBAAgC,EAAI9Q,EAAOT,SAAS/F,QAAQsG,IAAS,KAG1IrD,EAAOiU,EAAOjX,OAAS,GAEA,QAAnBmX,GAA+C,UAAnBA,IAA+B5Q,GAAUA,EAAOuL,QAAUzL,EAAKyL,WAC7F9O,EAA6B,EAAtBgC,KAAKsS,KAAKtU,EAAO,IAM1B,OAHAkJ,EAAOgD,EAAQrG,MAAM,YACrBlJ,EAAQ4X,EAAYC,EAAKnR,EAAM6I,IAI/B,SAAa/L,EAAMzD,EAAO+X,GACxB,GAAI/X,EACF,OAAQ+X,EAAQ,GAAK/U,EAAO,IAAKM,IAASG,EAG5C,OAAQsU,EAAQR,EAASA,EAASvU,EAAO,IAAKM,EAAOiU,EAAOjX,SAAWmD,KARzE+I,IACOvM,GA9BT,IAAI+C,EAAS,EAAQ,OAEjBwU,EAAc,EAAQ,OAEtBE,EAAsB,EAAQ,OAE9BI,EAAO,EAAQ,OAEfD,EAAc,EAAQ,Q,kBCV1BlY,EAAOC,QAEP,SAAqB4P,GACnB,IAAIwI,EAASxI,EAAQzN,QAAQwV,QAAU,IAEvC,GAAe,MAAXS,GAA6B,MAAXA,GAA6B,MAAXA,EACtC,MAAM,IAAI5X,MAAM,gCAAkC4X,EAAS,qDAG7D,OAAOA,I,kBCTTrY,EAAOC,QAEP,SAA6B4P,GAC3B,IAAIyI,EAAQzI,EAAQzN,QAAQ0V,gBAAkB,MAE9C,GAAc,IAAVQ,GAAyB,MAAVA,EACjB,MAAO,MAGT,GAAc,QAAVA,GAA6B,QAAVA,GAA6B,UAAVA,EACxC,MAAM,IAAI7X,MAAM,gCAAkC6X,EAAQ,qEAG5D,OAAOA,I,sBCbTtY,EAAOC,QAIP,SAAciH,EAAQ2I,GACpB,IAGInJ,EAHAD,EAAWS,EAAOT,UAAY,GAC9B8R,EAAU,GACVlY,GAAS,EAGb,OAASA,EAAQoG,EAAS9F,QACxB+F,EAAQD,EAASpG,GACjBkY,EAAQhT,KAAKsK,EAAQ2I,OAAO9R,EAAOQ,EAAQ2I,EAAS,CAClD9L,OAAQ,KACRC,MAAO,QAGL3D,EAAQ,EAAIoG,EAAS9F,QACvB4X,EAAQhT,KAAKkT,EAAQ/R,EAAOD,EAASpG,EAAQ,KAIjD,OAAOkY,EAAQxS,KAAK,IAEpB,SAAS0S,EAAQxF,EAAMoE,GAIrB,IAHA,IACIpQ,EADA5G,GAAS,IAGJA,EAAQwP,EAAQ9J,KAAKpF,SAGb,KAFfsG,EAAS4I,EAAQ9J,KAAK1F,GAAO4S,EAAMoE,EAAOnQ,EAAQ2I,KAEhB,IAAX5I,GAHa,CAOpC,GAAsB,iBAAXA,EACT,OAAO5D,EAAO,KAAM,EAAIqV,OAAOzR,IAGjC,IAAe,IAAXA,EACF,MAAO,wBAIX,MAAO,SA1CX,IAAI5D,EAAS,EAAQ,Q,kBCFrBrD,EAAOC,QAEP,SAAkBiH,EAAQ2I,EAAS8I,GACjC,IAII3U,EACAwU,EACA9R,EANAD,EAAWS,EAAOT,UAAY,GAC9B8R,EAAU,GACVlY,GAAS,EACT0D,EAAS4U,EAAY5U,OAKzB,OAAS1D,EAAQoG,EAAS9F,QACxB+F,EAAQD,EAASpG,GAEbA,EAAQ,EAAIoG,EAAS9F,SACvB6X,EAAS3I,EAAQ2I,OAAOnD,SAAS5O,EAASpG,EAAQ,GAAGmG,QACvCgS,EAAOjD,OAAMiD,EAASA,EAAOjD,MAC3CvR,EAAQwU,EAASA,EAAO/R,EAASpG,EAAQ,GAAI6G,EAAQ2I,EAAS,CAC5D9L,OAAQ,GACRC,MAAO,KACN2T,OAAO,GAAK,IAEf3T,EAAQ2U,EAAY3U,MASlBuU,EAAQ5X,OAAS,IAAiB,OAAXoD,GAA8B,OAAXA,IAAmC,SAAf2C,EAAMF,OACtE+R,EAAQA,EAAQ5X,OAAS,GAAK4X,EAAQA,EAAQ5X,OAAS,GAAGG,QAAQ,cAAe,KACjFiD,EAAS,KAGXwU,EAAQhT,KAAKsK,EAAQ2I,OAAO9R,EAAOQ,EAAQ2I,EAAS,CAClD9L,OAAQA,EACRC,MAAOA,KAETD,EAASwU,EAAQA,EAAQ5X,OAAS,GAAGyH,OAAO,GAG9C,OAAOmQ,EAAQxS,KAAK,M,kBC3CtB/F,EAAOC,QAGP,SAAqBK,EAAOsY,GAC1B,IAGI9Q,EAHAb,EAAS,GACT7C,EAAQ,EACRN,EAAO,EAGX,KAAOgE,EAAQ+Q,EAAItR,KAAKjH,IACtByG,EAAIzG,EAAM8H,MAAMhE,EAAO0D,EAAMzH,QAC7B4G,EAAO1B,KAAKuC,EAAM,IAClB1D,EAAQ0D,EAAMzH,MAAQyH,EAAM,GAAGnH,OAC/BmD,IAIF,OADAiD,EAAIzG,EAAM8H,MAAMhE,IACT6C,EAAOlB,KAAK,IAEnB,SAASgB,EAAIzG,GACX2G,EAAO1B,KAAKqT,EAAItY,EAAOwD,GAAOxD,MAnBlC,IAAIuY,EAAM,a,kBCDV7Y,EAAOC,QAEP,SAAwBuX,GACtB,IAAIzT,EACAC,EAECwT,EAAQsB,YACX/U,EAASyT,EAAQzT,OAAS,MAAQyT,EAAQzT,OAAS,IAAM,GACzDC,EAAQwT,EAAQxT,MAAQ,MAAQwT,EAAQxT,MAAQ,IAAM,GAElDwT,EAAQrB,UACVpS,EAAS,kBAAoBA,GAG/ByT,EAAQsB,UAAY,IAAI9P,QAAQjF,EAAS,IAAMA,EAAS,IAAM,KAAO,sBAAsBgQ,KAAKyD,EAAQpX,WAAa,KAAO,IAAMoX,EAAQpX,WAAa4D,GAAS,IAAK,MAGvK,OAAOwT,EAAQsB,Y,+BCXjB,SAAS1X,EAAS4F,GAChB,OAAOA,IAASA,EAAK1G,OAAS0G,EAAKsL,KAAOtL,EAAK+K,OAAS,aAAc/K,GAAQI,EAAIJ,EAAKP,WAAa,WAAYO,GAAQI,EAAIJ,KAAU,GAGxI,SAASI,EAAI2R,GAIX,IAHA,IAAI9R,EAAS,GACT5G,GAAS,IAEJA,EAAQ0Y,EAAOpY,QACtBsG,EAAO5G,GAASe,EAAS2X,EAAO1Y,IAGlC,OAAO4G,EAAOlB,KAAK,IAhBrB/F,EAAOC,QAAUmB,G,sBCFjBpB,EAAOC,QAAU,EAAjB,Q,sBCAA,IAAI+Y,EAAa,EAAQ,MAErBC,EAAoB,EAAQ,OAE5BC,EAAe,EAAQ,OAEvBC,EAAqB,EAAQ,OAE7B/F,EAAqB,EAAQ,OAE7BC,EAAoB,EAAQ,OAE5B+F,EAAM,CACRC,SAwQF,SAAqBC,EAASC,EAAIC,GAChC,OAEA,SAAevV,GAGb,OADAqV,EAAQG,QAAQxV,GACTyV,GAGT,SAASA,EAAGzV,GAEV,OAAa,KAATA,GAAeA,EAAO,IAAO,IAC/BqV,EAAQG,QAAQxV,GACT0V,GAGFH,EAAIvV,GAGb,SAAS0V,EAAG1V,GAEV,OAAa,KAATA,GAAeA,EAAO,IAAO,IAC/BqV,EAAQG,QAAQxV,GACT2V,GAGFJ,EAAIvV,GAGb,SAAS2V,EAAI3V,GAEX,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTD,GAGFwV,EAAIvV,GAGb,SAASD,EAAMC,GACb,OAAgB,OAATA,GAAiBkV,EAAmBlV,GAAQuV,EAAIvV,GAAQsV,EAAGtV,KA/SpE4V,SAAS,GAEPnG,EAAS,CACX2F,SAgTF,SAAwBC,EAASC,EAAIC,GACnC,IAAIM,EACAC,EACJ,OAAOrG,EAEP,SAASA,EAAOzP,GAEd,OAAa,KAATA,EACKqV,EAAQU,MAAMC,EAAyBC,EAAMC,EAA7Cb,CAAsErV,GAGlE,KAATA,GAEQ,KAATA,EAGQqV,EAAQU,MAAMI,EAAaF,EAAMC,EAAjCb,CAA0DrV,GAQjEiV,EAAajV,IAASoP,EAAkBpP,IAAkB,KAATA,GAElDmP,EAAmBnP,GACbiW,EAAKjW,IAGdqV,EAAQG,QAAQxV,GACTyP,GAGT,SAASyG,EAAwBlW,GAE/B,OAAa,KAATA,GACF8V,EAAiCD,EACjCA,OAA6BxU,EAC7BgU,EAAQG,QAAQxV,GACTyP,IAII,KAATzP,IAAa6V,GAA6B,GAC9CR,EAAQG,QAAQxV,GACTyP,GAGT,SAASwG,EAAKjW,GACZ,OAAK8V,GAAmCD,EAIjCN,EAAIvV,GAHFsV,EAAGtV,KAlWd4V,SAAS,GAEPlG,EAAO,CACT0F,SAsWF,SAAsBC,EAASC,GAC7B,IAAIc,EAAU,EACd,OAAOC,EAEP,SAASA,EAAOrW,GAEd,OAAa,KAATA,EACKqV,EAAQU,MAAMC,EAAyBV,EAAIgB,EAA3CjB,CAAiErV,IAI7D,KAATA,GACFoW,IAIW,KAATpW,EACKqV,EAAQU,MAAMI,EAAaI,EAAgBD,EAA3CjB,CAAiErV,GAGtEwW,EAAQxW,GACHsV,EAAGtV,GAGRyW,EAAoBzW,GACfqV,EAAQU,MAAMI,EAAab,EAAIgB,EAA/BjB,CAAqDrV,IAG9DqV,EAAQG,QAAQxV,GACTqW,IAGT,SAASC,EAAqBtW,GAE5B,OADAqV,EAAQG,QAAQxV,GACTqW,EAGT,SAASE,EAAevW,GAEtB,QADAoW,EACiB,EAAId,EAAGtV,GAAQsW,EAAqBtW,KA5YvD4V,SAAS,GAEPO,EAAc,CAChBf,SA4aF,SAA6BC,EAASC,EAAIC,GACxC,OAEA,SAAevV,GAGb,OADAqV,EAAQG,QAAQxV,GACTD,GAGT,SAASA,EAAMC,GAEb,OAAIyW,EAAoBzW,IACtBqV,EAAQG,QAAQxV,GACTD,GAKFyW,EAAQxW,GAAQsV,EAAGtV,GAAQuV,EAAIvV,KA7bxC4V,SAAS,GAEPI,EAA0B,CAC5BZ,SAyYF,SAAyCC,EAASC,EAAIC,GACpD,OAEA,SAAevV,GAGb,OADAqV,EAAQG,QAAQxV,GACT0W,GAGT,SAASA,EAAO1W,GACd,OAAI+U,EAAW/U,IACbqV,EAAQG,QAAQxV,GACT0W,GAII,KAAT1W,GACFqV,EAAQG,QAAQxV,GACTD,GAGFwV,EAAIvV,GAGb,SAASD,EAAMC,GAGb,OAAOwW,EAAQxW,GAAQsV,EAAGtV,GAAQuV,EAAIvV,KAnaxC4V,SAAS,GAEPe,EAAc,CAChBvB,SA0HF,SAA6BC,EAASC,EAAIC,GACxC,IAAIqB,EAAOtJ,KACX,OAEA,SAAetN,GAEb,GAAa,KAATA,GAAeA,EAAO,IAAO,KAAO6W,EAAYD,EAAK/G,WAAaA,EAAS+G,EAAKnL,QAClF,OAAO8J,EAAIvV,GAQb,OALAqV,EAAQ9P,MAAM,mBACd8P,EAAQ9P,MAAM,sBAIP8P,EAAQU,MAAMZ,EAAKE,EAAQyB,QAAQrH,EAAQ4F,EAAQyB,QAAQpH,EAAMuG,GAAOV,GAAMA,EAA9EF,CAAmFrV,IAG5F,SAASiW,EAAKjW,GAGZ,OAFAqV,EAAQzM,KAAK,sBACbyM,EAAQzM,KAAK,mBACN0M,EAAGtV,KA9IZ6P,SAAUgH,GAERE,EAAe,CACjB3B,SA+IF,SAA8BC,EAASC,EAAIC,GACzC,IAAIqB,EAAOtJ,KACX,OAEA,SAAetN,GAEb,GAAa,KAATA,GAAeA,EAAO,IAAO,KAAOgX,EAAaJ,EAAK/G,WAAaA,EAAS+G,EAAKnL,QACnF,OAAO8J,EAAIvV,GAMb,OAHAqV,EAAQ9P,MAAM,mBACd8P,EAAQ9P,MAAM,uBACd8P,EAAQG,QAAQxV,GACTiX,GAGT,SAASA,EAAGjX,GAEV,OAAa,KAATA,GAAeA,EAAO,IAAO,IAC/BqV,EAAQG,QAAQxV,GACTkX,GAGF3B,EAAIvV,GAGb,SAASkX,EAAGlX,GAEV,OAAa,KAATA,GAAeA,EAAO,IAAO,IAC/BqV,EAAQG,QAAQxV,GACTmX,GAGF5B,EAAIvV,GAGb,SAASmX,EAAEnX,GAET,OAAa,KAATA,GAAeA,EAAO,IAAO,IAC/BqV,EAAQG,QAAQxV,GACToX,GAGF7B,EAAIvV,GAGb,SAASoX,EAAEpX,GAET,OAAa,KAATA,GAAeA,EAAO,IAAO,IAC/BqV,EAAQG,QAAQxV,GACTwB,GAGFA,EAAMxB,GAGf,SAASwB,EAAMxB,GAEb,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTqX,GAGF9B,EAAIvV,GAGb,SAASqX,EAAOrX,GAEd,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTsX,GAGF/B,EAAIvV,GAGb,SAASsX,EAAOtX,GAEd,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTD,GAGFwV,EAAIvV,GAGb,SAASD,EAAMC,GACb,OAAOiV,EAAajV,IAASoP,EAAkBpP,IAASmP,EAAmBnP,GAAQuV,EAAIvV,GAAQqV,EAAQyB,QAAQrH,EAAQ4F,EAAQyB,QAAQpH,EAAMuG,GAAOV,EAArDF,CAA0DrV,GAG3J,SAASiW,EAAKjW,GAGZ,OAFAqV,EAAQzM,KAAK,uBACbyM,EAAQzM,KAAK,mBACN0M,EAAGtV,KA3OZ6P,SAAUmH,GAERO,EAAgB,CAClBnC,SAgCF,SAA+BC,EAASC,EAAIC,GAC1C,IACIiC,EADAZ,EAAOtJ,KAEX,OAEA,SAAetN,GAEb,IAAKyX,EAASzX,KAAU0X,EAAcd,EAAK/G,WAAaA,EAAS+G,EAAKnL,QACpE,OAAO8J,EAAIvV,GAKb,OAFAqV,EAAQ9P,MAAM,mBACd8P,EAAQ9P,MAAM,wBACPgL,EAAMvQ,IAGf,SAASuQ,EAAMvQ,GACb,OAAIyX,EAASzX,IACXqV,EAAQG,QAAQxV,GACTuQ,GAII,KAATvQ,GACFqV,EAAQG,QAAQxV,GACT2H,GAGF4N,EAAIvV,GAGb,SAAS2H,EAAM3H,GAEb,OAAa,KAATA,EACKqV,EAAQU,MAAMI,EAAaF,EAAM0B,EAAjCtC,CAAkDrV,GAIlD,KAATA,GACS,KAATA,EACSqV,EAAQU,MAAMI,EAAaZ,EAAKqC,EAAhCvC,CAA8DrV,GAGnEgV,EAAkBhV,IACpBqV,EAAQG,QAAQxV,GACT2H,GAGFsO,EAAKjW,GAGd,SAAS2X,EAAgB3X,GAGvB,OAFAqV,EAAQG,QAAQxV,GAChBwX,GAAS,EACF7P,EAGT,SAASiQ,EAA6B5X,GAEpC,OADAqV,EAAQG,QAAQxV,GACT6X,EAGT,SAASA,EAAsB7X,GAE7B,OAAa,KAATA,EACKqV,EAAQU,MAAMI,EAAaZ,EAAKoC,EAAhCtC,CAAiDrV,GAGnD2H,EAAM3H,GAGf,SAASiW,EAAKjW,GACZ,OAAIwX,GACFnC,EAAQzM,KAAK,wBACbyM,EAAQzM,KAAK,mBACN0M,EAAGtV,IAGLuV,EAAIvV,KA7Gb6P,SAAU6H,GAERxJ,EAAO,GAEXlS,EAAQkS,KAAOA,EAIf,IAFA,IAAIlO,EAAO,GAEJA,EAAO,KACZkO,EAAKlO,GAAQuX,EAGA,OAFbvX,EAEiBA,EAAO,GACN,KAATA,IAAaA,EAAO,IAoa/B,SAASyW,EAAoBzW,GAC3B,OACW,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,MAATA,EAIJ,SAASwW,EAAQxW,GACf,OACW,OAATA,GACAA,EAAO,GACE,KAATA,GACS,KAATA,EAIJ,SAASyX,EAASzX,GAChB,OAAgB,KAATA,GAEK,KAATA,GAES,KAATA,GAES,KAATA,GAEAgV,EAAkBhV,GAGvB,SAAS6W,EAAY7W,GACnB,OAAgB,OAATA,GAAiBA,EAAO,GAAc,KAATA,GAExB,KAATA,GAES,KAATA,GAES,KAATA,GAES,MAATA,EAKL,SAASgX,EAAahX,GACpB,OAAgB,OAATA,IAAkB+U,EAAW/U,GAGtC,SAAS0X,EAAc1X,GACrB,OAAgB,KAATA,GAEJgX,EAAahX,GAGlB,SAAS6P,EAASpE,GAGhB,IAFA,IAAIrP,EAAQqP,EAAO/O,OAEZN,KACL,IAA+B,cAA1BqP,EAAOrP,GAAO,GAAGmG,MAAkD,eAA1BkJ,EAAOrP,GAAO,GAAGmG,QAA2BkJ,EAAOrP,GAAO,GAAG0b,UACzG,OAAO,EApeb5J,EAAK,IAAMqJ,EAEXrJ,EAAK,IAAMqJ,EAEXrJ,EAAK,IAAMqJ,EAEXrJ,EAAK,IAAMqJ,EAEXrJ,EAAK,IAAM,CAACqJ,EAAeR,GAC3B7I,EAAK,KAAO,CAACqJ,EAAeR,GAE5B7I,EAAK,IAAM,CAACqJ,EAAeZ,GAC3BzI,EAAK,KAAO,CAACqJ,EAAeZ,I,sBCvE5B5a,EAAOC,QAUP,SAAgBmC,GACd,IACI4Z,GADW5Z,GAAW,IACJ6Z,YAClBC,EAAY,CACd7C,SA2EF,SAA+BC,EAASC,EAAIC,GAC1C,IAAI1F,EAAWvC,KAAKuC,SAChBpE,EAAS6B,KAAK7B,OACd/L,EAAO,EACX,OAAOS,EAEP,SAASA,EAAMH,GACb,OAAa,MAATA,GAA6B,MAAb6P,GAA0D,oBAAtCpE,EAAOA,EAAO/O,OAAS,GAAG,GAAG6F,KAC5DgT,EAAIvV,IAGbqV,EAAQ9P,MAAM,kCACP2S,EAAKlY,IAGd,SAASkY,EAAKlY,GACZ,IACIqN,EACAtN,EAFAD,EAASqY,EAAkBtI,GAI/B,OAAa,MAAT7P,EAEEN,EAAO,EAAU6V,EAAIvV,IACzBqV,EAAQG,QAAQxV,GAChBN,IACOwY,GAGLxY,EAAO,IAAMqY,EAAexC,EAAIvV,IACpCqN,EAAQgI,EAAQzM,KAAK,kCACrB7I,EAAQoY,EAAkBnY,GAC1BqN,EAAM+K,OAASrY,GAAmB,IAAVA,GAAeD,EACvCuN,EAAMgL,QAAUvY,GAAqB,IAAXA,GAAgBC,EACnCuV,EAAGtV,MA3GZsY,WAgBF,SAAiC7M,EAAQG,GACvC,IACIoF,EACA9C,EACAd,EACAmL,EAJAnc,GAAS,EAMb,OAASA,EAAQqP,EAAO/O,QAEtB,GAAyB,UAArB+O,EAAOrP,GAAO,IAA4C,mCAA1BqP,EAAOrP,GAAO,GAAGmG,MAA6CkJ,EAAOrP,GAAO,GAAGic,OAGjH,IAFAjL,EAAOhR,EAEAgR,KAEL,GAAwB,SAApB3B,EAAO2B,GAAM,IAA0C,mCAAzB3B,EAAO2B,GAAM,GAAG7K,MAA6CkJ,EAAO2B,GAAM,GAAGgL,OAC/G3M,EAAOrP,GAAO,GAAGiE,IAAIkM,OAASd,EAAOrP,GAAO,GAAG+D,MAAMoM,QAAWd,EAAO2B,GAAM,GAAG/M,IAAIkM,OAASd,EAAO2B,GAAM,GAAGjN,MAAMoM,OAAQ,CACzHd,EAAOrP,GAAO,GAAGmG,KAAO,wBACxBkJ,EAAO2B,GAAM,GAAG7K,KAAO,wBACvByO,EAAgB,CACdzO,KAAM,gBACNpC,MAAOqY,EAAQ/M,EAAO2B,GAAM,GAAGjN,OAC/BE,IAAKmY,EAAQ/M,EAAOrP,GAAO,GAAGiE,MAEhC6N,EAAO,CACL3L,KAAM,oBACNpC,MAAOqY,EAAQ/M,EAAO2B,GAAM,GAAG/M,KAC/BA,IAAKmY,EAAQ/M,EAAOrP,GAAO,GAAG+D,QAGhCoY,EAAa,CAAC,CAAC,QAASvH,EAAepF,GAAU,CAAC,QAASH,EAAO2B,GAAM,GAAIxB,GAAU,CAAC,OAAQH,EAAO2B,GAAM,GAAIxB,GAAU,CAAC,QAASsC,EAAMtC,IAE1I6M,EAAcF,EAAYA,EAAW7b,OAAQ,EAAG4b,EAAW1M,EAAQgD,OAAO8J,WAAWC,WAAWC,KAAMnN,EAAOtH,MAAMiJ,EAAO,EAAGhR,GAAQwP,IAErI6M,EAAcF,EAAYA,EAAW7b,OAAQ,EAAG,CAAC,CAAC,OAAQwR,EAAMtC,GAAU,CAAC,QAASH,EAAOrP,GAAO,GAAIwP,GAAU,CAAC,OAAQH,EAAOrP,GAAO,GAAIwP,GAAU,CAAC,OAAQoF,EAAepF,KAC7K6M,EAAchN,EAAQ2B,EAAO,EAAGhR,EAAQgR,EAAO,EAAGmL,GAClDnc,EAAQgR,EAAOmL,EAAW7b,OAAS,EACnC,MAMR,OAGF,SAAkC+O,GAChC,IAAIrP,GAAS,EACTM,EAAS+O,EAAO/O,OAEpB,OAASN,EAAQM,GACe,mCAA1B+O,EAAOrP,GAAO,GAAGmG,OACnBkJ,EAAOrP,GAAO,GAAGmG,KAAO,QAI5B,OAAOkJ,EAbAoN,CAAyBpN,KAvD9BsM,UACFA,GAAS,GAGX,MAAO,CACL7J,KAAM,CACJ,IAAK+J,GAEPU,WAAY,CACVC,KAAMX,KAzBZ,IAAIE,EAAoB,EAAQ,OAE5BM,EAAgB,EAAQ,MAExBH,EAAa,EAAQ,OAErBE,EAAU,EAAQ,Q,sBCRtBzc,EAAOC,QAAU,EAAjB,Q,sBCAAA,EAAQkY,KAAO,CACb0E,KAAM,CACJxD,SAkGJ,SAAuBC,EAASC,EAAIC,GAClC,IAEIuD,EACAC,EAHAxY,EAAQ,GACRyY,EAAmB,EAGvB,OAEA,SAAehZ,GAEb,GAAa,OAATA,IAA2B,IAAVA,IAAyB,IAAVA,IAAyB,IAAVA,EACjD,OAAOuV,EAAIvV,GAOb,GAJAqV,EAAQ9P,MAAM,SAASkM,OAASlR,EAChC8U,EAAQ9P,MAAM,aACd8P,EAAQ9P,MAAM,YAED,MAATvF,EACF,OAAOiZ,EAAgBjZ,GAMzB,OAHAgZ,IACA3D,EAAQ9P,MAAM,6BAEP2T,EAAkBlZ,IAG3B,SAASiZ,EAAgBjZ,GAMvB,OAJAqV,EAAQ9P,MAAM,oBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,oBACbkQ,GAAgB,EACTK,EAGT,SAASA,EAAcnZ,GAErB,OAAa,OAATA,IAA2B,IAAVA,IAAyB,IAAVA,IAAyB,IAAVA,EA4DrD,SAAsBA,GACpB,GAAa,OAATA,EACF,OAAOuV,EAAIvV,GAUb,OAPAqV,EAAQzM,KAAK,YACbyM,EAAQzM,KAAK,aAEbyM,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cAENyM,EAAQU,MAAMqD,EAAqB7D,EAC1C8D,EAAYhE,EAASiE,EAAmB,aAAc,IAxE7CC,CAAavZ,IAIR,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,GAChCqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GACTwZ,IAGLV,IACFA,OAAgBzX,EAChB2X,KAIW,MAAThZ,EACKiZ,EAAgBjZ,IAIzBqV,EAAQ9P,MAAM,6BACP2T,EAAkBlZ,KAG3B,SAASwZ,EAAiBxZ,GAExB,OAAc,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,GAChCqV,EAAQG,QAAQxV,GACTwZ,IAGTnE,EAAQzM,KAAK,cACNuQ,EAAcnZ,IAGvB,SAASkZ,EAAkBlZ,GAEzB,OAAa,OAATA,GAAiBA,EAAO,GAAc,KAATA,GAAwB,MAATA,GAC9CqV,EAAQzM,KAAK,6BACNuQ,EAAcnZ,KAGvBqV,EAAQG,QAAQxV,GAEA,KAATA,EAAcyZ,EAA0BP,GAGjD,SAASO,EAAwBzZ,GAE/B,OAAa,KAATA,GAAwB,MAATA,GACjBqV,EAAQG,QAAQxV,GACTkZ,GAIFA,EAAkBlZ,GAmB3B,SAASsZ,EAAkBtZ,GAEzB,OAAa,OAATA,GAAiBA,EAAO,GAAc,KAATA,EACxBuV,EAAIvV,IAGbqV,EAAQ9P,MAAM,qBACPmU,EAAoB1Z,IAG7B,SAAS0Z,EAAoB1Z,GAE3B,OAAa,OAATA,IAA2B,IAAVA,IAAyB,IAAVA,IAAyB,IAAVA,EAC1C2Z,EAAgB3Z,IAIX,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,GAChCqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GACT4Z,GAII,KAAT5Z,GACFqV,EAAQ9P,MAAM,wBACd8P,EAAQG,QAAQxV,GAChB+Y,GAAU,EACVxY,EAAMe,KAAK,MACJuY,GAII,KAAT7Z,GACFqV,EAAQ9P,MAAM,2BACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,2BACbrI,EAAMe,KAAK,QACJwY,GAII,MAAT9Z,GACFqV,EAAQ9P,MAAM,oBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,oBACN8Q,GAGFnE,EAAIvV,GAGb,SAAS4Z,EAAsB5Z,GAE7B,OAAc,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,GAChCqV,EAAQG,QAAQxV,GACT4Z,IAGTvE,EAAQzM,KAAK,cACN8Q,EAAoB1Z,IAG7B,SAAS6Z,EAAkB7Z,GAEzB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACT6Z,IAGTxE,EAAQzM,KAAK,wBAEA,KAAT5I,GACFqV,EAAQ9P,MAAM,2BACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,2BACbrI,EAAMA,EAAM7D,OAAS,GAAiC,SAA5B6D,EAAMA,EAAM7D,OAAS,GAAgB,SAAW,QACnEqd,GAGFL,EAAoB1Z,IAG7B,SAAS8Z,EAAmB9Z,GAE1B,OAAa,KAATA,GACFqV,EAAQ9P,MAAM,wBACd8P,EAAQG,QAAQxV,GAChB+Y,GAAU,EACHc,GAIFtE,EAAIvV,GAGb,SAAS+Z,EAAoB/Z,GAE3B,OAAa,OAATA,IAA2B,IAAVA,IAAyB,IAAVA,IAAyB,IAAVA,EAC1C2Z,EAAgB3Z,IAIX,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,GAChCqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GACT4Z,GAII,MAAT5Z,GACFqV,EAAQ9P,MAAM,oBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,oBACN8Q,GAGFnE,EAAIvV,GAGb,SAAS2Z,EAAgB3Z,GAIvB,OAHAqV,EAAQzM,KAAK,qBAGRmQ,GAAWC,IAAqBzY,EAAM7D,OAI9B,OAATsD,EACKga,EAAWha,GAGbqV,EAAQU,MAAMkE,EAAqBD,EAAYE,EAA/C7E,CAA8DrV,GAP5DuV,EAAIvV,GAUf,SAASga,EAAWha,GAElB,OADAqV,EAAQzM,KAAK,SACN0M,EAAGtV,GAGZ,SAASka,EAAcla,GAOrB,OALAqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cAGNyQ,EAAYhE,EAAS8E,EAAW,aAAc,GAGvD,SAASA,EAAUna,GAEjB,OADAqV,EAAQ9P,MAAM,aACP6U,EAAapa,GAGtB,SAASoa,EAAapa,GAGpB,OAFAqV,EAAQ9P,MAAM,YAED,MAATvF,EACKqa,EAAgBra,IAGzBqV,EAAQ9P,MAAM,6BAEP+U,EAAkBta,IAG3B,SAASqa,EAAgBra,GAKvB,OAHAqV,EAAQ9P,MAAM,oBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,oBACN2R,EAGT,SAASA,EAAcva,GAErB,OAAa,OAATA,IAA2B,IAAVA,IAAyB,IAAVA,IAAyB,IAAVA,EAuDrD,SAAsBA,GAGpB,GAFAqV,EAAQzM,KAAK,YAEA,OAAT5I,EACF,OAAOwa,EAAexa,GAGxB,OAAOqV,EAAQU,MAAMkE,EAAqBO,EAAgBC,EAAnDpF,CAAsErV,GA7DpE0a,CAAa1a,IAIR,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,GAChCqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GACT2a,GAII,MAAT3a,EACKqa,EAAgBra,IAIzBqV,EAAQ9P,MAAM,6BACP+U,EAAkBta,IAG3B,SAAS2a,EAAiB3a,GAExB,OAAc,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,GAChCqV,EAAQG,QAAQxV,GACT2a,IAGTtF,EAAQzM,KAAK,cACN2R,EAAcva,IAGvB,SAASsa,EAAkBta,GAEzB,OAAa,OAATA,GAAiBA,EAAO,GAAc,KAATA,GAAwB,MAATA,GAC9CqV,EAAQzM,KAAK,6BACN2R,EAAcva,KAGvBqV,EAAQG,QAAQxV,GAEA,KAATA,EAAc4a,EAA0BN,GAGjD,SAASM,EAAwB5a,GAE/B,OAAa,KAATA,GAAwB,MAATA,GACjBqV,EAAQG,QAAQxV,GACTsa,GAIFA,EAAkBta,GAa3B,SAASwa,EAAexa,GAEtB,OADAqV,EAAQzM,KAAK,aACNoR,EAAWha,GAGpB,SAASya,EAAkBza,GAMzB,OAJAqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cAENyQ,EAAYhE,EAAS+E,EAAc,aAAc,KAhdxDS,QAgBJ,SAAsBpP,EAAQG,GAC5B,IAEIyB,EACAyN,EACAC,EACAC,EACArb,EACAsb,EACA/M,EACAgN,EACAC,EACAC,EAXA1e,EAAS+O,EAAO/O,OAChBN,GAAS,EAYb,OAASA,EAAQM,GACf2Q,EAAQ5B,EAAOrP,GAAO,GAElB4e,IACiB,8BAAf3N,EAAM9K,OACR2Y,EAAeA,GAAgB9e,EAC/B+e,EAAa/e,GAIC,qBAAfiR,EAAM9K,MAA8C,aAAf8K,EAAM9K,OAAwB4Y,IAClEF,EAAU,CACR1Y,KAAM,eACNpC,MAAOsL,EAAOyP,GAAc,GAAG/a,MAC/BE,IAAKoL,EAAO0P,GAAY,GAAG9a,KAE7B6N,EAAO,CACL3L,KAAM,YACNpC,MAAO8a,EAAQ9a,MACfE,IAAK4a,EAAQ5a,IACbgb,YAAa,QAEf5P,EAAO7J,OAAOsZ,EAAcC,EAAaD,EAAe,EAAG,CAAC,QAASD,EAASrP,GAAU,CAAC,QAASsC,EAAMtC,GAAU,CAAC,OAAQsC,EAAMtC,GAAU,CAAC,OAAQqP,EAASrP,IAC7JxP,GAAS+e,EAAaD,EAAe,EACrCxe,EAAS+O,EAAO/O,OAChBwe,OAAe7Z,EACf8Z,OAAa9Z,IAIQ,SAArBoK,EAAOrP,GAAO,IAAiBgf,GAAaA,EAAY,EAAIhf,IAAyB,qBAAfiR,EAAM9K,MAA8C,aAAf8K,EAAM9K,OAAwB6Y,EAAY,EAAIhf,GAAuC,eAA9BqP,EAAO2P,GAAW,GAAG7Y,SACzL5C,EAAO,CACL4C,KAAMwY,EAAiB,iBAAmBD,EAAS,cAAgB,YACnE3a,MAAOsL,EAAO2P,GAAW,GAAGjb,MAC5BE,IAAKoL,EAAOrP,GAAO,GAAGiE,KAExBoL,EAAO7J,OAAOxF,GAAwB,qBAAfiR,EAAM9K,KAA8B,EAAI,GAAI,EAAG,CAAC,OAAQ5C,EAAMiM,IACrFH,EAAO7J,OAAOwZ,EAAW,EAAG,CAAC,QAASzb,EAAMiM,IAC5CxP,GAAS,EACTM,EAAS+O,EAAO/O,OAChB0e,EAAYhf,EAAQ,GAGH,aAAfiR,EAAM9K,OACRyY,EAA6B,UAArBvP,EAAOrP,GAAO,MAGpBgf,EAAYhf,EAAQ,GAIL,sBAAfiR,EAAM9K,OACRwY,EAAsC,UAArBtP,EAAOrP,GAAO,MAG7Bgf,EAAYhf,EAAQ,GAIL,cAAfiR,EAAM9K,OACRuY,EAA8B,UAArBrP,EAAOrP,GAAO,IAI3B,OAAOqP,GA7FL6P,eAAe,IAInB,IAAIjC,EAAc,EAAQ,OAEtBD,EAAsB,CACxBhE,SA+cF,SAAqCC,EAASC,EAAIC,GAChD,OAEA,SAAevV,GAEb,GAAa,KAATA,EACF,OAAOuV,EAAIvV,GAIb,OADAqV,EAAQ9P,MAAM,mBACPkO,EAASzT,IAGlB,SAASyT,EAASzT,GAChB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTyT,GAGF8H,EAAWvb,GAGpB,SAASub,EAAWvb,GAClB,OAAc,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,GAChCqV,EAAQG,QAAQxV,GACTub,GAGI,OAATvb,IAA2B,IAAVA,IAAyB,IAAVA,IAAyB,IAAVA,EAC1CsV,EAAGtV,GAGLuV,EAAIvV,KA9eb4V,SAAS,GAEPqE,EAAsB,CACxB7E,SA+eF,SAAqCC,EAASC,EAAIC,GAChD,IAAI7V,EAAO,EACX,OAEA,SAAeM,GAMb,OAHAqV,EAAQ9P,MAAM,SAEd8P,EAAQG,QAAQxV,GACTub,GAGT,SAASA,EAAWvb,GAElB,OAAc,IAAVA,GAAwB,KAATA,GACjBqV,EAAQG,QAAQxV,GAEA,MADhBN,EACoB4V,EAAKiG,GAId,OAATvb,GAAiBA,EAAO,EACnBsV,EAAGtV,GAILuV,EAAIvV,KAzgBb4V,SAAS,I,sBChBX7Z,EAAOC,QAAU,EAAjB,Q,sBCAA,IAAIwf,EAA4B,EAAQ,OAEpCC,EAAe,EAAQ,OAEvBC,EAAa,EAAQ,MAErBC,EAAgB,CAClBvG,SAMF,SAA+BC,EAASC,EAAIC,GAC1C,IAAIqB,EAAOtJ,KACX,OAEA,SAActN,GACZ,GACS,KAATA,GACkB,OAAlB4W,EAAK/G,WAEJ+G,EAAKgF,mCACJ,OAAOrG,EAAIvV,GAOb,OAJAqV,EAAQ9P,MAAM,iBACd8P,EAAQ9P,MAAM,uBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,uBACN8N,GAGT,SAASA,EAAO1W,GAEd,OAAc,IAAVA,GAAwB,KAATA,GACjBqV,EAAQ9P,MAAM,+BACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,+BACN2E,GAII,KAATvN,GAAwB,MAATA,GACjBqV,EAAQ9P,MAAM,6BACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,6BACN2E,GAGFgI,EAAIvV,GAGb,SAASuN,EAAMvN,GAEb,OAAa,KAATA,GACFqV,EAAQ9P,MAAM,uBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,uBACbyM,EAAQzM,KAAK,iBACNyM,EAAQU,MAAM,CACnBX,SAAUyG,GACTvG,EAAIC,IAGFA,EAAIvV,MAIf,SAAS6b,EAAkBxG,EAASC,EAAIC,GACtC,IAAIqB,EAAOtJ,KACX,OAAOmO,EAAapG,GAEpB,SAAerV,GACb,OAAO0b,EAAW9E,EAAKnL,OAAQ,eAA0B,OAATzL,IAAkBwb,EAA0Bxb,GAAQsV,EAAGtV,GAAQuV,EAAIvV,KAHjF,cA9DtChE,EAAQkS,KAAO,CACb,GAAIyN,I,sBCVN5f,EAAOC,QAAU,EAAjB,Q,sBCAA,IAAI8f,EAAU,EAAQ,MAElBtW,EAAW,EAAQ,OAEnBwL,EAAgB,EAAQ,OAExB3R,EAAQ,EAAQ,OAEhB0c,EAAW,EAAQ,OAEvBhgB,EAAOC,QAEP,SAAgBmC,GACd,OAAO2d,EAAQ,CAACtW,EAAUwL,EAAc7S,GAAUkB,EAAO0c,M,kCCX3D,IAEIhH,EAFa,EAAQ,KAERiH,CAAW,YAC5BjgB,EAAOC,QAAU+Y,G,mCCHjB,IAEIC,EAFa,EAAQ,KAEDgH,CAAW,cACnCjgB,EAAOC,QAAUgZ,G,mCCHjB,IAEIiH,EAFa,EAAQ,KAERD,CAAW,uBAC5BjgB,EAAOC,QAAUigB,G,+BCIjBlgB,EAAOC,QAPP,SAAsBgE,GACpB,OAEEA,EAAO,IAAe,MAATA,I,mCCHjB,IAEIkc,EAFa,EAAQ,KAERF,CAAW,MAC5BjgB,EAAOC,QAAUkgB,G,mCCHjB,IAEIC,EAFa,EAAQ,KAELH,CAAW,cAC/BjgB,EAAOC,QAAUmgB,G,mCCHjB,IAEIC,EAFa,EAAQ,KAEFJ,CAAW,kBAClCjgB,EAAOC,QAAUogB,G,+BCCjBrgB,EAAOC,QAJP,SAAmCgE,GACjC,OAAOA,EAAO,GAAc,KAATA,I,+BCGrBjE,EAAOC,QAJP,SAA4BgE,GAC1B,OAAOA,GAAQ,I,+BCGjBjE,EAAOC,QAJP,SAAuBgE,GACrB,OAAiB,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,I,mCCDvC,IAAIqc,EAA0B,EAAQ,OAKlClN,EAHa,EAAQ,KAGA6M,CAAWK,GACpCtgB,EAAOC,QAAUmT,G,mCCNjB,IAEIC,EAFa,EAAQ,KAED4M,CAAW,MACnCjgB,EAAOC,QAAUoT,G,8BCHjB,IAAIlD,EAASnP,OAAOmP,OACpBnQ,EAAOC,QAAUkQ,G,+BCDjB,IAAIoQ,EAAehgB,OAAOggB,aAC1BvgB,EAAOC,QAAUsgB,G,+BCDjB,IAAIrQ,EAAM,GAAGhP,eACblB,EAAOC,QAAUiQ,G,+BCAjBlQ,EAAOC,QADM,CAAC,UAAW,UAAW,QAAS,OAAQ,WAAY,aAAc,OAAQ,UAAW,SAAU,MAAO,WAAY,KAAM,UAAW,SAAU,MAAO,MAAO,KAAM,KAAM,WAAY,aAAc,SAAU,SAAU,OAAQ,QAAS,WAAY,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,OAAQ,SAAU,KAAM,OAAQ,SAAU,SAAU,KAAM,OAAQ,OAAQ,OAAQ,WAAY,MAAO,WAAY,KAAM,WAAY,SAAU,IAAK,QAAS,UAAW,SAAU,UAAW,QAAS,QAAS,KAAM,QAAS,KAAM,QAAS,QAAS,KAAM,QAAS,O,+BCCtiBD,EAAOC,QADI,CAAC,MAAO,SAAU,QAAS,a,+BCAtC,IAAI4F,EAAS,GAAGA,OAChB7F,EAAOC,QAAU4F,G,+BCKjB7F,EAAOC,QADkB,ovC,mCCLzBe,OAAOK,eAAepB,EAAS,aAA/B,CACEK,OAAO,IAGT,IAAIkgB,EAAS,EAAQ,OAEjBC,EAAY,EAAQ,OAEpBhX,EAAW,EAAQ,OAEnBQ,EAAa,EAAQ,OAErBC,EAAkB,EAAQ,OAE1BC,EAAqB,EAAQ,OAE7BC,EAAa,EAAQ,OAErBK,EAAe,EAAQ,OAEvBC,EAAW,EAAQ,OAEnBI,EAAa,EAAQ,OAErBK,EAAkB,EAAQ,OAE1BuV,EAAa,EAAQ,OAErBpV,EAAW,EAAQ,OAEnBG,EAAW,EAAQ,OAEnBkV,EAAW,EAAQ,OAEnBC,EAAkB,EAAQ,OAE1BC,EAAiB,EAAQ,OAEzBlS,EAAa,EAAQ,OAErB1C,EAAO,EAAQ,OAEf6U,EAAkB,EAAQ,OAE1BlU,EAAgB,EAAQ,OAExBkG,EAAW,CACb,GAAI7G,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIA,EAEJ,GAAIhC,GAGF8W,EAAiB,CACnB,GAAIjW,GAGFkW,EAAc,CAChB,KAAMvW,EAEN,KAAMA,EAEN,GAAIA,GAGF0N,EAAO,CACT,GAAIuI,EAEJ,GAAI9T,EAEJ,GAAI,CAACkU,EAAiBlU,GAEtB,GAAItB,EAEJ,GAAIwV,EAEJ,GAAIlU,EAEJ,GAAIxC,EAEJ,IAAKA,GAGHxJ,EAAS,CACX,GAAIuJ,EAEJ,GAAID,GAGFiI,EAAO,CACT,KAAMxD,EAEN,KAAMA,EAEN,KAAMA,EAEN,GAAIiS,EAEJ,GAAIzW,EAEJ,GAAIsW,EAEJ,GAAI,CAAChX,EAAUgC,GAEf,GAAIoV,EAEJ,GAAI,CAAC1V,EAAiBjB,GAEtB,GAAIyW,EAEJ,GAAIF,EAEJ,GAAI/V,GAGFkS,EAAa,CACfC,KAAM,CAAC4D,EAAWD,EAAOS,WAK3BhhB,EAAQ8gB,eAAiBA,EACzB9gB,EAAQihB,QAJM,CACZrE,KAAM,IAIR5c,EAAQ6S,SAAWA,EACnB7S,EAAQkY,KAAOA,EACflY,EAAQ+gB,YAAcA,EACtB/gB,EAAQ2c,WAAaA,EACrB3c,EAAQW,OAASA,EACjBX,EAAQkS,KAAOA,G,kCCvJfnR,OAAOK,eAAepB,EAAS,aAA/B,CACEK,OAAO,IAGT,IAAI6Y,EAAqB,EAAQ,OAE7BgI,EAAe,EAAQ,OAEvB9H,EAEJ,SAA2BC,GACzB,IACIxF,EADAqL,EAAe7F,EAAQyB,QAAQxJ,KAAKsB,OAAO8J,WAAWoE,gBAI1D,SAAoC9c,GAClC,GAAa,OAATA,EAEF,YADAqV,EAAQG,QAAQxV,GAOlB,OAHAqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cACNsU,EAAa7H,EAAS6F,EAAc,iBAG7C,SAA0Blb,GAExB,OADAqV,EAAQ9P,MAAM,aACP4X,EAAUnd,MAhBnB,OAAOkb,EAmBP,SAASiC,EAAUnd,GACjB,IAAIqN,EAAQgI,EAAQ9P,MAAM,YAAa,CACrC8V,YAAa,OACbxL,SAAUA,IAQZ,OALIA,IACFA,EAASuN,KAAO/P,GAGlBwC,EAAWxC,EACJ1G,EAAK3G,GAGd,SAAS2G,EAAK3G,GACZ,OAAa,OAATA,GACFqV,EAAQzM,KAAK,aACbyM,EAAQzM,KAAK,kBACbyM,EAAQG,QAAQxV,IAIdkV,EAAmBlV,IACrBqV,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,aACNuU,IAIT9H,EAAQG,QAAQxV,GACT2G,KAIX3K,EAAQoZ,SAAWA,G,mCClEnBrY,OAAOK,eAAepB,EAAS,aAA/B,CACEK,OAAO,IAGT,IAAI6Y,EAAqB,EAAQ,OAE7BgI,EAAe,EAAQ,OAEvBG,EAAmB,EAAQ,OAE3BjI,EAQJ,SAA4BC,GAC1B,IAOIiI,EACAC,EACAC,EATA5G,EAAOtJ,KACPzK,EAAQ,GACR4a,EAAY,EACZC,EAAmB,CACrBtI,SAuGF,SAAyBC,EAASC,GAChC,IAAIqI,EAAe,EAEnB,OADAL,EAAgB,GACTM,EAEP,SAASA,EAAa5d,GACpB,OAAI2d,EAAe9a,EAAMnG,QACvBka,EAAKiH,eAAiBhb,EAAM8a,GAAc,GACnCtI,EAAQyB,QAAQjU,EAAM8a,GAAc,GAAGG,aAAcC,EAAiBC,EAAtE3I,CAAmFrV,IAKxFud,EAAUU,kBAAoBV,EAAUU,iBAAiBC,UAC3DZ,EAAca,cAAe,EACtBC,EAAYpe,KAGrB4W,EAAKyH,UAAYd,EAAUU,kBAAoBV,EAAUU,iBAAiB3C,cAC1E1E,EAAKiH,eAAiB,GACfxI,EAAQyB,QAAQwH,EAAoBC,EAAgBH,EAApD/I,CAAiErV,IAG1E,SAAS+d,EAAgB/d,GAEvB,OADA2d,IACO/G,EAAKiH,eAAeW,WAAaD,EAAeve,GAAQ4d,EAAa5d,GAG9E,SAASge,EAAYhe,GACnB,OAAIud,EAAUU,kBAAoBV,EAAUU,iBAAiBQ,MAE3D7H,EAAKiH,eAAiB,GACfxI,EAAQyB,QAAQwH,EAAoBC,EAC3ClJ,EAAQyB,QAAQ4H,EAAmBH,EAAgBlJ,EAAQU,MAAMsH,EAAkBkB,EAAgBI,IAD5FtJ,CAC2GrV,IAI7Gue,EAAeve,GAGxB,SAAS2e,EAAY3e,GAKnB,OAHA2d,EAAe9a,EAAMnG,OACrB4gB,EAAcmB,MAAO,EACrBnB,EAAca,cAAe,EACtBC,EAAYpe,GAIrB,SAASue,EAAeve,GAEtB,OADAsd,EAAcsB,SAAU,EACjBR,EAAYpe,GAGrB,SAASoe,EAAYpe,GAGnB,OAFAsd,EAAcG,UAAYE,EAC1B/G,EAAKyH,UAAYzH,EAAKiH,oBAAiBxc,EAChCiU,EAAGtV,KA/JZ4V,SAAS,GAKX,OAAOzV,EAEP,SAASA,EAAMH,GACb,OAAIyd,EAAY5a,EAAMnG,QACpBka,EAAKiH,eAAiBhb,EAAM4a,GAAW,GAChCpI,EAAQyB,QAAQjU,EAAM4a,GAAW,GAAGK,aAAce,EAAkBC,EAApEzJ,CAAuFrV,IAGzF8e,EAAkB9e,GAG3B,SAAS6e,EAAiB7e,GAExB,OADAyd,IACOtd,EAAMH,GAGf,SAAS8e,EAAkB9e,GAGzB,OAAIsd,GAAiBA,EAAca,aAC1BY,EAAU/e,IAGnB4W,EAAKyH,UAAYd,GAAaA,EAAUU,kBAAoBV,EAAUU,iBAAiB3C,cACvF1E,EAAKiH,eAAiB,GACfxI,EAAQyB,QAAQwH,EAAoBU,EAAmBD,EAAvD1J,CAAkErV,IAG3E,SAASgf,EAAkBhf,GAGzB,OAFA6C,EAAMvB,KAAK,CAACsV,EAAKqH,iBAAkBrH,EAAKiH,iBACxCjH,EAAKiH,oBAAiBxc,EACfyd,EAAkB9e,GAG3B,SAAS+e,EAAU/e,GACjB,OAAa,OAATA,GACFif,EAAe,GAAG,QAClB5J,EAAQG,QAAQxV,KAIlBud,EAAYA,GAAa3G,EAAKhI,OAAOsF,KAAK0C,EAAKsI,OAC/C7J,EAAQ9P,MAAM,YAAa,CACzB8V,YAAa,OACbxL,SAAU2N,EACV2B,WAAY5B,IAEPY,EAAane,IAGtB,SAASme,EAAane,GACpB,OAAa,OAATA,GACFof,EAAa/J,EAAQzM,KAAK,cACnBmW,EAAU/e,IAGfkV,EAAmBlV,IACrBqV,EAAQG,QAAQxV,GAChBof,EAAa/J,EAAQzM,KAAK,cACnByM,EAAQU,MAAM2H,EAAkB2B,KAGzChK,EAAQG,QAAQxV,GACTme,GAGT,SAASkB,EAAkBrf,GAGzB,OAFAif,EAAe3B,EAAcG,UAAWH,GAAiBA,EAAcsB,SACvEnB,EAAY,EACLtd,EAAMH,GAGf,SAASof,EAAa/R,GAChBmQ,IAAYA,EAAWJ,KAAO/P,GAClCmQ,EAAanQ,EACbkQ,EAAUkB,KAAOnB,GAAiBA,EAAcmB,KAChDlB,EAAU+B,WAAWjS,EAAMlN,OAC3Bod,EAAUzO,MAAM8H,EAAK2I,YAAYlS,IAGnC,SAAS4R,EAAevf,EAAMW,GAC5B,IAAIjE,EAAQyG,EAAMnG,OAQlB,IANI6gB,GAAald,IACfkd,EAAUzO,MAAM,CAAC,OACjB0O,EAAaD,OAAYlc,GAIpBjF,KAAUsD,GACfkX,EAAKiH,eAAiBhb,EAAMzG,GAAO,GACnCyG,EAAMzG,GAAO,GAAGwM,KAAKlL,KAAKkZ,EAAMvB,GAGlCxS,EAAMnG,OAASgD,IAhHf4e,EAAqB,CACvBlJ,SAgLF,SAA2BC,EAASC,EAAIC,GACtC,OAAO2H,EAAa7H,EAASA,EAAQyB,QAAQxJ,KAAKsB,OAAO8J,WAAW7J,SAAUyG,EAAIC,GAAM,aAAcjI,KAAKsB,OAAO8J,WAAWuE,QAAQrE,KAAKnc,QAAQ,iBAAmB,OAAI4E,EAAY,KA/KnLqd,EAAoB,CACtBtJ,SAiLF,SAA0BC,EAASC,EAAIC,GACrC,OAAO2H,EAAa7H,EAASA,EAAQoJ,KAAKnR,KAAKsB,OAAO8J,WAAWxE,KAAMoB,EAAIC,GAAM,aAAcjI,KAAKsB,OAAO8J,WAAWuE,QAAQrE,KAAKnc,QAAQ,iBAAmB,OAAI4E,EAAY,KAGhLrF,EAAQoZ,SAAWA,G,mCCpMnBrY,OAAOK,eAAepB,EAAS,aAA/B,CACEK,OAAO,IAGT,IAAI4e,EAAU,EAAQ,OAElBiC,EAAe,EAAQ,OAEvBG,EAAmB,EAAQ,OAE3BjI,EAEJ,SAAwBC,GACtB,IAAIuB,EAAOtJ,KACPkS,EAAUnK,EAAQyB,QACtBuG,GAIA,SAAuBrd,GACrB,GAAa,OAATA,EAEF,YADAqV,EAAQG,QAAQxV,GAQlB,OAJAqV,EAAQ9P,MAAM,mBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,mBACbgO,EAAKqH,sBAAmB5c,EACjBme,IAbTnK,EAAQyB,QAAQxJ,KAAKsB,OAAO8J,WAAWqE,YAAa0C,EAAgBvC,EAAa7H,EAASA,EAAQyB,QAAQxJ,KAAKsB,OAAO8J,WAAWxE,KAAMuL,EAAgBpK,EAAQyB,QAAQmE,EAASwE,IAAkB,gBAClM,OAAOD,EAeP,SAASC,EAAezf,GACtB,GAAa,OAATA,EASJ,OAJAqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cACbgO,EAAKqH,sBAAmB5c,EACjBme,EARLnK,EAAQG,QAAQxV,KAYtBhE,EAAQoZ,SAAWA,G,mCC9CnBrY,OAAOK,eAAepB,EAAS,aAA/B,CACEK,OAAO,IAGT,IAAI6P,EAAS,EAAQ,MAEjBsM,EAAU,EAAQ,OAElBtK,EAAOwR,EAAkB,QACzB/iB,EAAS+iB,EAAkB,UAC3B1C,EAAW,CACb1E,WAAYqH,KAGd,SAASD,EAAkBE,GACzB,MAAO,CACLxK,SAIF,SAAwBC,GACtB,IAAIuB,EAAOtJ,KACPoL,EAAapL,KAAKsB,OAAO8J,WAAWkH,GACpC1R,EAAOmH,EAAQyB,QAAQ4B,EAAYvY,EAAO0f,GAC9C,OAAO1f,EAEP,SAASA,EAAMH,GACb,OAAOkS,EAAQlS,GAAQkO,EAAKlO,GAAQ6f,EAAQ7f,GAG9C,SAAS6f,EAAQ7f,GACf,GAAa,OAATA,EAOJ,OAFAqV,EAAQ9P,MAAM,QACd8P,EAAQG,QAAQxV,GACT2G,EANL0O,EAAQG,QAAQxV,GASpB,SAAS2G,EAAK3G,GACZ,OAAIkS,EAAQlS,IACVqV,EAAQzM,KAAK,QACNsF,EAAKlO,KAIdqV,EAAQG,QAAQxV,GACT2G,GAGT,SAASuL,EAAQlS,GACf,IAAIgI,EAAO0Q,EAAW1Y,GAClB5D,GAAS,EAEb,GAAa,OAAT4D,EACF,OAAO,EAGT,GAAIgI,EACF,OAAS5L,EAAQ4L,EAAKtL,QACpB,IAAKsL,EAAK5L,GAAOyT,UAAY7H,EAAK5L,GAAOyT,SAASnS,KAAKkZ,EAAMA,EAAK/G,UAChE,OAAO,IA9CfyI,WAAYqH,EAAyB,SAAVC,EAAmBE,OAAyBze,IAsD3E,SAASse,EAAeI,GACtB,OAEA,SAAwBtU,EAAQG,GAC9B,IACIrG,EADAnJ,GAAS,EAIb,OAASA,GAASqP,EAAO/O,aACT2E,IAAVkE,EACEkG,EAAOrP,IAAoC,SAA1BqP,EAAOrP,GAAO,GAAGmG,OACpCgD,EAAQnJ,EACRA,KAEQqP,EAAOrP,IAAoC,SAA1BqP,EAAOrP,GAAO,GAAGmG,OAExCnG,IAAUmJ,EAAQ,IACpBkG,EAAOlG,GAAO,GAAGlF,IAAMoL,EAAOrP,EAAQ,GAAG,GAAGiE,IAC5CoL,EAAO7J,OAAO2D,EAAQ,EAAGnJ,EAAQmJ,EAAQ,GACzCnJ,EAAQmJ,EAAQ,GAGlBA,OAAQlE,GAIZ,OAAO0e,EAAgBA,EAActU,EAAQG,GAAWH,GAW5D,SAASqU,EAAuBrU,EAAQG,GAWtC,IAVA,IACIoU,EACArZ,EACAsZ,EACA7jB,EACA8jB,EACAxgB,EACAygB,EACA9S,EARA+S,GAAc,IAUTA,GAAc3U,EAAO/O,QAC5B,IAAK0jB,IAAe3U,EAAO/O,QAAyC,eAA/B+O,EAAO2U,GAAY,GAAG7d,OAA6D,SAAnCkJ,EAAO2U,EAAa,GAAG,GAAG7d,KAAiB,CAQ9H,IAPAoE,EAAO8E,EAAO2U,EAAa,GAAG,GAE9BhkB,GADA4jB,EAASpU,EAAQ2T,YAAY5Y,IACdjK,OACfwjB,GAAe,EACfxgB,EAAO,EACPygB,OAAO9e,EAEAjF,KAGL,GAAqB,iBAFrB6jB,EAAQD,EAAO5jB,IAEgB,CAG7B,IAFA8jB,EAAcD,EAAMvjB,OAEyB,KAAtCujB,EAAMje,WAAWke,EAAc,IACpCxgB,IACAwgB,IAGF,GAAIA,EAAa,MACjBA,GAAe,OAEZ,IAAe,IAAXD,EACLE,GAAO,EACPzgB,SACK,IAAe,IAAXugB,EAAoB,CAE7B7jB,IACA,MAIFsD,IACF2N,EAAQ,CACN9K,KAAM6d,IAAe3U,EAAO/O,QAAUyjB,GAAQzgB,EAAO,EAAI,aAAe,oBACxES,MAAO,CACLN,KAAM8G,EAAKtG,IAAIR,KACfyM,OAAQ3F,EAAKtG,IAAIiM,OAAS5M,EAC1B6M,OAAQ5F,EAAKtG,IAAIkM,OAAS7M,EAC1B2gB,OAAQ1Z,EAAKxG,MAAMkgB,OAASjkB,EAC5BkkB,aAAclkB,EAAQ8jB,EAAcvZ,EAAKxG,MAAMmgB,aAAeJ,GAEhE7f,IAAKmY,EAAQ7R,EAAKtG,MAEpBsG,EAAKtG,IAAMmY,EAAQnL,EAAMlN,OAErBwG,EAAKxG,MAAMoM,SAAW5F,EAAKtG,IAAIkM,OACjCL,EAAOvF,EAAM0G,IAEb5B,EAAO7J,OAAOwe,EAAY,EAAG,CAAC,QAAS/S,EAAOzB,GAAU,CAAC,OAAQyB,EAAOzB,IACxEwU,GAAc,IAIlBA,IAIJ,OAAO3U,EAGTzP,EAAQghB,SAAWA,EACnBhhB,EAAQW,OAASA,EACjBX,EAAQkS,KAAOA,G,mCCvLf,IAAI+M,EAAU,EAAQ,MAElBpM,EAAW,EAAQ,OAEnBqF,EAAO,EAAQ,OAEfhG,EAAO,EAAQ,OAEfqS,EAAoB,EAAQ,MAE5BC,EAAkB,EAAQ,OAE1BC,EAAW,EAAQ,OAEnB/H,EAAa,EAAQ,OAwBzB3c,EAAOC,QAtBP,SAAemC,GACb,IACIyQ,EAAS,CACX8R,QAAS,GACThI,WAAY6H,EAAkB,CAAC7H,GAAYlY,OAAOigB,GAHrCtiB,GAAW,IAG4C+G,cACpE+V,QAAS/N,EAAO+N,GAChBpM,SAAU3B,EAAO2B,GACjBqF,KAAMhH,EAAOgH,GACbvX,OAAQuQ,EAAOgB,EAAKvR,QACpBuR,KAAMhB,EAAOgB,EAAKA,OAEpB,OAAOU,EAEP,SAAS1B,EAAOyT,GACd,OAEA,SAAiBC,GACf,OAAOJ,EAAgB5R,EAAQ+R,EAAaC,O,mCCjClD,IAAIC,EAAc,EAAQ,OAS1B9kB,EAAOC,QAPP,SAAqByP,GACnB,MAAQoV,EAAYpV,KAGpB,OAAOA,I,+BCNT,IAAIlI,EAAS,cAsFbxH,EAAOC,QApFP,WACE,IAGI8kB,EAHA3gB,GAAQ,EACRmM,EAAS,EACThG,EAAS,GAEb,OAEA,SAAsBjK,EAAO2I,EAAU3E,GACrC,IACIwD,EACAuZ,EACA2D,EACAC,EACAhhB,EALAggB,EAAS,GAMb3jB,EAAQiK,EAASjK,EAAMc,SAAS6H,GAChC+b,EAAgB,EAChBza,EAAS,GAELnG,IAC0B,QAAxB9D,EAAM2F,WAAW,IACnB+e,IAGF5gB,OAAQkB,GAGV,KAAO0f,EAAgB1kB,EAAMK,QAAQ,CAMnC,GALA6G,EAAOS,UAAY+c,EACnBld,EAAQN,EAAOD,KAAKjH,GACpB2kB,EAAcnd,EAAQA,EAAMzH,MAAQC,EAAMK,OAC1CsD,EAAO3D,EAAM2F,WAAWgf,IAEnBnd,EAAO,CACVyC,EAASjK,EAAM8H,MAAM4c,GACrB,MAGF,GAAa,KAAT/gB,GAAe+gB,IAAkBC,GAAeF,EAClDd,EAAO1e,MAAM,GACbwf,OAAmBzf,OAYnB,GAVIyf,IACFd,EAAO1e,MAAM,GACbwf,OAAmBzf,GAGjB0f,EAAgBC,IAClBhB,EAAO1e,KAAKjF,EAAM8H,MAAM4c,EAAeC,IACvC1U,GAAU0U,EAAcD,GAGb,IAAT/gB,EACFggB,EAAO1e,KAAK,OACZgL,SACK,GAAa,IAATtM,EAIT,IAHAod,EAA+B,EAAxB1b,KAAKsS,KAAK1H,EAAS,GAC1B0T,EAAO1e,MAAM,GAENgL,IAAW8Q,GAChB4C,EAAO1e,MAAM,QAEG,KAATtB,GACTggB,EAAO1e,MAAM,GACbgL,EAAS,IAGPwU,GAAmB,EACnBxU,EAAS,GAIfyU,EAAgBC,EAAc,EAG5B3gB,IACEygB,GAAkBd,EAAO1e,MAAM,GAC/BgF,GAAQ0Z,EAAO1e,KAAKgF,GACxB0Z,EAAO1e,KAAK,OAGd,OAAO0e,K,mCClFX,IAAIiB,EAAc,EAAQ,OAEtBxI,EAAgB,EAAQ,MAExBN,EAAoB,EAAQ,OAE5B+I,EAAY,EAAQ,OAEpB5I,EAAa,EAAQ,OAErBE,EAAU,EAAQ,OAElBgE,EAAY,CACdpe,KAAM,YACNgX,SAmGF,SAA2BC,EAASC,GAClC,IACIlB,EADAtU,EAASqY,EAAkB7K,KAAKuC,UAEpC,OAEA,SAAe7P,GAGb,OAFAqV,EAAQ9P,MAAM,qBACd6O,EAASpU,EACFyT,EAASzT,IAGlB,SAASyT,EAASzT,GAChB,IAAIqN,EACAtN,EACAqN,EACAG,EAEJ,OAAIvN,IAASoU,GACXiB,EAAQG,QAAQxV,GACTyT,IAGTpG,EAAQgI,EAAQzM,KAAK,qBAErBwE,IADArN,EAAQoY,EAAkBnY,KACC,IAAVD,GAAeD,EAChCyN,GAASzN,GAAqB,IAAXA,GAAgBC,EACnCsN,EAAM+K,MAAmB,KAAXhE,EAAgBhH,EAAOA,IAAStN,IAAWyN,GACzDF,EAAMgL,OAAoB,KAAXjE,EAAgB7G,EAAQA,IAAUxN,IAAUqN,GACpDkI,EAAGtV,MA9HZsY,WAGF,SAA6B7M,EAAQG,GACnC,IACIwB,EACA+T,EACAjT,EACAkT,EACAC,EACAC,EACA/I,EACAhM,EARAnQ,GAAS,EAab,OAASA,EAAQqP,EAAO/O,QAEtB,GAAyB,UAArB+O,EAAOrP,GAAO,IAA4C,sBAA1BqP,EAAOrP,GAAO,GAAGmG,MAAgCkJ,EAAOrP,GAAO,GAAGic,OAGpG,IAFAjL,EAAOhR,EAEAgR,KAEL,GAAwB,SAApB3B,EAAO2B,GAAM,IAA0C,sBAAzB3B,EAAO2B,GAAM,GAAG7K,MAAgCkJ,EAAO2B,GAAM,GAAGgL,OAClGxM,EAAQO,eAAeV,EAAO2B,GAAM,IAAIpL,WAAW,KAAO4J,EAAQO,eAAeV,EAAOrP,GAAO,IAAI4F,WAAW,GAAI,CAKhH,IAAKyJ,EAAO2B,GAAM,GAAGiL,QAAU5M,EAAOrP,GAAO,GAAGgc,SAAW3M,EAAOrP,GAAO,GAAGiE,IAAIkM,OAASd,EAAOrP,GAAO,GAAG+D,MAAMoM,QAAU,MAAQd,EAAO2B,GAAM,GAAG/M,IAAIkM,OAASd,EAAO2B,GAAM,GAAGjN,MAAMoM,OAASd,EAAOrP,GAAO,GAAGiE,IAAIkM,OAASd,EAAOrP,GAAO,GAAG+D,MAAMoM,QAAU,GAC3P,SAIF+U,EAAM7V,EAAO2B,GAAM,GAAG/M,IAAIkM,OAASd,EAAO2B,GAAM,GAAGjN,MAAMoM,OAAS,GAAKd,EAAOrP,GAAO,GAAGiE,IAAIkM,OAASd,EAAOrP,GAAO,GAAG+D,MAAMoM,OAAS,EAAI,EAAI,EAC7I6U,EAAkB,CAChB7e,KAAM+e,EAAM,EAAI,iBAAmB,mBACnCnhB,MAAO+gB,EAAU1I,EAAQ/M,EAAO2B,GAAM,GAAG/M,MAAOihB,GAChDjhB,IAAKmY,EAAQ/M,EAAO2B,GAAM,GAAG/M,MAE/BghB,EAAkB,CAChB9e,KAAM+e,EAAM,EAAI,iBAAmB,mBACnCnhB,MAAOqY,EAAQ/M,EAAOrP,GAAO,GAAG+D,OAChCE,IAAK6gB,EAAU1I,EAAQ/M,EAAOrP,GAAO,GAAG+D,OAAQmhB,IAElDpT,EAAO,CACL3L,KAAM+e,EAAM,EAAI,aAAe,eAC/BnhB,MAAOqY,EAAQ/M,EAAO2B,GAAM,GAAG/M,KAC/BA,IAAKmY,EAAQ/M,EAAOrP,GAAO,GAAG+D,QAEhCghB,EAAQ,CACN5e,KAAM+e,EAAM,EAAI,SAAW,WAC3BnhB,MAAOqY,EAAQ4I,EAAgBjhB,OAC/BE,IAAKmY,EAAQ6I,EAAgBhhB,MAE/BoL,EAAO2B,GAAM,GAAG/M,IAAMmY,EAAQ4I,EAAgBjhB,OAC9CsL,EAAOrP,GAAO,GAAG+D,MAAQqY,EAAQ6I,EAAgBhhB,KACjDkY,EAAa,GAET9M,EAAO2B,GAAM,GAAG/M,IAAIkM,OAASd,EAAO2B,GAAM,GAAGjN,MAAMoM,SACrDgM,EAAa0I,EAAY1I,EAAY,CAAC,CAAC,QAAS9M,EAAO2B,GAAM,GAAIxB,GAAU,CAAC,OAAQH,EAAO2B,GAAM,GAAIxB,MAIvG2M,EAAa0I,EAAY1I,EAAY,CAAC,CAAC,QAAS4I,EAAOvV,GAAU,CAAC,QAASwV,EAAiBxV,GAAU,CAAC,OAAQwV,EAAiBxV,GAAU,CAAC,QAASsC,EAAMtC,KAE1J2M,EAAa0I,EAAY1I,EAAYD,EAAW1M,EAAQgD,OAAO8J,WAAWC,WAAWC,KAAMnN,EAAOtH,MAAMiJ,EAAO,EAAGhR,GAAQwP,IAE1H2M,EAAa0I,EAAY1I,EAAY,CAAC,CAAC,OAAQrK,EAAMtC,GAAU,CAAC,QAASyV,EAAiBzV,GAAU,CAAC,OAAQyV,EAAiBzV,GAAU,CAAC,OAAQuV,EAAOvV,KAEpJH,EAAOrP,GAAO,GAAGiE,IAAIkM,OAASd,EAAOrP,GAAO,GAAG+D,MAAMoM,QACvDA,EAAS,EACTgM,EAAa0I,EAAY1I,EAAY,CAAC,CAAC,QAAS9M,EAAOrP,GAAO,GAAIwP,GAAU,CAAC,OAAQH,EAAOrP,GAAO,GAAIwP,MAEvGW,EAAS,EAGXkM,EAAchN,EAAQ2B,EAAO,EAAGhR,EAAQgR,EAAO,EAAGmL,GAClDnc,EAAQgR,EAAOmL,EAAW7b,OAAS6P,EAAS,EAC5C,MAORnQ,GAAS,EAET,OAASA,EAAQqP,EAAO/O,QACQ,sBAA1B+O,EAAOrP,GAAO,GAAGmG,OACnBkJ,EAAOrP,GAAO,GAAGmG,KAAO,QAI5B,OAAOkJ,IAmCT1P,EAAOC,QAAUwgB,G,mCCjJjB,IAAIzH,EAAa,EAAQ,MAErBC,EAAoB,EAAQ,OAE5BiH,EAAa,EAAQ,OAErBhH,EAAe,EAAQ,OAEvBzP,EAAW,CACbpH,KAAM,WACNgX,SAGF,SAA0BC,EAASC,EAAIC,GACrC,IAAI7V,EAAO,EACX,OAEA,SAAeM,GAMb,OALAqV,EAAQ9P,MAAM,YACd8P,EAAQ9P,MAAM,kBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,kBACbyM,EAAQ9P,MAAM,oBACP6H,GAGT,SAASA,EAAKpN,GACZ,OAAI+U,EAAW/U,IACbqV,EAAQG,QAAQxV,GACTuhB,GAGFtF,EAAWjc,GAAQwhB,EAAWxhB,GAAQuV,EAAIvV,GAGnD,SAASuhB,EAAmBvhB,GAC1B,OAAgB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAegV,EAAkBhV,GAAQyhB,EAAyBzhB,GAAQwhB,EAAWxhB,GAG5H,SAASyhB,EAAyBzhB,GAChC,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACT0hB,IAGK,KAAT1hB,GAAwB,KAATA,GAAwB,KAATA,GAAegV,EAAkBhV,KAAUN,IAAS,IACrF2V,EAAQG,QAAQxV,GACTyhB,GAGFD,EAAWxhB,GAGpB,SAAS0hB,EAAU1hB,GACjB,OAAa,KAATA,GACFqV,EAAQzM,KAAK,oBACNvI,EAAIL,IAGA,KAATA,GAAwB,KAATA,GAAeiV,EAAajV,GACtCuV,EAAIvV,IAGbqV,EAAQG,QAAQxV,GACT0hB,GAGT,SAASF,EAAWxhB,GAClB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GAChBN,EAAO,EACAiiB,GAGL1F,EAAWjc,IACbqV,EAAQG,QAAQxV,GACTwhB,GAGFjM,EAAIvV,GAGb,SAAS2hB,EAAiB3hB,GACxB,OAAOgV,EAAkBhV,GAAQ4hB,EAAW5hB,GAAQuV,EAAIvV,GAG1D,SAAS4hB,EAAW5hB,GAClB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GAChBN,EAAO,EACAiiB,GAGI,KAAT3hB,GAEFqV,EAAQzM,KAAK,oBAAoBrG,KAAO,gBACjClC,EAAIL,IAGN6hB,EAAW7hB,GAGpB,SAAS6hB,EAAW7hB,GAClB,OAAc,KAATA,GAAegV,EAAkBhV,KAAUN,IAAS,IACvD2V,EAAQG,QAAQxV,GACA,KAATA,EAAc6hB,EAAaD,GAG7BrM,EAAIvV,GAGb,SAASK,EAAIL,GAKX,OAJAqV,EAAQ9P,MAAM,kBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,kBACbyM,EAAQzM,KAAK,YACN0M,KAIXvZ,EAAOC,QAAUwJ,G,mCCxHjB,IAAIsc,EAAgB,EAAQ,OAExB5E,EAAe,EAAQ,OAEvBlX,EAAa,CACf5H,KAAM,aACNgX,SAOF,SAAiCC,EAASC,EAAIC,GAC5C,IAAIqB,EAAOtJ,KACX,OAEA,SAAetN,GACb,GAAa,KAATA,EAYF,OAXK4W,EAAKiH,eAAezQ,OACvBiI,EAAQ9P,MAAM,aAAc,CAC1Bwc,YAAY,IAEdnL,EAAKiH,eAAezQ,MAAO,GAG7BiI,EAAQ9P,MAAM,oBACd8P,EAAQ9P,MAAM,oBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,oBACN7I,EAGT,OAAOwV,EAAIvV,IAGb,SAASD,EAAMC,GACb,OAAI8hB,EAAc9hB,IAChBqV,EAAQ9P,MAAM,8BACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,8BACbyM,EAAQzM,KAAK,oBACN0M,IAGTD,EAAQzM,KAAK,oBACN0M,EAAGtV,MAvCZ8d,aAAc,CACZ1I,SA0CJ,SAAwCC,EAASC,EAAIC,GACnD,OAAO2H,EAAa7H,EAASA,EAAQyB,QAAQ9Q,EAAYsP,EAAIC,GAAM,aAAcjI,KAAKsB,OAAO8J,WAAWuE,QAAQrE,KAAKnc,QAAQ,iBAAmB,OAAI4E,EAAY,KAzChKuH,KA4CF,SAAcyM,GACZA,EAAQzM,KAAK,gBAGf7M,EAAOC,QAAUgK,G,mCC1DjB,IAAIoW,EAAmB,EAAQ,OAE3BnW,EAAkB,CACpB7H,KAAM,kBACNgX,SAGF,SAAiCC,EAASC,EAAIC,GAC5C,OAEA,SAAevV,GAKb,OAJAqV,EAAQ9P,MAAM,mBACd8P,EAAQ9P,MAAM,gBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,gBACNwE,GAGT,SAASA,EAAKpN,GACZ,OAAIoc,EAAiBpc,IACnBqV,EAAQ9P,MAAM,wBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,wBACbyM,EAAQzM,KAAK,mBACN0M,GAGFC,EAAIvV,MAIfjE,EAAOC,QAAUiK,G,mCC/BjB,IAAI+b,EAAe,EAAQ,OAEvBhN,EAAoB,EAAQ,OAE5BkH,EAAa,EAAQ,OAErBC,EAAgB,EAAQ,OAE5B,SAAS8F,EAAsBC,GAC7B,OAAOA,GAAkB,iBAANA,GAAkB,YAAaA,EAAIA,EAAI,CACxDC,QAASD,GAIb,IAAIE,EAAqCH,EAAsBD,GAE3D9b,EAAqB,CACvB9H,KAAM,qBACNgX,SAGF,SAAoCC,EAASC,EAAIC,GAC/C,IAEI5T,EACAmO,EAHA8G,EAAOtJ,KACP5N,EAAO,EAGX,OAEA,SAAeM,GAKb,OAJAqV,EAAQ9P,MAAM,sBACd8P,EAAQ9P,MAAM,4BACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,4BACNwE,GAGT,SAASA,EAAKpN,GACZ,OAAa,KAATA,GACFqV,EAAQ9P,MAAM,mCACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,mCACNyZ,IAGThN,EAAQ9P,MAAM,2BACd5D,EAAM,GACNmO,EAAOkF,EACA3Y,EAAM2D,IAGf,SAASqiB,EAAQriB,GACf,OAAa,KAATA,GAAwB,MAATA,GACjBqV,EAAQ9P,MAAM,uCACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,uCACbyM,EAAQ9P,MAAM,2BACd5D,EAAM,EACNmO,EAAOqM,EACA9f,IAGTgZ,EAAQ9P,MAAM,2BACd5D,EAAM,EACNmO,EAAOoM,EACA7f,EAAM2D,IAGf,SAAS3D,EAAM2D,GACb,IAAIqN,EAEJ,OAAa,KAATrN,GAAeN,GACjB2N,EAAQgI,EAAQzM,KAAK,2BAEjBkH,IAASkF,GAAsBoN,EAA+B,QAAExL,EAAKzK,eAAekB,KAIxFgI,EAAQ9P,MAAM,4BACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,4BACbyM,EAAQzM,KAAK,sBACN0M,GAPEC,EAAIvV,IAUX8P,EAAK9P,IAASN,IAASiC,GACzB0T,EAAQG,QAAQxV,GACT3D,GAGFkZ,EAAIvV,MAIfjE,EAAOC,QAAUkK,G,mCC7FjB,IAAIgP,EAAqB,EAAQ,OAE7BsG,EAA4B,EAAQ,OAEpCE,EAAa,EAAQ,MAErBwB,EAAe,EAAQ,OAEvB/W,EAAa,CACf/H,KAAM,aACNgX,SAIF,SAA4BC,EAASC,EAAIC,GACvC,IAOInB,EAPAwC,EAAOtJ,KACPgV,EAAwB,CAC1BlN,SA+GF,SAA8BC,EAASC,EAAIC,GACzC,IAAI7V,EAAO,EACX,OAAOwd,EAAa7H,EAASkN,EAAsB,aAAcjV,KAAKsB,OAAO8J,WAAWuE,QAAQrE,KAAKnc,QAAQ,iBAAmB,OAAI4E,EAAY,GAEhJ,SAASkhB,EAAqBviB,GAG5B,OAFAqV,EAAQ9P,MAAM,mBACd8P,EAAQ9P,MAAM,2BACP8b,EAAgBrhB,GAGzB,SAASqhB,EAAgBrhB,GACvB,OAAIA,IAASoU,GACXiB,EAAQG,QAAQxV,GAChBN,IACO2hB,GAGL3hB,EAAO8iB,EAAiBjN,EAAIvV,IAChCqV,EAAQzM,KAAK,2BACNsU,EAAa7H,EAASoN,EAAoB,aAA1CvF,CAAwDld,IAGjE,SAASyiB,EAAmBziB,GAC1B,OAAa,OAATA,GAAiBkV,EAAmBlV,IACtCqV,EAAQzM,KAAK,mBACN0M,EAAGtV,IAGLuV,EAAIvV,KA1Ib4V,SAAS,GAEP8M,EAAgBhH,EAAWpO,KAAK7B,OAAQ,cACxC+W,EAAW,EAEf,OAEA,SAAexiB,GAKb,OAJAqV,EAAQ9P,MAAM,cACd8P,EAAQ9P,MAAM,mBACd8P,EAAQ9P,MAAM,2BACd6O,EAASpU,EACF2iB,EAAa3iB,IAGtB,SAAS2iB,EAAa3iB,GACpB,OAAIA,IAASoU,GACXiB,EAAQG,QAAQxV,GAChBwiB,IACOG,IAGTtN,EAAQzM,KAAK,2BACN4Z,EAAW,EAAIjN,EAAIvV,GAAQkd,EAAa7H,EAASuN,EAAU,aAAhC1F,CAA8Cld,IAGlF,SAAS4iB,EAAS5iB,GAChB,OAAa,OAATA,GAAiBkV,EAAmBlV,GAC/B6iB,EAAU7iB,IAGnBqV,EAAQ9P,MAAM,uBACd8P,EAAQ9P,MAAM,cAAe,CAC3B8V,YAAa,WAERyH,EAAK9iB,IAGd,SAAS8iB,EAAK9iB,GACZ,OAAa,OAATA,GAAiBwb,EAA0Bxb,IAC7CqV,EAAQzM,KAAK,eACbyM,EAAQzM,KAAK,uBACNsU,EAAa7H,EAAS0N,EAAW,aAAjC7F,CAA+Cld,IAG3C,KAATA,GAAeA,IAASoU,EAAemB,EAAIvV,IAC/CqV,EAAQG,QAAQxV,GACT8iB,GAGT,SAASC,EAAU/iB,GACjB,OAAa,OAATA,GAAiBkV,EAAmBlV,GAC/B6iB,EAAU7iB,IAGnBqV,EAAQ9P,MAAM,uBACd8P,EAAQ9P,MAAM,cAAe,CAC3B8V,YAAa,WAER3N,EAAK1N,IAGd,SAAS0N,EAAK1N,GACZ,OAAa,OAATA,GAAiBkV,EAAmBlV,IACtCqV,EAAQzM,KAAK,eACbyM,EAAQzM,KAAK,uBACNia,EAAU7iB,IAGN,KAATA,GAAeA,IAASoU,EAAemB,EAAIvV,IAC/CqV,EAAQG,QAAQxV,GACT0N,GAGT,SAASmV,EAAU7iB,GAEjB,OADAqV,EAAQzM,KAAK,mBACNgO,EAAKyH,UAAY/I,EAAGtV,GAAQib,EAAQjb,GAG7C,SAASib,EAAQjb,GACf,OAAa,OAATA,EACKD,EAAMC,GAGXkV,EAAmBlV,IACrBqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cACNyM,EAAQyB,QAAQwL,EAAuBviB,EAAO2iB,EAAgBxF,EAAa7H,EAAS4F,EAAS,aAAcyH,EAAgB,GAAKzH,KAGzI5F,EAAQ9P,MAAM,iBACPyd,EAAgBhjB,IAGzB,SAASgjB,EAAgBhjB,GACvB,OAAa,OAATA,GAAiBkV,EAAmBlV,IACtCqV,EAAQzM,KAAK,iBACNqS,EAAQjb,KAGjBqV,EAAQG,QAAQxV,GACTgjB,GAGT,SAASjjB,EAAMC,GAEb,OADAqV,EAAQzM,KAAK,cACN0M,EAAGtV,KAlHZke,UAAU,GAsJZniB,EAAOC,QAAUmK,G,mCCjKjB,IAAI+O,EAAqB,EAAQ,OAE7BuD,EAAgB,EAAQ,MAExBiD,EAAa,EAAQ,MAErBwB,EAAe,EAAQ,OAEvB1W,EAAe,CACjBpI,KAAM,eACNgX,SAmBF,SAA8BC,EAASC,EAAIC,GACzC,OAAOF,EAAQyB,QAAQmM,EAA0BC,EAAa3N,GAE9D,SAAS2N,EAAYljB,GACnB,OAAa,OAATA,EACKsV,EAAGtV,GAGRkV,EAAmBlV,GACdqV,EAAQyB,QAAQmM,EAA0BC,EAAa5N,EAAvDD,CAA2DrV,IAGpEqV,EAAQ9P,MAAM,iBACP0V,EAAQjb,IAGjB,SAASib,EAAQjb,GACf,OAAa,OAATA,GAAiBkV,EAAmBlV,IACtCqV,EAAQzM,KAAK,iBACNsa,EAAYljB,KAGrBqV,EAAQG,QAAQxV,GACTib,KAzCTJ,QAOF,SAA6BpP,EAAQG,GACnC,IAAI5L,EAAO,CACTuC,KAAM,eACNpC,MAAOsL,EAAO,GAAG,GAAGtL,MACpBE,IAAKoL,EAAOA,EAAO/O,OAAS,GAAG,GAAG2D,KAIpC,OAFAoY,EAAchN,EAAQ,EAAG,EAAG,CAAC,CAAC,QAASzL,EAAM4L,KAC7C6M,EAAchN,EAAQA,EAAO/O,OAAQ,EAAG,CAAC,CAAC,OAAQsD,EAAM4L,KACjDH,IAbLwX,EAA2B,CAC7B7N,SA0CF,SAAiCC,EAASC,EAAIC,GAC5C,IAAIqB,EAAOtJ,KACX,OAAO4P,EAAa7H,GAEpB,SAAS6N,EAAYljB,GACnB,GAAIkV,EAAmBlV,GAIrB,OAHAqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cACNsU,EAAa7H,EAAS6N,EAAa,aAAc,GAG1D,OAAOxH,EAAW9E,EAAKnL,OAAQ,cAAgB,EAAI8J,EAAIvV,GAAQsV,EAAGtV,KAV1B,aAAc,IA3CxD4V,SAAS,GAyDX7Z,EAAOC,QAAUwK,G,mCCxEjB,IAAI0O,EAAqB,EAAQ,OAE7BzO,EAAW,CACbrI,KAAM,WACNgX,SAwDF,SAA0BC,EAASC,EAAIC,GACrC,IACI7V,EACA2N,EAFAmV,EAAW,EAGf,OAEA,SAAexiB,GAGb,OAFAqV,EAAQ9P,MAAM,YACd8P,EAAQ9P,MAAM,oBACP6b,EAAgBphB,IAGzB,SAASohB,EAAgBphB,GACvB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GAChBwiB,IACOpB,IAGT/L,EAAQzM,KAAK,oBACNua,EAAInjB,IAGb,SAASmjB,EAAInjB,GAEX,OAAa,OAATA,EACKuV,EAAIvV,GAKA,KAATA,GACFqN,EAAQgI,EAAQ9P,MAAM,oBACtB7F,EAAO,EACA2hB,EAAgBrhB,IAIZ,KAATA,GACFqV,EAAQ9P,MAAM,SACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,SACNua,GAGLjO,EAAmBlV,IACrBqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cACNua,IAIT9N,EAAQ9P,MAAM,gBACPoB,EAAK3G,IAId,SAAS2G,EAAK3G,GACZ,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAekV,EAAmBlV,IACpEqV,EAAQzM,KAAK,gBACNua,EAAInjB,KAGbqV,EAAQG,QAAQxV,GACT2G,GAIT,SAAS0a,EAAgBrhB,GAEvB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GAChBN,IACO2hB,GAIL3hB,IAAS8iB,GACXnN,EAAQzM,KAAK,oBACbyM,EAAQzM,KAAK,YACN0M,EAAGtV,KAIZqN,EAAM9K,KAAO,eACNoE,EAAK3G,MA7Id6a,QAIF,SAAyBpP,GACvB,IAEIrP,EACAmJ,EAHA6d,EAAgB3X,EAAO/O,OAAS,EAChC2mB,EAAiB,EAIrB,KAAwC,eAAnC5X,EAAO4X,GAAgB,GAAG9gB,MAA4D,UAAnCkJ,EAAO4X,GAAgB,GAAG9gB,MAAwD,eAAlCkJ,EAAO2X,GAAe,GAAG7gB,MAA2D,UAAlCkJ,EAAO2X,GAAe,GAAG7gB,MAGjL,IAFAnG,EAAQinB,IAECjnB,EAAQgnB,GACf,GAA8B,iBAA1B3X,EAAOrP,GAAO,GAAGmG,KAAyB,CAE5CkJ,EAAO2X,GAAe,GAAG7gB,KAAOkJ,EAAO4X,GAAgB,GAAG9gB,KAAO,kBACjE8gB,GAAkB,EAClBD,GAAiB,EACjB,MAMNhnB,EAAQinB,EAAiB,EACzBD,IAEA,OAAShnB,GAASgnB,QACF/hB,IAAVkE,EACEnJ,IAAUgnB,GAA2C,eAA1B3X,EAAOrP,GAAO,GAAGmG,OAC9CgD,EAAQnJ,GAEDA,IAAUgnB,GAA2C,eAA1B3X,EAAOrP,GAAO,GAAGmG,OACrDkJ,EAAOlG,GAAO,GAAGhD,KAAO,eAEpBnG,IAAUmJ,EAAQ,IACpBkG,EAAOlG,GAAO,GAAGlF,IAAMoL,EAAOrP,EAAQ,GAAG,GAAGiE,IAC5CoL,EAAO7J,OAAO2D,EAAQ,EAAGnJ,EAAQmJ,EAAQ,GACzC6d,GAAiBhnB,EAAQmJ,EAAQ,EACjCnJ,EAAQmJ,EAAQ,GAGlBA,OAAQlE,GAIZ,OAAOoK,GA9CPoE,SAiDF,SAAkB7P,GAEhB,OAAgB,KAATA,GAA+D,oBAAhDsN,KAAK7B,OAAO6B,KAAK7B,OAAO/O,OAAS,GAAG,GAAG6F,OA6F/DxG,EAAOC,QAAUyK,G,mCCtJjB,IAAIyO,EAAqB,EAAQ,OAE7BwG,EAAa,EAAQ,MAErBmF,EAAc,EAAQ,OAEtB3D,EAAe,EAAQ,OAGvBjC,EAAU,CACZ7F,SAgBF,SAAyBC,EAASC,GAChC,IAAIzF,EACJ,OAEA,SAAe7P,GAKb,OAJAqV,EAAQ9P,MAAM,WACdsK,EAAWwF,EAAQ9P,MAAM,eAAgB,CACvC8V,YAAa,YAER1U,EAAK3G,IAGd,SAAS2G,EAAK3G,GACZ,OAAa,OAATA,EACKmb,EAAWnb,GAGhBkV,EAAmBlV,GACdqV,EAAQU,MAAMuN,EAAuBN,EAAiB7H,EAAtD9F,CAAkErV,IAI3EqV,EAAQG,QAAQxV,GACT2G,GAGT,SAASwU,EAAWnb,GAGlB,OAFAqV,EAAQzM,KAAK,gBACbyM,EAAQzM,KAAK,WACN0M,EAAGtV,GAGZ,SAASgjB,EAAgBhjB,GAOvB,OANAqV,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,gBACbiH,EAAWA,EAASuN,KAAO/H,EAAQ9P,MAAM,eAAgB,CACvD8V,YAAa,UACbxL,SAAUA,IAELlJ,IAtDTkU,QAUF,SAAwBpP,GAEtB,OADAoV,EAAYpV,GACLA,GAXP6P,eAAe,EACfmD,MAAM,GAEJ6E,EAAwB,CAC1BlO,SAqDF,SAA8BC,EAASC,EAAIC,GACzC,IAAIqB,EAAOtJ,KACX,OAEA,SAAwBtN,GAItB,OAHAqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cACNsU,EAAa7H,EAASkO,EAAU,eAGzC,SAASA,EAASvjB,GAChB,OAAa,OAATA,GAAiBkV,EAAmBlV,GAC/BuV,EAAIvV,GAGT4W,EAAKhI,OAAO8J,WAAWuE,QAAQrE,KAAKnc,QAAQ,iBAAmB,GAAKif,EAAW9E,EAAKnL,OAAQ,cAAgB,EACvG4J,EAAQgJ,UAAUzH,EAAKhI,OAAO8J,WAAWxE,KAAMqB,EAAKD,EAApDD,CAAwDrV,GAG1DsV,EAAGtV,KAxEZ4V,SAAS,GA4EX7Z,EAAOC,QAAUif,G,mCC7FjB,IAAI/F,EAAqB,EAAQ,OAE7BsG,EAA4B,EAAQ,OAEpC5N,EAAsB,EAAQ,MAE9B4V,EAAqB,EAAQ,OAE7BC,EAAe,EAAQ,OAEvBvG,EAAe,EAAQ,OAEvBwG,EAAoB,EAAQ,OAE5BC,EAAe,EAAQ,OAEvB9c,EAAa,CACfzI,KAAM,aACNgX,SAOF,SAA4BC,EAASC,EAAIC,GACvC,IACI5H,EADAiJ,EAAOtJ,KAEX,OAEA,SAAetN,GAEb,OADAqV,EAAQ9P,MAAM,cACPke,EAAa/lB,KAAKkZ,EAAMvB,EAASuO,EAAYrO,EAAK,kBAAmB,wBAAyB,wBAA9FkO,CAAuHzjB,IAGhI,SAAS4jB,EAAW5jB,GAGlB,OAFA2N,EAAaC,EAAoBgJ,EAAKzK,eAAeyK,EAAKnL,OAAOmL,EAAKnL,OAAO/O,OAAS,GAAG,IAAIyH,MAAM,GAAI,IAE1F,KAATnE,GACFqV,EAAQ9P,MAAM,oBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,oBAEN8a,EAAkBrO,EAASmO,EAAmBnO,EAASA,EAAQyB,QAAQ+M,EAAgB3G,EAAa7H,EAAStV,EAAO,cAAemd,EAAa7H,EAAStV,EAAO,eAAgBwV,EAAK,wBAAyB,+BAAgC,qCAAsC,2BAA4B,iCAGlTA,EAAIvV,GAGb,SAASD,EAAMC,GACb,OAAa,OAATA,GAAiBkV,EAAmBlV,IACtCqV,EAAQzM,KAAK,cAETgO,EAAKhI,OAAO8R,QAAQjkB,QAAQkR,GAAc,GAC5CiJ,EAAKhI,OAAO8R,QAAQpf,KAAKqM,GAGpB2H,EAAGtV,IAGLuV,EAAIvV,MAxCX6jB,EAAiB,CACnBzO,SA2CF,SAAuBC,EAASC,EAAIC,GAClC,OAEA,SAAevV,GACb,OAAOwb,EAA0Bxb,GAAQ0jB,EAAkBrO,EAASvV,EAA3B4jB,CAAmC1jB,GAAQuV,EAAIvV,IAG1F,SAASF,EAAOE,GACd,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzB2jB,EAAatO,EAAS6H,EAAa7H,EAAStV,EAAO,cAAewV,EAAK,kBAAmB,wBAAyB,wBAAnHoO,CAA4I3jB,GAG9IuV,EAAIvV,GAGb,SAASD,EAAMC,GACb,OAAgB,OAATA,GAAiBkV,EAAmBlV,GAAQsV,EAAGtV,GAAQuV,EAAIvV,KA1DpE4V,SAAS,GA8DX7Z,EAAOC,QAAU6K,G,mCCpFjB,IAAIoO,EAAe,EAAQ,OAEvBuG,EAA4B,EAAQ,OAEpCtG,EAAqB,EAAQ,OAoHjCnZ,EAAOC,QAjHP,SAA4BqZ,EAASC,EAAIC,EAAKhT,EAAMuhB,EAAaC,EAAmBC,EAASC,EAAYtiB,GACvG,IAAIuiB,EAAQviB,GAAOwiB,IACf/N,EAAU,EACd,OAEA,SAAepW,GACb,GAAa,KAATA,EAMF,OALAqV,EAAQ9P,MAAMhD,GACd8S,EAAQ9P,MAAMue,GACdzO,EAAQ9P,MAAMwe,GACd1O,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAKmb,GACNK,EAGT,GAAInP,EAAajV,IAAkB,KAATA,EACxB,OAAOuV,EAAIvV,GASb,OANAqV,EAAQ9P,MAAMhD,GACd8S,EAAQ9P,MAAMye,GACd3O,EAAQ9P,MAAM0e,GACd5O,EAAQ9P,MAAM,cAAe,CAC3B8V,YAAa,WAERgJ,EAAerkB,IAGxB,SAASokB,EAA0BpkB,GACjC,OAAa,KAATA,GACFqV,EAAQ9P,MAAMwe,GACd1O,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAKmb,GACb1O,EAAQzM,KAAKkb,GACbzO,EAAQzM,KAAKrG,GACN+S,IAGTD,EAAQ9P,MAAM0e,GACd5O,EAAQ9P,MAAM,cAAe,CAC3B8V,YAAa,WAERiJ,EAAoBtkB,IAG7B,SAASskB,EAAoBtkB,GAC3B,OAAa,KAATA,GACFqV,EAAQzM,KAAK,eACbyM,EAAQzM,KAAKqb,GACNG,EAA0BpkB,IAGtB,OAATA,GAA0B,KAATA,GAAekV,EAAmBlV,GAC9CuV,EAAIvV,IAGbqV,EAAQG,QAAQxV,GACA,KAATA,EAAcukB,EAA4BD,GAGnD,SAASC,EAA0BvkB,GACjC,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCqV,EAAQG,QAAQxV,GACTskB,GAGFA,EAAoBtkB,GAG7B,SAASqkB,EAAerkB,GACtB,OAAa,KAATA,IACIoW,EAAU8N,EAAc3O,EAAIvV,IAClCqV,EAAQG,QAAQxV,GACTqkB,GAGI,KAATrkB,EACGoW,KAQLf,EAAQG,QAAQxV,GACTqkB,IARLhP,EAAQzM,KAAK,eACbyM,EAAQzM,KAAKqb,GACb5O,EAAQzM,KAAKob,GACb3O,EAAQzM,KAAKrG,GACN+S,EAAGtV,IAOD,OAATA,GAAiBwb,EAA0Bxb,GACzCoW,EAAgBb,EAAIvV,IACxBqV,EAAQzM,KAAK,eACbyM,EAAQzM,KAAKqb,GACb5O,EAAQzM,KAAKob,GACb3O,EAAQzM,KAAKrG,GACN+S,EAAGtV,IAGRiV,EAAajV,GAAcuV,EAAIvV,IACnCqV,EAAQG,QAAQxV,GACA,KAATA,EAAcwkB,EAAuBH,GAG9C,SAASG,EAAqBxkB,GAC5B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCqV,EAAQG,QAAQxV,GACTqkB,GAGFA,EAAerkB,M,mCCpH1B,IAAIkV,EAAqB,EAAQ,OAE7B4M,EAAgB,EAAQ,OAyE5B/lB,EAAOC,QAtEP,SAAsBqZ,EAASC,EAAIC,EAAKhT,EAAMkiB,EAAYR,GACxD,IAEItd,EAFAiQ,EAAOtJ,KACP5N,EAAO,EAEX,OAEA,SAAeM,GAMb,OALAqV,EAAQ9P,MAAMhD,GACd8S,EAAQ9P,MAAMkf,GACdpP,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK6b,GACbpP,EAAQ9P,MAAM0e,GACP/R,GAGT,SAASA,EAAQlS,GACf,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,IAAgB2G,GAE3C,KAAT3G,IAECN,GAED,2BAA4BkX,EAAKhI,OAAO8J,YAAchZ,EAAO,IACpD6V,EAAIvV,GAGA,KAATA,GACFqV,EAAQzM,KAAKqb,GACb5O,EAAQ9P,MAAMkf,GACdpP,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK6b,GACbpP,EAAQzM,KAAKrG,GACN+S,GAGLJ,EAAmBlV,IACrBqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cACNsJ,IAGTmD,EAAQ9P,MAAM,cAAe,CAC3B8V,YAAa,WAER1T,EAAM3H,IAGf,SAAS2H,EAAM3H,GACb,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAekV,EAAmBlV,IAASN,IAAS,KACtF2V,EAAQzM,KAAK,eACNsJ,EAAQlS,KAGjBqV,EAAQG,QAAQxV,GAChB2G,EAAOA,IAASmb,EAAc9hB,GACd,KAATA,EAAc0kB,EAAc/c,GAGrC,SAAS+c,EAAY1kB,GACnB,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCqV,EAAQG,QAAQxV,GAChBN,IACOiI,GAGFA,EAAM3H,M,mCCvEjB,IAAI8hB,EAAgB,EAAQ,OA2B5B/lB,EAAOC,QAzBP,SAAsBqZ,EAASC,EAAI/S,EAAMZ,GACvC,IAAIuiB,EAAQviB,EAAMA,EAAM,EAAIwiB,IACxBzkB,EAAO,EACX,OAEA,SAAeM,GACb,GAAI8hB,EAAc9hB,GAEhB,OADAqV,EAAQ9P,MAAMhD,GACPqN,EAAO5P,GAGhB,OAAOsV,EAAGtV,IAGZ,SAAS4P,EAAO5P,GACd,OAAI8hB,EAAc9hB,IAASN,IAASwkB,GAClC7O,EAAQG,QAAQxV,GACT4P,IAGTyF,EAAQzM,KAAKrG,GACN+S,EAAGtV,O,mCCvBd,IAAIkV,EAAqB,EAAQ,OAE7BgI,EAAe,EAAQ,OAwE3BnhB,EAAOC,QAtEP,SAAsBqZ,EAASC,EAAIC,EAAKhT,EAAMkiB,EAAYR,GACxD,IAAI7P,EACJ,OAEA,SAAepU,GAMb,OALAqV,EAAQ9P,MAAMhD,GACd8S,EAAQ9P,MAAMkf,GACdpP,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK6b,GACbrQ,EAAkB,KAATpU,EAAc,GAAKA,EACrB2kB,GAGT,SAASA,EAAkB3kB,GACzB,OAAIA,IAASoU,GACXiB,EAAQ9P,MAAMkf,GACdpP,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK6b,GACbpP,EAAQzM,KAAKrG,GACN+S,IAGTD,EAAQ9P,MAAM0e,GACPW,EAAa5kB,IAGtB,SAAS4kB,EAAa5kB,GACpB,OAAIA,IAASoU,GACXiB,EAAQzM,KAAKqb,GACNU,EAAkBvQ,IAGd,OAATpU,EACKuV,EAAIvV,GAITkV,EAAmBlV,IACrBqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cACNsU,EAAa7H,EAASuP,EAAc,gBAG7CvP,EAAQ9P,MAAM,cAAe,CAC3B8V,YAAa,WAERvN,EAAM9N,IAGf,SAAS8N,EAAM9N,GACb,OAAIA,IAASoU,GAAmB,OAATpU,GAAiBkV,EAAmBlV,IACzDqV,EAAQzM,KAAK,eACNgc,EAAa5kB,KAGtBqV,EAAQG,QAAQxV,GACA,KAATA,EAAc6kB,EAAc/W,GAGrC,SAAS+W,EAAY7kB,GACnB,OAAIA,IAASoU,GAAmB,KAATpU,GACrBqV,EAAQG,QAAQxV,GACT8N,GAGFA,EAAM9N,M,mCCtEjB,IAAIkV,EAAqB,EAAQ,OAE7B4M,EAAgB,EAAQ,OAExB5E,EAAe,EAAQ,OAuB3BnhB,EAAOC,QArBP,SAA2BqZ,EAASC,GAClC,IAAIwP,EACJ,OAEA,SAAS3kB,EAAMH,GACb,GAAIkV,EAAmBlV,GAKrB,OAJAqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cACbkc,GAAO,EACA3kB,EAGT,GAAI2hB,EAAc9hB,GAChB,OAAOkd,EAAa7H,EAASlV,EAAO2kB,EAAO,aAAe,aAAnD5H,CAAiEld,GAG1E,OAAOsV,EAAGtV,M,mCCvBd,IAAIkV,EAAqB,EAAQ,OAE7BhO,EAAkB,CACpB9I,KAAM,kBACNgX,SAGF,SAAiCC,EAASC,EAAIC,GAC5C,OAEA,SAAevV,GAIb,OAHAqV,EAAQ9P,MAAM,mBACd8P,EAAQ9P,MAAM,gBACd8P,EAAQG,QAAQxV,GACToN,GAGT,SAASA,EAAKpN,GACZ,OAAIkV,EAAmBlV,IACrBqV,EAAQzM,KAAK,gBACbyM,EAAQzM,KAAK,mBACN0M,EAAGtV,IAGLuV,EAAIvV,MAIfjE,EAAOC,QAAUkL,G,mCC5BjB,IAAIgO,EAAqB,EAAQ,OAE7BsG,EAA4B,EAAQ,OAEpCsG,EAAgB,EAAQ,OAExBrJ,EAAgB,EAAQ,MAExByE,EAAe,EAAQ,OAEvBT,EAAa,CACfre,KAAM,aACNgX,SAyCF,SAA4BC,EAASC,EAAIC,GACvC,IAAIqB,EAAOtJ,KACP5N,EAAO,EACX,OAEA,SAAeM,GAGb,OAFAqV,EAAQ9P,MAAM,cACd8P,EAAQ9P,MAAM,sBACPwf,EAAgB/kB,IAGzB,SAAS+kB,EAAgB/kB,GACvB,OAAa,KAATA,GAAeN,IAAS,GAC1B2V,EAAQG,QAAQxV,GACT+kB,GAGI,OAAT/kB,GAAiBwb,EAA0Bxb,IAC7CqV,EAAQzM,KAAK,sBACNgO,EAAKyH,UAAY/I,EAAGtV,GAAQglB,EAAahlB,IAG3CuV,EAAIvV,GAGb,SAASglB,EAAahlB,GACpB,OAAa,KAATA,GACFqV,EAAQ9P,MAAM,sBACPkO,EAASzT,IAGL,OAATA,GAAiBkV,EAAmBlV,IACtCqV,EAAQzM,KAAK,cACN0M,EAAGtV,IAGR8hB,EAAc9hB,GACTkd,EAAa7H,EAAS2P,EAAc,aAApC9H,CAAkDld,IAG3DqV,EAAQ9P,MAAM,kBACPoB,EAAK3G,IAGd,SAASyT,EAASzT,GAChB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTyT,IAGT4B,EAAQzM,KAAK,sBACNoc,EAAahlB,IAGtB,SAAS2G,EAAK3G,GACZ,OAAa,OAATA,GAA0B,KAATA,GAAewb,EAA0Bxb,IAC5DqV,EAAQzM,KAAK,kBACNoc,EAAahlB,KAGtBqV,EAAQG,QAAQxV,GACT2G,KArGTkU,QAGF,SAA2BpP,EAAQG,GACjC,IAEIqP,EACA/M,EAHAiN,EAAa1P,EAAO/O,OAAS,EAC7Bwe,EAAe,EAIkB,eAAjCzP,EAAOyP,GAAc,GAAG3Y,OAC1B2Y,GAAgB,GAIdC,EAAa,EAAID,GAA+C,eAA/BzP,EAAO0P,GAAY,GAAG5Y,OACzD4Y,GAAc,GAGmB,uBAA/B1P,EAAO0P,GAAY,GAAG5Y,OAAkC2Y,IAAiBC,EAAa,GAAKA,EAAa,EAAID,GAAmD,eAAnCzP,EAAO0P,EAAa,GAAG,GAAG5Y,QACxJ4Y,GAAcD,EAAe,IAAMC,EAAa,EAAI,GAGlDA,EAAaD,IACfD,EAAU,CACR1Y,KAAM,iBACNpC,MAAOsL,EAAOyP,GAAc,GAAG/a,MAC/BE,IAAKoL,EAAO0P,GAAY,GAAG9a,KAE7B6N,EAAO,CACL3L,KAAM,YACNpC,MAAOsL,EAAOyP,GAAc,GAAG/a,MAC/BE,IAAKoL,EAAO0P,GAAY,GAAG9a,IAC3Bgb,YAAa,QAEf5C,EAAchN,EAAQyP,EAAcC,EAAaD,EAAe,EAAG,CAAC,CAAC,QAASD,EAASrP,GAAU,CAAC,QAASsC,EAAMtC,GAAU,CAAC,OAAQsC,EAAMtC,GAAU,CAAC,OAAQqP,EAASrP,MAGxK,OAAOH,IAoET1P,EAAOC,QAAUygB,G,mCCtHjB,IAAI1H,EAAa,EAAQ,MAErBC,EAAoB,EAAQ,OAE5BE,EAAqB,EAAQ,OAE7BsG,EAA4B,EAAQ,OAEpCsG,EAAgB,EAAQ,OAExBxF,EAAe,EAAQ,OAEvB2I,EAAiB,EAAQ,OAEzBC,EAAe,EAAQ,OAEvB7H,EAAmB,EAAQ,OAE3BhW,EAAW,CACbjJ,KAAM,WACNgX,SA8BF,SAA0BC,EAASC,EAAIC,GACrC,IACI4P,EACAC,EACA9e,EACAlK,EACAgY,EALAwC,EAAOtJ,KAMX,OAEA,SAAetN,GAIb,OAHAqV,EAAQ9P,MAAM,YACd8P,EAAQ9P,MAAM,gBACd8P,EAAQG,QAAQxV,GACToN,GAGT,SAASA,EAAKpN,GACZ,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTqlB,GAGI,KAATrlB,GACFqV,EAAQG,QAAQxV,GACTslB,GAGI,KAATtlB,GACFqV,EAAQG,QAAQxV,GAChBmlB,EAAO,EAGAvO,EAAKyH,UAAY/I,EAAKiQ,GAG3BxQ,EAAW/U,IACbqV,EAAQG,QAAQxV,GAChBsG,EAASgW,EAAatc,GACtBolB,GAAW,EACJI,GAGFjQ,EAAIvV,GAGb,SAASqlB,EAAiBrlB,GACxB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GAChBmlB,EAAO,EACAM,GAGI,KAATzlB,GACFqV,EAAQG,QAAQxV,GAChBmlB,EAAO,EACP7e,EAAS,SACTlK,EAAQ,EACDspB,GAGL3Q,EAAW/U,IACbqV,EAAQG,QAAQxV,GAChBmlB,EAAO,EACAvO,EAAKyH,UAAY/I,EAAKiQ,GAGxBhQ,EAAIvV,GAGb,SAASylB,EAAkBzlB,GACzB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACT4W,EAAKyH,UAAY/I,EAAKiQ,GAGxBhQ,EAAIvV,GAGb,SAAS0lB,EAAgB1lB,GACvB,OAAIA,IAASsG,EAAOtE,WAAW5F,MAC7BiZ,EAAQG,QAAQxV,GACT5D,IAAUkK,EAAO5J,OAASka,EAAKyH,UAAY/I,EAAKwI,EAAe4H,GAGjEnQ,EAAIvV,GAGb,SAASslB,EAActlB,GACrB,OAAI+U,EAAW/U,IACbqV,EAAQG,QAAQxV,GAChBsG,EAASgW,EAAatc,GACfwlB,GAGFjQ,EAAIvV,GAGb,SAASwlB,EAAQxlB,GACf,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAewb,EAA0Bxb,GAC9D,KAATA,GAAeolB,GAAYF,EAAazoB,QAAQ6J,EAAOuH,gBAAkB,GAC3EsX,EAAO,EACAvO,EAAKyH,UAAY/I,EAAGtV,GAAQ8d,EAAa9d,IAG9CilB,EAAexoB,QAAQ6J,EAAOuH,gBAAkB,GAClDsX,EAAO,EAEM,KAATnlB,GACFqV,EAAQG,QAAQxV,GACT2lB,GAGF/O,EAAKyH,UAAY/I,EAAGtV,GAAQ8d,EAAa9d,KAGlDmlB,EAAO,EAEAvO,EAAKyH,UAAY9I,EAAIvV,GAAQolB,EAAWQ,EAA4B5lB,GAAQ6lB,EAAwB7lB,IAGhG,KAATA,GAAegV,EAAkBhV,IACnCqV,EAAQG,QAAQxV,GAChBsG,GAAUgW,EAAatc,GAChBwlB,GAGFjQ,EAAIvV,GAGb,SAAS2lB,EAAiB3lB,GACxB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACT4W,EAAKyH,UAAY/I,EAAKwI,GAGxBvI,EAAIvV,GAGb,SAAS6lB,EAAwB7lB,GAC/B,OAAI8hB,EAAc9hB,IAChBqV,EAAQG,QAAQxV,GACT6lB,GAGFC,EAAY9lB,GAGrB,SAAS4lB,EAA4B5lB,GACnC,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACT8lB,GAGI,KAAT9lB,GAAwB,KAATA,GAAe+U,EAAW/U,IAC3CqV,EAAQG,QAAQxV,GACT+lB,GAGLjE,EAAc9hB,IAChBqV,EAAQG,QAAQxV,GACT4lB,GAGFE,EAAY9lB,GAGrB,SAAS+lB,EAAsB/lB,GAC7B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAegV,EAAkBhV,IAChFqV,EAAQG,QAAQxV,GACT+lB,GAGFC,EAA2BhmB,GAGpC,SAASgmB,EAA2BhmB,GAClC,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTimB,GAGLnE,EAAc9hB,IAChBqV,EAAQG,QAAQxV,GACTgmB,GAGFJ,EAA4B5lB,GAGrC,SAASimB,EAA6BjmB,GACpC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzDuV,EAAIvV,GAGA,KAATA,GAAwB,KAATA,GACjBqV,EAAQG,QAAQxV,GAChBoU,EAASpU,EACFkmB,GAGLpE,EAAc9hB,IAChBqV,EAAQG,QAAQxV,GACTimB,IAGT7R,OAAS/S,EACF8kB,EAA+BnmB,IAGxC,SAASkmB,EAA6BlmB,GACpC,OAAIA,IAASoU,GACXiB,EAAQG,QAAQxV,GACTomB,GAGI,OAATpmB,GAAiBkV,EAAmBlV,GAC/BuV,EAAIvV,IAGbqV,EAAQG,QAAQxV,GACTkmB,GAGT,SAASC,EAA+BnmB,GACtC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAewb,EAA0Bxb,GAChIgmB,EAA2BhmB,IAGpCqV,EAAQG,QAAQxV,GACTmmB,GAGT,SAASC,EAAkCpmB,GACzC,OAAa,KAATA,GAAwB,KAATA,GAAe8hB,EAAc9hB,GACvC4lB,EAA4B5lB,GAG9BuV,EAAIvV,GAGb,SAAS8lB,EAAY9lB,GACnB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTqmB,GAGF9Q,EAAIvV,GAGb,SAASqmB,EAAcrmB,GACrB,OAAI8hB,EAAc9hB,IAChBqV,EAAQG,QAAQxV,GACTqmB,GAGO,OAATrmB,GAAiBkV,EAAmBlV,GAAQ8d,EAAa9d,GAAQuV,EAAIvV,GAG9E,SAAS8d,EAAa9d,GACpB,OAAa,KAATA,GAAwB,IAATmlB,GACjB9P,EAAQG,QAAQxV,GACTsmB,GAGI,KAATtmB,GAAwB,IAATmlB,GACjB9P,EAAQG,QAAQxV,GACTumB,GAGI,KAATvmB,GAAwB,IAATmlB,GACjB9P,EAAQG,QAAQxV,GACTwmB,GAGI,KAATxmB,GAAwB,IAATmlB,GACjB9P,EAAQG,QAAQxV,GACTulB,GAGI,KAATvlB,GAAwB,IAATmlB,GACjB9P,EAAQG,QAAQxV,GACTymB,IAGLvR,EAAmBlV,IAAmB,IAATmlB,GAAuB,IAATA,EAIlC,OAATnlB,GAAiBkV,EAAmBlV,GAC/B0mB,EAAyB1mB,IAGlCqV,EAAQG,QAAQxV,GACT8d,GAREzI,EAAQU,MAAM4Q,EAAoBH,EAAmBE,EAArDrR,CAA+ErV,GAW1F,SAAS0mB,EAAyB1mB,GAEhC,OADAqV,EAAQzM,KAAK,gBACNge,EAAkB5mB,GAG3B,SAAS4mB,EAAkB5mB,GACzB,OAAa,OAATA,EACKiW,EAAKjW,GAGVkV,EAAmBlV,IACrBqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cACNge,IAGTvR,EAAQ9P,MAAM,gBACPuY,EAAa9d,IAGtB,SAASsmB,EAA0BtmB,GACjC,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTulB,GAGFzH,EAAa9d,GAGtB,SAASumB,EAAuBvmB,GAC9B,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GAChBsG,EAAS,GACFugB,GAGF/I,EAAa9d,GAGtB,SAAS6mB,EAAsB7mB,GAC7B,OAAa,KAATA,GAAeklB,EAAazoB,QAAQ6J,EAAOuH,gBAAkB,GAC/DwH,EAAQG,QAAQxV,GACTwmB,GAGLzR,EAAW/U,IAASsG,EAAO5J,OAAS,GACtC2Y,EAAQG,QAAQxV,GAChBsG,GAAUgW,EAAatc,GAChB6mB,GAGF/I,EAAa9d,GAGtB,SAASymB,EAAgCzmB,GACvC,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTulB,GAGFzH,EAAa9d,GAGtB,SAASulB,EAA8BvlB,GACrC,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTwmB,GAGF1I,EAAa9d,GAGtB,SAASwmB,EAAkBxmB,GACzB,OAAa,OAATA,GAAiBkV,EAAmBlV,IACtCqV,EAAQzM,KAAK,gBACNqN,EAAKjW,KAGdqV,EAAQG,QAAQxV,GACTwmB,GAGT,SAASvQ,EAAKjW,GAEZ,OADAqV,EAAQzM,KAAK,YACN0M,EAAGtV,KA1ZZ8mB,UAQF,SAA2Brb,GACzB,IAAIrP,EAAQqP,EAAO/O,OAEnB,KAAON,MACoB,UAArBqP,EAAOrP,GAAO,IAA4C,aAA1BqP,EAAOrP,GAAO,GAAGmG,QAKnDnG,EAAQ,GAAmC,eAA9BqP,EAAOrP,EAAQ,GAAG,GAAGmG,OAEpCkJ,EAAOrP,GAAO,GAAG+D,MAAQsL,EAAOrP,EAAQ,GAAG,GAAG+D,MAE9CsL,EAAOrP,EAAQ,GAAG,GAAG+D,MAAQsL,EAAOrP,EAAQ,GAAG,GAAG+D,MAElDsL,EAAO7J,OAAOxF,EAAQ,EAAG,IAG3B,OAAOqP,GAzBPyS,UAAU,GAERyI,EAAqB,CACvBvR,SA0ZF,SAA2BC,EAASC,EAAIC,GACtC,OAEA,SAAevV,GAKb,OAJAqV,EAAQzM,KAAK,gBACbyM,EAAQ9P,MAAM,mBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,mBACNyM,EAAQyB,QAAQuG,EAAkB/H,EAAIC,KAja/CK,SAAS,GAqaX7Z,EAAOC,QAAUqL,G,mCC/bjB,IAAI0N,EAAa,EAAQ,MAErBC,EAAoB,EAAQ,OAE5BE,EAAqB,EAAQ,OAE7BsG,EAA4B,EAAQ,OAEpCsG,EAAgB,EAAQ,OAExB5E,EAAe,EAAQ,OAEvB1V,EAAW,CACbpJ,KAAM,WACNgX,SAGF,SAA0BC,EAASC,EAAIC,GACrC,IACInB,EACA9N,EACAlK,EACA2qB,EAJAnQ,EAAOtJ,KAKX,OAEA,SAAetN,GAIb,OAHAqV,EAAQ9P,MAAM,YACd8P,EAAQ9P,MAAM,gBACd8P,EAAQG,QAAQxV,GACToN,GAGT,SAASA,EAAKpN,GACZ,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTgnB,GAGI,KAAThnB,GACFqV,EAAQG,QAAQxV,GACTslB,GAGI,KAATtlB,GACFqV,EAAQG,QAAQxV,GACTinB,GAGLlS,EAAW/U,IACbqV,EAAQG,QAAQxV,GACTknB,GAGF3R,EAAIvV,GAGb,SAASgnB,EAAgBhnB,GACvB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTmnB,GAGI,KAATnnB,GACFqV,EAAQG,QAAQxV,GAChBsG,EAAS,SACTlK,EAAQ,EACDgrB,GAGLrS,EAAW/U,IACbqV,EAAQG,QAAQxV,GACTqnB,GAGF9R,EAAIvV,GAGb,SAASmnB,EAAYnnB,GACnB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTsnB,GAGF/R,EAAIvV,GAGb,SAASsnB,EAAatnB,GACpB,OAAa,OAATA,GAA0B,KAATA,EACZuV,EAAIvV,GAGA,KAATA,GACFqV,EAAQG,QAAQxV,GACTunB,GAGFC,EAAQxnB,GAGjB,SAASunB,EAAiBvnB,GACxB,OAAa,OAATA,GAA0B,KAATA,EACZuV,EAAIvV,GAGNwnB,EAAQxnB,GAGjB,SAASwnB,EAAQxnB,GACf,OAAa,OAATA,EACKuV,EAAIvV,GAGA,KAATA,GACFqV,EAAQG,QAAQxV,GACTynB,GAGLvS,EAAmBlV,IACrB+mB,EAAcS,EACPE,EAAa1nB,KAGtBqV,EAAQG,QAAQxV,GACTwnB,GAGT,SAASC,EAAaznB,GACpB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTK,GAGFmnB,EAAQxnB,GAGjB,SAASonB,EAAUpnB,GACjB,OAAIA,IAASsG,EAAOtE,WAAW5F,MAC7BiZ,EAAQG,QAAQxV,GACT5D,IAAUkK,EAAO5J,OAASirB,EAAQP,GAGpC7R,EAAIvV,GAGb,SAAS2nB,EAAM3nB,GACb,OAAa,OAATA,EACKuV,EAAIvV,GAGA,KAATA,GACFqV,EAAQG,QAAQxV,GACT4nB,GAGL1S,EAAmBlV,IACrB+mB,EAAcY,EACPD,EAAa1nB,KAGtBqV,EAAQG,QAAQxV,GACT2nB,GAGT,SAASC,EAAW5nB,GAClB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACT6nB,GAGFF,EAAM3nB,GAGf,SAAS6nB,EAAS7nB,GAChB,OAAa,KAATA,EACKK,EAAIL,GAGA,KAATA,GACFqV,EAAQG,QAAQxV,GACT6nB,GAGFF,EAAM3nB,GAGf,SAASqnB,EAAYrnB,GACnB,OAAa,OAATA,GAA0B,KAATA,EACZK,EAAIL,GAGTkV,EAAmBlV,IACrB+mB,EAAcM,EACPK,EAAa1nB,KAGtBqV,EAAQG,QAAQxV,GACTqnB,GAGT,SAASJ,EAAYjnB,GACnB,OAAa,OAATA,EACKuV,EAAIvV,GAGA,KAATA,GACFqV,EAAQG,QAAQxV,GACT8nB,GAGL5S,EAAmBlV,IACrB+mB,EAAcE,EACPS,EAAa1nB,KAGtBqV,EAAQG,QAAQxV,GACTinB,GAGT,SAASa,EAAiB9nB,GACxB,OAAgB,KAATA,EAAcK,EAAIL,GAAQinB,EAAYjnB,GAG/C,SAASslB,EAActlB,GACrB,OAAI+U,EAAW/U,IACbqV,EAAQG,QAAQxV,GACT+nB,GAGFxS,EAAIvV,GAGb,SAAS+nB,EAAS/nB,GAChB,OAAa,KAATA,GAAegV,EAAkBhV,IACnCqV,EAAQG,QAAQxV,GACT+nB,GAGFC,EAAgBhoB,GAGzB,SAASgoB,EAAgBhoB,GACvB,OAAIkV,EAAmBlV,IACrB+mB,EAAciB,EACPN,EAAa1nB,IAGlB8hB,EAAc9hB,IAChBqV,EAAQG,QAAQxV,GACTgoB,GAGF3nB,EAAIL,GAGb,SAASknB,EAAQlnB,GACf,OAAa,KAATA,GAAegV,EAAkBhV,IACnCqV,EAAQG,QAAQxV,GACTknB,GAGI,KAATlnB,GAAwB,KAATA,GAAewb,EAA0Bxb,GACnDioB,EAAejoB,GAGjBuV,EAAIvV,GAGb,SAASioB,EAAejoB,GACtB,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTK,GAGI,KAATL,GAAwB,KAATA,GAAe+U,EAAW/U,IAC3CqV,EAAQG,QAAQxV,GACTkoB,GAGLhT,EAAmBlV,IACrB+mB,EAAckB,EACPP,EAAa1nB,IAGlB8hB,EAAc9hB,IAChBqV,EAAQG,QAAQxV,GACTioB,GAGF5nB,EAAIL,GAGb,SAASkoB,EAAqBloB,GAC5B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAegV,EAAkBhV,IAChFqV,EAAQG,QAAQxV,GACTkoB,GAGFC,EAA0BnoB,GAGnC,SAASmoB,EAA0BnoB,GACjC,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GACTooB,GAGLlT,EAAmBlV,IACrB+mB,EAAcoB,EACPT,EAAa1nB,IAGlB8hB,EAAc9hB,IAChBqV,EAAQG,QAAQxV,GACTmoB,GAGFF,EAAejoB,GAGxB,SAASooB,EAA4BpoB,GACnC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzDuV,EAAIvV,GAGA,KAATA,GAAwB,KAATA,GACjBqV,EAAQG,QAAQxV,GAChBoU,EAASpU,EACFqoB,GAGLnT,EAAmBlV,IACrB+mB,EAAcqB,EACPV,EAAa1nB,IAGlB8hB,EAAc9hB,IAChBqV,EAAQG,QAAQxV,GACTooB,IAGT/S,EAAQG,QAAQxV,GAChBoU,OAAS/S,EACFinB,GAGT,SAASD,EAA4BroB,GACnC,OAAIA,IAASoU,GACXiB,EAAQG,QAAQxV,GACTuoB,GAGI,OAATvoB,EACKuV,EAAIvV,GAGTkV,EAAmBlV,IACrB+mB,EAAcsB,EACPX,EAAa1nB,KAGtBqV,EAAQG,QAAQxV,GACTqoB,GAGT,SAASE,EAAiCvoB,GACxC,OAAa,KAATA,GAAwB,KAATA,GAAewb,EAA0Bxb,GACnDioB,EAAejoB,GAGjBuV,EAAIvV,GAGb,SAASsoB,EAA8BtoB,GACrC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACxEuV,EAAIvV,GAGA,KAATA,GAAewb,EAA0Bxb,GACpCioB,EAAejoB,IAGxBqV,EAAQG,QAAQxV,GACTsoB,GAKT,SAASZ,EAAa1nB,GAKpB,OAJAqV,EAAQzM,KAAK,gBACbyM,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cACNsU,EAAa7H,EAAS6N,EAAa,aAActM,EAAKhI,OAAO8J,WAAWuE,QAAQrE,KAAKnc,QAAQ,iBAAmB,OAAI4E,EAAY,GAGzI,SAAS6hB,EAAYljB,GAEnB,OADAqV,EAAQ9P,MAAM,gBACPwhB,EAAY/mB,GAGrB,SAASK,EAAIL,GACX,OAAa,KAATA,GACFqV,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,gBACbyM,EAAQzM,KAAK,YACN0M,GAGFC,EAAIvV,MAIfjE,EAAOC,QAAUwL,G,mCC5ZjB,IAAIgU,EAA4B,EAAQ,OAEpCyF,EAAc,EAAQ,OAEtBxI,EAAgB,EAAQ,MAExB7K,EAAsB,EAAQ,MAE9B0K,EAAa,EAAQ,OAErBE,EAAU,EAAQ,OAElBgL,EAAqB,EAAQ,OAE7BC,EAAe,EAAQ,OAEvBE,EAAe,EAAQ,OAEvBD,EAAoB,EAAQ,OAE5BhH,EAAW,CACbte,KAAM,WACNgX,SAuGF,SAA0BC,EAASC,EAAIC,GACrC,IAEIiT,EACA9H,EAHA9J,EAAOtJ,KACPlR,EAAQwa,EAAKnL,OAAO/O,OAIxB,KAAON,KACL,IAAoC,eAA/Bwa,EAAKnL,OAAOrP,GAAO,GAAGmG,MAAwD,cAA/BqU,EAAKnL,OAAOrP,GAAO,GAAGmG,QAA0BqU,EAAKnL,OAAOrP,GAAO,GAAG0b,UAAW,CACnI0Q,EAAa5R,EAAKnL,OAAOrP,GAAO,GAChC,MAIJ,OAEA,SAAe4D,GACb,IAAKwoB,EACH,OAAOjT,EAAIvV,GAIb,OAAIwoB,EAAWC,UAAkBC,EAAS1oB,IAC1C0gB,EAAU9J,EAAKhI,OAAO8R,QAAQjkB,QAAQmR,EAAoBgJ,EAAKzK,eAAe,CAC5EhM,MAAOqoB,EAAWnoB,IAClBA,IAAKuW,EAAKsI,WACJ,EACR7J,EAAQ9P,MAAM,YACd8P,EAAQ9P,MAAM,eACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,eACbyM,EAAQzM,KAAK,YACN+f,IAGT,SAASA,EAAc3oB,GAErB,OAAa,KAATA,EACKqV,EAAQyB,QAAQ8R,EAAmBtT,EAAIoL,EAAUpL,EAAKoT,EAAtDrT,CAAgErV,GAI5D,KAATA,EACKqV,EAAQyB,QAAQ+R,EAAwBvT,EAAIoL,EAAUrL,EAAQyB,QAAQgS,EAA6BxT,EAAIoT,GAAYA,EAAnHrT,CAA6HrV,GAI/H0gB,EAAUpL,EAAGtV,GAAQ0oB,EAAS1oB,GAGvC,SAAS0oB,EAAS1oB,GAEhB,OADAwoB,EAAW1Q,WAAY,EAChBvC,EAAIvV,KAzJb8mB,UA+BF,SAA2Brb,EAAQG,GACjC,IAEIuV,EACAxZ,EACAuG,EACAb,EACAD,EACAG,EACAwb,EARA3sB,EAAQqP,EAAO/O,OACf6P,EAAS,EASb,KAAOnQ,KAGL,GAFAiR,EAAQ5B,EAAOrP,GAAO,GAElBgR,EAAM,CAER,GAAmB,SAAfC,EAAM9K,MAAkC,cAAf8K,EAAM9K,MAAwB8K,EAAMob,UAC/D,MAKuB,UAArBhd,EAAOrP,GAAO,IAAiC,cAAfiR,EAAM9K,OACxC8K,EAAMob,WAAY,QAEf,GAAIlb,GACT,GAAyB,UAArB9B,EAAOrP,GAAO,KAAkC,eAAfiR,EAAM9K,MAAwC,cAAf8K,EAAM9K,QAA0B8K,EAAMyK,YACxG1K,EAAOhR,EAEY,cAAfiR,EAAM9K,MAAsB,CAC9BgK,EAAS,EACT,WAGoB,aAAfc,EAAM9K,OACfgL,EAAQnR,GAiCZ,OA7BA+kB,EAAQ,CACN5e,KAA+B,cAAzBkJ,EAAO2B,GAAM,GAAG7K,KAAuB,OAAS,QACtDpC,MAAOqY,EAAQ/M,EAAO2B,GAAM,GAAGjN,OAC/BE,IAAKmY,EAAQ/M,EAAOA,EAAO/O,OAAS,GAAG,GAAG2D,MAE5CsH,EAAQ,CACNpF,KAAM,QACNpC,MAAOqY,EAAQ/M,EAAO2B,GAAM,GAAGjN,OAC/BE,IAAKmY,EAAQ/M,EAAO8B,GAAO,GAAGlN,MAEhC6N,EAAO,CACL3L,KAAM,YACNpC,MAAOqY,EAAQ/M,EAAO2B,EAAOb,EAAS,GAAG,GAAGlM,KAC5CA,IAAKmY,EAAQ/M,EAAO8B,EAAQ,GAAG,GAAGpN,QAIpC4oB,EAAQ9H,EAFR8H,EAAQ,CAAC,CAAC,QAAS5H,EAAOvV,GAAU,CAAC,QAASjE,EAAOiE,IAE1BH,EAAOtH,MAAMiJ,EAAO,EAAGA,EAAOb,EAAS,IAElEwc,EAAQ9H,EAAY8H,EAAO,CAAC,CAAC,QAAS7a,EAAMtC,KAE5Cmd,EAAQ9H,EAAY8H,EAAOzQ,EAAW1M,EAAQgD,OAAO8J,WAAWC,WAAWC,KAAMnN,EAAOtH,MAAMiJ,EAAOb,EAAS,EAAGgB,EAAQ,GAAI3B,IAE7Hmd,EAAQ9H,EAAY8H,EAAO,CAAC,CAAC,OAAQ7a,EAAMtC,GAAUH,EAAO8B,EAAQ,GAAI9B,EAAO8B,EAAQ,GAAI,CAAC,OAAQ5F,EAAOiE,KAE3Gmd,EAAQ9H,EAAY8H,EAAOtd,EAAOtH,MAAMoJ,EAAQ,IAEhDwb,EAAQ9H,EAAY8H,EAAO,CAAC,CAAC,OAAQ5H,EAAOvV,KAC5C6M,EAAchN,EAAQ2B,EAAM3B,EAAO/O,OAAQqsB,GACpCtd,GAlGP6M,WAYF,SAA4B7M,GAC1B,IACI4B,EADAjR,GAAS,EAGb,OAASA,EAAQqP,EAAO/O,SACtB2Q,EAAQ5B,EAAOrP,GAAO,IAEX4sB,OAAyB,eAAf3b,EAAM9K,MAAwC,cAAf8K,EAAM9K,MAAuC,aAAf8K,EAAM9K,OAEtFkJ,EAAO7J,OAAOxF,EAAQ,EAAkB,eAAfiR,EAAM9K,KAAwB,EAAI,GAC3D8K,EAAM9K,KAAO,OACbnG,KAIJ,OAAOqP,IAzBLmd,EAAoB,CACtBxT,SAyJF,SAA0BC,EAASC,EAAIC,GACrC,OAEA,SAAevV,GAKb,OAJAqV,EAAQ9P,MAAM,YACd8P,EAAQ9P,MAAM,kBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,kBACN8a,EAAkBrO,EAASjI,IAGpC,SAASA,EAAKpN,GACZ,OAAa,KAATA,EACKK,EAAIL,GAGNwjB,EAAmBnO,EAAS4T,EAAkB1T,EAAK,sBAAuB,6BAA8B,mCAAoC,yBAA0B,4BAA6B,EAAnMiO,CAAsMxjB,GAG/M,SAASipB,EAAiBjpB,GACxB,OAAOwb,EAA0Bxb,GAAQ0jB,EAAkBrO,EAASb,EAA3BkP,CAAoC1jB,GAAQK,EAAIL,GAG3F,SAASwU,EAAQxU,GACf,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzB2jB,EAAatO,EAASqO,EAAkBrO,EAAShV,GAAMkV,EAAK,gBAAiB,sBAAuB,sBAApGoO,CAA2H3jB,GAG7HK,EAAIL,GAGb,SAASK,EAAIL,GACX,OAAa,KAATA,GACFqV,EAAQ9P,MAAM,kBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,kBACbyM,EAAQzM,KAAK,YACN0M,GAGFC,EAAIvV,MA/LX6oB,EAAyB,CAC3BzT,SAkMF,SAA+BC,EAASC,EAAIC,GAC1C,IAAIqB,EAAOtJ,KACX,OAEA,SAAetN,GACb,OAAOyjB,EAAa/lB,KAAKkZ,EAAMvB,EAAS6T,EAAY3T,EAAK,YAAa,kBAAmB,kBAAlFkO,CAAqGzjB,IAG9G,SAASkpB,EAAWlpB,GAClB,OAAO4W,EAAKhI,OAAO8R,QAAQjkB,QAAQmR,EAAoBgJ,EAAKzK,eAAeyK,EAAKnL,OAAOmL,EAAKnL,OAAO/O,OAAS,GAAG,IAAIyH,MAAM,GAAI,KAAO,EAAIoR,EAAIvV,GAAQsV,EAAGtV,MAzMvJ8oB,EAA8B,CAChC1T,SA4MF,SAAoCC,EAASC,EAAIC,GAC/C,OAEA,SAAevV,GAKb,OAJAqV,EAAQ9P,MAAM,aACd8P,EAAQ9P,MAAM,mBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,mBACNwE,GAGT,SAASA,EAAKpN,GACZ,OAAa,KAATA,GACFqV,EAAQ9P,MAAM,mBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,mBACbyM,EAAQzM,KAAK,aACN0M,GAGFC,EAAIvV,MAIfjE,EAAOC,QAAU0gB,G,mCCrQjB,IAEIC,EAAkB,CACpBve,KAAM,kBACNgX,SAIF,SAAiCC,EAASC,EAAIC,GAC5C,IAAIqB,EAAOtJ,KACX,OAEA,SAAetN,GAKb,OAJAqV,EAAQ9P,MAAM,cACd8P,EAAQ9P,MAAM,oBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,oBACNwE,GAGT,SAASA,EAAKpN,GACZ,OAAa,KAATA,GACFqV,EAAQ9P,MAAM,eACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,eACbyM,EAAQzM,KAAK,cACN7I,GAGFwV,EAAIvV,GAGb,SAASD,EAAMC,GAEb,OAAgB,KAATA,GAEP,2BAA4B4W,EAAKhI,OAAO8J,WAExCnD,EAAIvV,GAAQsV,EAAGtV,KAjCjBsY,WALa,EAAQ,OAKAA,YAqCvBvc,EAAOC,QAAU2gB,G,mCC1CjB,IAEIC,EAAiB,CACnBxe,KAAM,iBACNgX,SAIF,SAAgCC,EAASC,EAAIC,GAC3C,IAAIqB,EAAOtJ,KACX,OAEA,SAAetN,GAMb,OALAqV,EAAQ9P,MAAM,aACd8P,EAAQ9P,MAAM,eACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,eACbyM,EAAQzM,KAAK,aACN7I,GAGT,SAASA,EAAMC,GAEb,OAAgB,KAATA,GAEP,2BAA4B4W,EAAKhI,OAAO8J,WAExCnD,EAAIvV,GAAQsV,EAAGtV,KAtBjBsY,WALa,EAAQ,OAKAA,YA0BvBvc,EAAOC,QAAU4gB,G,mCC/BjB,IAAIM,EAAe,EAAQ,OAEvBxS,EAAa,CACftM,KAAM,aACNgX,SAGF,SAA4BC,EAASC,GACnC,OAEA,SAAetV,GAIb,OAHAqV,EAAQ9P,MAAM,cACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,cACNsU,EAAa7H,EAASC,EAAI,iBAIrCvZ,EAAOC,QAAU0O,G,mCClBjB,IAAIwR,EAAa,EAAQ,OAErB4F,EAAgB,EAAQ,OAExBpG,EAAa,EAAQ,MAErByN,EAAa,EAAQ,OAErBjM,EAAe,EAAQ,OAEvBG,EAAmB,EAAQ,OAE3B1U,EAAgB,EAAQ,OAExBX,EAAO,CACT5J,KAAM,OACNgX,SAeF,SAA2BC,EAASC,EAAIC,GACtC,IAAIqB,EAAOtJ,KACP8b,EAAc1N,EAAW9E,EAAKnL,OAAQ,cACtC/L,EAAO,EACX,OAEA,SAAeM,GACb,IAAImlB,EAAOvO,EAAKiH,eAAetb,OAAkB,KAATvC,GAAwB,KAATA,GAAwB,KAATA,EAAc,gBAAkB,eAEtG,GAAa,kBAATmlB,GAA4BvO,EAAKiH,eAAezJ,QAAUpU,IAAS4W,EAAKiH,eAAezJ,OAAS8H,EAAWlc,GAAO,CAQpH,GAPK4W,EAAKiH,eAAetb,OACvBqU,EAAKiH,eAAetb,KAAO4iB,EAC3B9P,EAAQ9P,MAAM4f,EAAM,CAClBpD,YAAY,KAIH,kBAAToD,EAEF,OADA9P,EAAQ9P,MAAM,kBACE,KAATvF,GAAwB,KAATA,EAAcqV,EAAQU,MAAMpN,EAAe4M,EAAK1I,EAAlCwI,CAA4CrV,GAAQ6M,EAAS7M,GAGnG,IAAK4W,EAAKyH,WAAsB,KAATre,EAGrB,OAFAqV,EAAQ9P,MAAM,kBACd8P,EAAQ9P,MAAM,iBACPmR,EAAO1W,GAIlB,OAAOuV,EAAIvV,IAGb,SAAS0W,EAAO1W,GACd,OAAIkc,EAAWlc,MAAWN,EAAO,IAC/B2V,EAAQG,QAAQxV,GACT0W,KAGHE,EAAKyH,WAAa3e,EAAO,KAAOkX,EAAKiH,eAAezJ,OAASpU,IAAS4W,EAAKiH,eAAezJ,OAAkB,KAATpU,GAAwB,KAATA,IACtHqV,EAAQzM,KAAK,iBACNiE,EAAS7M,IAGXuV,EAAIvV,GAGb,SAAS6M,EAAS7M,GAKhB,OAJAqV,EAAQ9P,MAAM,kBACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,kBACbgO,EAAKiH,eAAezJ,OAASwC,EAAKiH,eAAezJ,QAAUpU,EACpDqV,EAAQU,MAAMsH,EACrBzG,EAAKyH,UAAY9I,EAAM8T,EAAShU,EAAQyB,QAAQwS,EAAmCC,EAAaC,IAGlG,SAASH,EAAQrpB,GAGf,OAFA4W,EAAKiH,eAAe4L,kBAAmB,EACvCL,IACOG,EAAYvpB,GAGrB,SAASwpB,EAAYxpB,GACnB,OAAI8hB,EAAc9hB,IAChBqV,EAAQ9P,MAAM,4BACd8P,EAAQG,QAAQxV,GAChBqV,EAAQzM,KAAK,4BACN2gB,GAGFhU,EAAIvV,GAGb,SAASupB,EAAYvpB,GAEnB,OADA4W,EAAKiH,eAAene,KAAO0pB,EAAcD,EAAWvS,EAAK2I,YAAYlK,EAAQzM,KAAK,oBAC3E0M,EAAGtV,KAxFZ8d,aAAc,CACZ1I,SA2FJ,SAAkCC,EAASC,EAAIC,GAC7C,IAAIqB,EAAOtJ,KAEX,OADAsJ,EAAKiH,eAAeW,gBAAand,EAC1BgU,EAAQU,MAAMsH,GAErB,SAAiBrd,GAIf,OAHA4W,EAAKiH,eAAe6L,kBAAoB9S,EAAKiH,eAAe6L,mBAAqB9S,EAAKiH,eAAe4L,iBAG9FvM,EAAa7H,EAASC,EAAI,iBAAkBsB,EAAKiH,eAAene,KAAO,EAAvEwd,CAA0Eld,MAGnF,SAAkBA,GAChB,GAAI4W,EAAKiH,eAAe6L,oBAAsB5H,EAAc9hB,GAE1D,OADA4W,EAAKiH,eAAe6L,kBAAoB9S,EAAKiH,eAAe4L,sBAAmBpoB,EACxEsoB,EAAiB3pB,GAI1B,OADA4W,EAAKiH,eAAe6L,kBAAoB9S,EAAKiH,eAAe4L,sBAAmBpoB,EACxEgU,EAAQyB,QAAQ8S,EAAiBtU,EAAIqU,EAArCtU,CAAuDrV,MAGhE,SAAS2pB,EAAiB3pB,GAKxB,OAHA4W,EAAKiH,eAAeW,YAAa,EAEjC5H,EAAKyH,eAAYhd,EACV6b,EAAa7H,EAASA,EAAQyB,QAAQ9O,EAAMsN,EAAIC,GAAM,aAAcqB,EAAKhI,OAAO8J,WAAWuE,QAAQrE,KAAKnc,QAAQ,iBAAmB,OAAI4E,EAAY,EAAnJ6b,CAAsJld,MApH/J4I,KAiIF,SAAyByM,GACvBA,EAAQzM,KAAK0E,KAAKuQ,eAAetb,QAhI/B+mB,EAAoC,CACtClU,SAkIF,SAA0CC,EAASC,EAAIC,GACrD,IAAIqB,EAAOtJ,KACX,OAAO4P,EAAa7H,GAEpB,SAAqBrV,GACnB,OAAO8hB,EAAc9hB,KAAU0b,EAAW9E,EAAKnL,OAAQ,4BAA8B8J,EAAIvV,GAAQsV,EAAGtV,KAH5D,2BAA4B4W,EAAKhI,OAAO8J,WAAWuE,QAAQrE,KAAKnc,QAAQ,iBAAmB,OAAI4E,EAAY,IAnIrJuU,SAAS,GAEPgU,EAAkB,CACpBxU,SAiHF,SAAwBC,EAASC,EAAIC,GACnC,IAAIqB,EAAOtJ,KACX,OAAO4P,EAAa7H,GAEpB,SAAqBrV,GACnB,OAAO0b,EAAW9E,EAAKnL,OAAQ,oBAAsBmL,EAAKiH,eAAene,KAAO4V,EAAGtV,GAAQuV,EAAIvV,KAHvD,iBAAkB4W,EAAKiH,eAAene,KAAO,IAlHvFkW,SAAS,GAsIX7Z,EAAOC,QAAUgM,G,mCClKjB,IAAIkN,EAAqB,EAAQ,OAE7BgI,EAAe,EAAQ,OAEvBG,EAAmB,CACrBjI,SAIF,SAAkCC,EAASC,EAAIC,GAC7C,OAAO2H,EAAa7H,GAEpB,SAAyBrV,GACvB,OAAgB,OAATA,GAAiBkV,EAAmBlV,GAAQsV,EAAGtV,GAAQuV,EAAIvV,KAHtB,eAJ9C4V,SAAS,GAWX7Z,EAAOC,QAAUqhB,G,mCCjBjB,IAAInI,EAAqB,EAAQ,OAE7BsD,EAAU,EAAQ,OAElB0E,EAAe,EAAQ,OAEvBL,EAAkB,CACpBze,KAAM,kBACNgX,SAyDF,SAAiCC,EAASC,EAAIC,GAC5C,IAEInB,EACAjM,EAHAyO,EAAOtJ,KACPlR,EAAQwa,EAAKnL,OAAO/O,OAIxB,KAAON,KAGL,GAAmC,eAA/Bwa,EAAKnL,OAAOrP,GAAO,GAAGmG,MAAwD,eAA/BqU,EAAKnL,OAAOrP,GAAO,GAAGmG,MAAwD,YAA/BqU,EAAKnL,OAAOrP,GAAO,GAAGmG,KAAoB,CAC1I4F,EAA2C,cAA/ByO,EAAKnL,OAAOrP,GAAO,GAAGmG,KAClC,MAIJ,OAEA,SAAevC,GACb,IAAK4W,EAAK6H,OAAS7H,EAAKyH,WAAalW,GAInC,OAHAkN,EAAQ9P,MAAM,qBACd8P,EAAQ9P,MAAM,6BACd6O,EAASpU,EACFqhB,EAAgBrhB,GAGzB,OAAOuV,EAAIvV,IAGb,SAASqhB,EAAgBrhB,GACvB,OAAIA,IAASoU,GACXiB,EAAQG,QAAQxV,GACTqhB,IAGThM,EAAQzM,KAAK,6BACNsU,EAAa7H,EAASoN,EAAoB,aAA1CvF,CAAwDld,IAGjE,SAASyiB,EAAmBziB,GAC1B,OAAa,OAATA,GAAiBkV,EAAmBlV,IACtCqV,EAAQzM,KAAK,qBACN0M,EAAGtV,IAGLuV,EAAIvV,KApGb8mB,UAGF,SAAkCrb,EAAQG,GACxC,IACIqP,EACA/M,EACArH,EACAd,EAJA3J,EAAQqP,EAAO/O,OAOnB,KAAON,KACL,GAAyB,UAArBqP,EAAOrP,GAAO,GAAgB,CAChC,GAA8B,YAA1BqP,EAAOrP,GAAO,GAAGmG,KAAoB,CACvC0Y,EAAU7e,EACV,MAG4B,cAA1BqP,EAAOrP,GAAO,GAAGmG,OACnB2L,EAAO9R,OAIuB,YAA1BqP,EAAOrP,GAAO,GAAGmG,MAEnBkJ,EAAO7J,OAAOxF,EAAO,GAGlByK,GAAwC,eAA1B4E,EAAOrP,GAAO,GAAGmG,OAClCsE,EAAazK,GAKrB2J,EAAU,CACRxD,KAAM,gBACNpC,MAAOqY,EAAQ/M,EAAOyC,GAAM,GAAG/N,OAC/BE,IAAKmY,EAAQ/M,EAAOA,EAAO/O,OAAS,GAAG,GAAG2D,MAG5CoL,EAAOyC,GAAM,GAAG3L,KAAO,oBAGnBsE,GACF4E,EAAO7J,OAAOsM,EAAM,EAAG,CAAC,QAASnI,EAAS6F,IAC1CH,EAAO7J,OAAOiF,EAAa,EAAG,EAAG,CAAC,OAAQ4E,EAAOwP,GAAS,GAAIrP,IAC9DH,EAAOwP,GAAS,GAAG5a,IAAMmY,EAAQ/M,EAAO5E,GAAY,GAAGxG,MAEvDoL,EAAOwP,GAAS,GAAKlV,EAKvB,OADA0F,EAAOnK,KAAK,CAAC,OAAQyE,EAAS6F,IACvBH,IAmDT1P,EAAOC,QAAU6gB,G,mCCjHjB,IAAI3H,EAAqB,EAAQ,OAE7B4M,EAAgB,EAAQ,OAExB5E,EAAe,EAAQ,OAEvBvU,EAAgB,CAClBvK,KAAM,gBACNgX,SAGF,SAA+BC,EAASC,EAAIC,GAC1C,IACInB,EADA1U,EAAO,EAEX,OAEA,SAAeM,GAGb,OAFAqV,EAAQ9P,MAAM,iBACd6O,EAASpU,EACFkS,EAAQlS,IAGjB,SAASkS,EAAQlS,GACf,OAAIA,IAASoU,GACXiB,EAAQ9P,MAAM,yBACPkO,EAASzT,IAGd8hB,EAAc9hB,GACTkd,EAAa7H,EAASnD,EAAS,aAA/BgL,CAA6Cld,GAGlDN,EAAO,GAAc,OAATM,IAAkBkV,EAAmBlV,GAC5CuV,EAAIvV,IAGbqV,EAAQzM,KAAK,iBACN0M,EAAGtV,IAGZ,SAASyT,EAASzT,GAChB,OAAIA,IAASoU,GACXiB,EAAQG,QAAQxV,GAChBN,IACO+T,IAGT4B,EAAQzM,KAAK,yBACNsJ,EAAQlS,OAInBjE,EAAOC,QAAU2M,G,mCCpDjB,IAAI8P,EAAgB,EAAQ,MAW5B1c,EAAOC,QATP,SAAqBgM,EAAM6hB,GACzB,OAAI7hB,EAAKtL,QACP+b,EAAczQ,EAAMA,EAAKtL,OAAQ,EAAGmtB,GAC7B7hB,GAGF6hB,I,kCCRT,IAAIjoB,EAAS,EAAQ,OAkCrB7F,EAAOC,QA/BP,SAAuBgM,EAAM7H,EAAO2pB,EAAQD,GAC1C,IAEIE,EAFA1pB,EAAM2H,EAAKtL,OACXstB,EAAa,EAWjB,GAPE7pB,EADEA,EAAQ,GACDA,EAAQE,EAAM,EAAIA,EAAMF,EAEzBA,EAAQE,EAAMA,EAAMF,EAG9B2pB,EAASA,EAAS,EAAIA,EAAS,EAE3BD,EAAMntB,OAAS,KACjBqtB,EAAatsB,MAAMmjB,KAAKiJ,IACbxlB,QAAQlE,EAAO2pB,GAC1BloB,EAAOqC,MAAM+D,EAAM+hB,QAKnB,IAFID,GAAQloB,EAAOqC,MAAM+D,EAAM,CAAC7H,EAAO2pB,IAEhCE,EAAaH,EAAMntB,SACxBqtB,EAAaF,EAAM1lB,MAAM6lB,EAAYA,EAAa,MACvC3lB,QAAQlE,EAAO,GAC1ByB,EAAOqC,MAAM+D,EAAM+hB,GACnBC,GAAc,IACd7pB,GAAS,M,mCC7Bf,IAAIqb,EAA4B,EAAQ,OAEpCrM,EAAqB,EAAQ,OAE7BC,EAAoB,EAAQ,OAgBhCrT,EAAOC,QAVP,SAA2BgE,GACzB,OAAa,OAATA,GAAiBwb,EAA0Bxb,IAASoP,EAAkBpP,GACjE,EAGLmP,EAAmBnP,GACd,OADT,I,kCCfF,IAAI/C,EAAiB,EAAQ,OAEzBwb,EAAgB,EAAQ,MAExBgI,EAAW,EAAQ,OAavB,SAAStb,EAAUhC,EAAKgC,GACtB,IAAI8kB,EACAjb,EACAoE,EACApT,EAEJ,IAAKiqB,KAAQ9kB,EAIX,IAAKnF,KAHLgP,EAAO/R,EAAeS,KAAKyF,EAAK8mB,GAAQ9mB,EAAI8mB,GAAQ9mB,EAAI8mB,GAAQ,GAChE7W,EAAQjO,EAAU8kB,GAGhBjb,EAAKhP,GAAQ0Y,EAAW+H,EAASrN,EAAMpT,IAAQ/C,EAAeS,KAAKsR,EAAMhP,GAAQgP,EAAKhP,GAAQ,IAKpG,SAAS0Y,EAAW1Q,EAAMkiB,GAIxB,IAHA,IAAI9tB,GAAS,EACT0D,EAAS,KAEJ1D,EAAQ4L,EAAKtL,SAEC,UAApBsL,EAAK5L,GAAO+tB,IAAkBD,EAAWpqB,GAAQwB,KAAK0G,EAAK5L,IAI9D,OADAqc,EAAcyR,EAAU,EAAG,EAAGpqB,GACvBoqB,EAGTnuB,EAAOC,QAxCP,SAA2BkJ,GAIzB,IAHA,IAAI/B,EAAM,GACN/G,GAAS,IAEJA,EAAQ8I,EAAWxI,QAC1ByI,EAAUhC,EAAK+B,EAAW9I,IAG5B,OAAO+G,I,mCCdT,IAAI+I,EAAS,EAAQ,MAEjBgJ,EAAqB,EAAQ,OAE7B+L,EAAc,EAAQ,OAEtBxI,EAAgB,EAAQ,MAExBgI,EAAW,EAAQ,OAEnBnI,EAAa,EAAQ,OAErB8R,EAAkB,EAAQ,OAE1B5R,EAAU,EAAQ,OAElB6R,EAAc,EAAQ,OAqS1BtuB,EAAOC,QA5RP,SAAyB4S,EAAQ0b,EAAY1J,GAC3C,IAAIvU,EAAQuU,EAAOpI,EAAQoI,GAAQ,CACjC/gB,KAAM,EACNyM,OAAQ,EACRC,OAAQ,GAENge,EAAc,GACdC,EAAuB,GACvBxK,EAAS,GACTnd,EAAQ,GACRwS,EAAU,CACZG,QA2GF,SAAiBxV,GACXkV,EAAmBlV,IACrBqM,EAAMxM,OACNwM,EAAMC,OAAS,EACfD,EAAME,SAAoB,IAAVvM,EAAc,EAAI,EAClCyqB,MACmB,IAAVzqB,IACTqM,EAAMC,SACND,EAAME,UAIJF,EAAMiU,aAAe,EACvBjU,EAAMgU,UAENhU,EAAMiU,eAEFjU,EAAMiU,eAAiBN,EAAO3T,EAAMgU,QAAQ3jB,SAC9C2P,EAAMiU,cAAgB,EACtBjU,EAAMgU,WAKVzU,EAAQiE,SAAW7P,GAlInBuF,MAsIF,SAAehD,EAAMmoB,GACnB,IAAIrd,EAAQqd,GAAU,GAKtB,OAJArd,EAAM9K,KAAOA,EACb8K,EAAMlN,MAAQ+e,IACdtT,EAAQH,OAAOnK,KAAK,CAAC,QAAS+L,EAAOzB,IACrC/I,EAAMvB,KAAK+L,GACJA,GA3IPzE,KA+IF,SAAcrG,GACZ,IAAI8K,EAAQxK,EAAMK,MAGlB,OAFAmK,EAAMhN,IAAM6e,IACZtT,EAAQH,OAAOnK,KAAK,CAAC,OAAQ+L,EAAOzB,IAC7ByB,GAlJPyJ,QAAS6T,GAsJX,SAA+BC,EAAW9H,GACxC+H,EAAUD,EAAW9H,EAAKlC,SAtJ1B7K,MAAO4U,EAAiBG,GACxBzM,UAAWsM,EAAiBG,EAAmB,CAC7CzM,WAAW,IAEbI,KAAMkM,EAAiBG,EAAmB,CACxCrM,MAAM,KAIN7S,EAAU,CACZiE,SAAU,KACVpE,OAAQ,GACRmD,OAAQA,EACR2Q,YAAaA,EACbpT,eAkCF,SAAwBkB,GACtB,OAAO+c,EAAgB7K,EAAYlS,KAlCnC6R,IAAKA,EACLI,WA4CF,SAAcjjB,GACZkuB,EAAYluB,EAAMwD,MAAQxD,EAAMiQ,OAChCme,KA7CA3b,MAcF,SAAe3K,GAIb,GAHA6b,EAASiB,EAAYjB,EAAQ7b,GAC7B4mB,IAEkC,OAA9B/K,EAAOA,EAAOtjB,OAAS,GACzB,MAAO,GAMT,OAHAmuB,EAAUP,EAAY,GAEtB1e,EAAQH,OAAS6M,EAAWkS,EAAsB5e,EAAQH,OAAQG,GAC3DA,EAAQH,SAtBbuf,EAAQV,EAAWlV,SAAS1X,KAAKkO,EAASyJ,GAS9C,OAPIiV,EAAWhS,YACbkS,EAAqBlpB,KAAKgpB,GAI5Bje,EAAMgU,OAAS,EACfhU,EAAMiU,cAAgB,EACf1U,EAuBP,SAAS2T,EAAYlS,GACnB,OAAOgd,EAAYrK,EAAQ3S,GAG7B,SAAS6R,IACP,OAAO1G,EAAQnM,GAiBjB,SAAS0e,IAIP,IAHA,IAAIE,EACAhL,EAEG5T,EAAMgU,OAASL,EAAOtjB,QAG3B,GAAqB,iBAFrBujB,EAAQD,EAAO3T,EAAMgU,SASnB,IANA4K,EAAa5e,EAAMgU,OAEfhU,EAAMiU,aAAe,IACvBjU,EAAMiU,aAAe,GAGhBjU,EAAMgU,SAAW4K,GAAc5e,EAAMiU,aAAeL,EAAMvjB,QAC/DwuB,EAAGjL,EAAMje,WAAWqK,EAAMiU,oBAG5B4K,EAAGjL,GAMT,SAASiL,EAAGlrB,GACVgrB,EAAQA,EAAMhrB,GAuDhB,SAAS8qB,EAAkBF,EAAW9H,GACpCA,EAAKqI,UAIP,SAASR,EAAiBS,EAAUV,GAClC,OAGA,SAAchS,EAAYqO,EAAasE,GACrC,IAAIC,EACAC,EACAtN,EACA6E,EACJ,OAAOpK,EAAWtD,UAAY,WAAYsD,EAAa8S,EAAuB/K,EAAS/H,IAEvF,SAA+B1Y,GAC7B,GAAIA,KAAQ0Y,GAAc,QAAQA,EAChC,OAAO8S,EAAuB9S,EAAWE,KAEzC6H,EAAS/H,EAAW1Y,IAAOQ,OAAOigB,EAAS/H,EAAWE,OAASF,EAAW1Y,GAFnEwrB,CAE0ExrB,GAGnF,OAAOqrB,EAAWrrB,IAGpB,SAASwrB,EAAuBxjB,GAG9B,OAFAsjB,EAAmBtjB,EAEZyjB,EAAgBzjB,EADvBujB,EAAiB,IAInB,SAASE,EAAgBb,GACvB,OAEA,SAAe5qB,GAKb8iB,EA8CR,WACE,IAAI4I,EAAaxM,IACbyM,EAAgB/f,EAAQiE,SACxB+b,EAAwBhgB,EAAQqS,iBAChC4N,EAAmBjgB,EAAQH,OAAO/O,OAClCovB,EAAaruB,MAAMmjB,KAAK/d,GAC5B,MAAO,CACLsoB,QAASA,EACTvK,KAAMiL,GAGR,SAASV,IACP9e,EAAQqf,EACR9f,EAAQiE,SAAW8b,EACnB/f,EAAQqS,iBAAmB2N,EAC3BhgB,EAAQH,OAAO/O,OAASmvB,EACxBhpB,EAAQipB,EACRrB,KA/DWsB,GACP9N,EAAmB2M,EAEdA,EAAUhV,UACbhK,EAAQqS,iBAAmB2M,GAG7B,GAAIA,EAAUxsB,MAAQwN,EAAQgD,OAAO8J,WAAWuE,QAAQrE,KAAKnc,QAAQmuB,EAAUxsB,OAAS,EACtF,OAAOmX,IAGT,OAAOqV,EAAUxV,SAAS1X,KAAKgtB,EAASxe,EAAO,GAAIN,EAAS8e,GAAU9e,EAASyJ,EAASC,EAAIC,EAArFqV,CAA0F5qB,IAIrG,SAASsV,EAAGtV,GAEV,OADAorB,EAASnN,EAAkB6E,GACpBiE,EAGT,SAASxR,EAAIvV,GAGX,OAFA8iB,EAAKqI,YAECI,EAAiBD,EAAiB5uB,OAC/B+uB,EAAgBH,EAAiBC,IAGnCF,IAKb,SAASR,EAAUD,EAAWhK,GACxBgK,EAAUtS,YAAckS,EAAqB/tB,QAAQmuB,GAAa,GACpEJ,EAAqBlpB,KAAKspB,GAGxBA,EAAU/P,SACZpC,EAAc7M,EAAQH,OAAQmV,EAAMhV,EAAQH,OAAO/O,OAASkkB,EAAMgK,EAAU/P,QAAQjP,EAAQH,OAAOtH,MAAMyc,GAAOhV,IAG9Ggf,EAAU9D,YACZlb,EAAQH,OAASmf,EAAU9D,UAAUlb,EAAQH,OAAQG,IAyBzD,SAAS6e,IACHpe,EAAMxM,QAAQ0qB,GAAele,EAAMC,OAAS,IAC9CD,EAAMC,OAASie,EAAYle,EAAMxM,MACjCwM,EAAME,QAAUge,EAAYle,EAAMxM,MAAQ,M,+BC5ShD9D,EAAOC,QAJP,SAAkBK,GAChB,OAAOA,QAAwC,GAAK,WAAYA,EAAQA,EAAQ,CAACA,K,+BCMnFN,EAAOC,QAPP,SAAmBqQ,EAAOE,GAIxB,OAHAF,EAAMC,QAAUC,EAChBF,EAAME,QAAUA,EAChBF,EAAMiU,cAAgB/T,EACfF,I,8BCQTtQ,EAAOC,QAZP,SAA6BK,GAC3B,OAAOA,EACNQ,QAAQ,cAAe,KACvBA,QAAQ,SAAU,IAMlBgR,cAAcme,gB,kCCTjB,IAAI7C,EAAa,EAAQ,OAQzBptB,EAAOC,QANP,SAAoByP,EAAQlJ,GAC1B,IAAI0L,EAAOxC,EAAOA,EAAO/O,OAAS,GAClC,OAAKuR,GAAQA,EAAK,GAAG1L,OAASA,EACvB4mB,EAAWlb,EAAK,GAAGsR,YAAYtR,EAAK,KADA,I,kCCJ7C,IAAIqO,EAAe,EAAQ,OAU3BvgB,EAAOC,QARP,SAAoBiwB,GAClB,OAEA,SAAejsB,GACb,OAAOisB,EAAMnc,KAAKwM,EAAatc,O,+BCWnCjE,EAAOC,QAjBP,SAAoB0c,EAAYjN,EAAQG,GAKtC,IAJA,IAEIiP,EAFAqR,EAAS,GACT9vB,GAAS,IAGJA,EAAQsc,EAAWhc,SAC1Bme,EAAUnC,EAAWtc,GAAOkc,aAEb4T,EAAOzvB,QAAQoe,GAAW,IACvCpP,EAASoP,EAAQpP,EAAQG,GACzBsgB,EAAO5qB,KAAKuZ,IAIhB,OAAOpP,I,mCCdT,IAAI6Q,EAAe,EAAQ,OAiB3BvgB,EAAOC,QAfP,SAAqBK,EAAOgX,GAC1B,IAAIrT,EAAOwN,SAASnR,EAAOgX,GAE3B,OACArT,EAAO,GAAc,KAATA,GAAeA,EAAO,IAAMA,EAAO,IAC/CA,EAAO,KAAOA,EAAO,KACrBA,EAAO,OAASA,EAAO,OACvBA,EAAO,OAASA,EAAO,OAA4B,QAAX,MAAPA,IAA8C,QAAX,MAAPA,IAC7DA,EAAO,QACE,IAGFsc,EAAatc,K,mCCdtB,IAAIsc,EAAe,EAAQ,OAqC3BvgB,EAAOC,QAnCP,SAAyBgkB,GAOvB,IANA,IAEIC,EACA5jB,EACA8vB,EAJA/vB,GAAS,EACT4G,EAAS,KAKJ5G,EAAQ4jB,EAAOtjB,QAAQ,CAG9B,GAAqB,iBAFrBujB,EAAQD,EAAO5jB,IAGbC,EAAQ4jB,OACH,IAAe,IAAXA,EACT5jB,EAAQ,UACH,IAAe,IAAX4jB,EACT5jB,EAAQ,UACH,IAAe,IAAX4jB,EACT5jB,EAAQ,YACH,IAAe,IAAX4jB,EACT5jB,EAAQ,UACH,IAAe,IAAX4jB,EAAc,CACvB,GAAIkM,EAAO,SACX9vB,EAAQ,SAGRA,EAAQigB,EAAa2D,GAGvBkM,GAAmB,IAAXlM,EACRjd,EAAO1B,KAAKjF,GAGd,OAAO2G,EAAOlB,KAAK,M,mCClCrB,IAAIoK,EAAS,EAAQ,MAMrBnQ,EAAOC,QAJP,SAAiBowB,GACf,OAAOlgB,EAAO,GAAIkgB,K,+BCQpBrwB,EAAOC,QAXP,SAAoBgkB,GAIlB,IAHA,IAAI5jB,GAAS,EACTsD,EAAO,IAEFtD,EAAQ4jB,EAAOtjB,QACtBgD,GAAiC,iBAAlBsgB,EAAO5jB,GAAsB4jB,EAAO5jB,GAAOM,OAAS,EAGrE,OAAOgD,I,+BCgBT3D,EAAOC,QAxBP,SAAqBgkB,EAAQ3S,GAC3B,IAIIgf,EAJAC,EAAajf,EAAMlN,MAAMkgB,OACzBkM,EAAmBlf,EAAMlN,MAAMmgB,aAC/BkM,EAAWnf,EAAMhN,IAAIggB,OACrBoM,EAAiBpf,EAAMhN,IAAIigB,aAiB/B,OAdIgM,IAAeE,EACjBH,EAAO,CAACrM,EAAOsM,GAAYnoB,MAAMooB,EAAkBE,KAEnDJ,EAAOrM,EAAO7b,MAAMmoB,EAAYE,GAE5BD,GAAoB,IACtBF,EAAK,GAAKA,EAAK,GAAGloB,MAAMooB,IAGtBE,EAAiB,GACnBJ,EAAK/qB,KAAK0e,EAAOwM,GAAUroB,MAAM,EAAGsoB,KAIjCJ,I,mCCrBT,IAAIngB,EAAS,EAAQ,MAEjBuM,EAAgB,EAAQ,MAExBD,EAAU,EAAQ,OAsFtB,SAASkU,EAAWjhB,EAAQ2U,GAiB1B,IAhBA,IAQIuM,EACA9c,EACAzT,EACAwwB,EACAvsB,EACAwsB,EAbAxf,EAAQ5B,EAAO2U,GAAY,GAC3BxU,EAAUH,EAAO2U,GAAY,GAC7BW,EAAgBX,EAAa,EAC7B0M,EAAiB,GACjB7U,EAAY5K,EAAM8R,YAAcvT,EAAQgD,OAAOvB,EAAMgO,aAAahO,EAAMlN,OACxE4sB,EAAc9U,EAAUxM,OACxBuhB,EAAQ,GACRC,EAAO,GASJ5f,GAAO,CAEZ,KAAO5B,IAASsV,GAAe,KAAO1T,IAGtCyf,EAAexrB,KAAKyf,GAEf1T,EAAM8R,aACTwN,EAAS/gB,EAAQ2T,YAAYlS,GAExBA,EAAM+P,MACTuP,EAAOrrB,KAAK,MAGVuO,GACFoI,EAAUqH,WAAWjS,EAAMlN,OAGzBkN,EAAM6f,6BACRjV,EAAU2D,oCAAqC,GAGjD3D,EAAUnJ,MAAM6d,GAEZtf,EAAM6f,6BACRjV,EAAU2D,wCAAqCva,IAKnDwO,EAAWxC,EACXA,EAAQA,EAAM+P,KAQhB,IAHA/P,EAAQwC,EACRzT,EAAQ2wB,EAAYrwB,OAEbN,KAGyB,UAA1B2wB,EAAY3wB,GAAO,GACrBwwB,GAAU,EAEZA,GAAWG,EAAY3wB,GAAO,GAAGmG,OAASwqB,EAAY3wB,EAAQ,GAAG,GAAGmG,MAAQwqB,EAAY3wB,GAAO,GAAG+D,MAAMN,OAASktB,EAAY3wB,GAAO,GAAGiE,IAAIR,OACzIsqB,EAAI4C,EAAY5oB,MAAM/H,EAAQ,EAAGiE,IAEjCgN,EAAM8R,WAAa9R,EAAM+P,UAAO/b,EAChCgM,EAAQA,EAAMwC,SACdxP,EAAMjE,EAAQ,GAWlB,IANA6b,EAAUxM,OAAS4B,EAAM8R,WAAa9R,EAAM+P,UAAO/b,EAEnD8oB,EAAI4C,EAAY5oB,MAAM,EAAG9D,IACzBjE,GAAS,EACTywB,EAAS,IAEAzwB,EAAQ4wB,EAAMtwB,QACrBuwB,EAAKJ,EAASG,EAAM5wB,GAAO,IAAMywB,EAASG,EAAM5wB,GAAO,GACvDywB,GAAUG,EAAM5wB,GAAO,GAAK4wB,EAAM5wB,GAAO,GAAK,EAGhD,OAAO6wB,EAEP,SAAS9C,EAAIhmB,GACX,IAAIhE,EAAQ2sB,EAAe5pB,MAC3B8pB,EAAM3oB,QAAQ,CAAClE,EAAOA,EAAQgE,EAAMzH,OAAS,IAC7C+b,EAAchN,EAAQtL,EAAO,EAAGgE,IAIpCpI,EAAOC,QAhLP,SAAqByP,GAWnB,IAVA,IAEIkB,EACAF,EACA0gB,EACAC,EACArD,EACAsD,EACAnV,EARA8U,EAAQ,GACR5wB,GAAS,IASJA,EAAQqP,EAAO/O,QAAQ,CAC9B,KAAON,KAAS4wB,GACd5wB,EAAQ4wB,EAAM5wB,GAMhB,GAHAuQ,EAAQlB,EAAOrP,GAGXA,GAA2B,cAAlBuQ,EAAM,GAAGpK,MAAsD,mBAA9BkJ,EAAOrP,EAAQ,GAAG,GAAGmG,QAEjE4qB,EAAa,IADbE,EAAY1gB,EAAM,GAAGwS,WAAW1T,QAGL/O,QAA4C,oBAAlC2wB,EAAUF,GAAY,GAAG5qB,OAC5D4qB,GAAc,GAGZA,EAAaE,EAAU3wB,QAA4C,YAAlC2wB,EAAUF,GAAY,GAAG5qB,MAC5D,OAAS4qB,EAAaE,EAAU3wB,QACQ,YAAlC2wB,EAAUF,GAAY,GAAG5qB,MAIS,cAAlC8qB,EAAUF,GAAY,GAAG5qB,OAC3B8qB,EAAUF,GAAY,GAAGD,4BAA6B,EACtDC,KAOR,GAAiB,UAAbxgB,EAAM,GACJA,EAAM,GAAG0O,cACXnP,EAAO8gB,EAAON,EAAWjhB,EAAQrP,IACjCA,EAAQ4wB,EAAM5wB,GACd8b,GAAO,QAGN,GAAIvL,EAAM,GAAGoV,YAAcpV,EAAM,GAAG2gB,yBAA0B,CAI/D,IAHAH,EAAa/wB,EACbqQ,OAAYpL,EAEL8rB,MAGsB,gBAF3BC,EAAa3hB,EAAO0hB,IAEL,GAAG5qB,MAAgD,oBAAvB6qB,EAAW,GAAG7qB,OACjC,UAAlB6qB,EAAW,KACT3gB,IACFhB,EAAOgB,GAAW,GAAGlK,KAAO,mBAG9B6qB,EAAW,GAAG7qB,KAAO,aACrBkK,EAAY0gB,GAOd1gB,IAEFE,EAAM,GAAGtM,IAAMmY,EAAQ/M,EAAOgB,GAAW,GAAGtM,QAE5C4pB,EAAate,EAAOtH,MAAMsI,EAAWrQ,IAC1BiI,QAAQsI,GACnB8L,EAAchN,EAAQgB,EAAWrQ,EAAQqQ,EAAY,EAAGsd,KAKhE,OAAQ7R,I,+BCtFV,IAAIqV,EAGJxxB,EAAOC,QAEP,SAAsBwxB,GACpB,IACIC,EADAC,EAAS,IAAMF,EAAa,IAUhC,IARAD,EAAKA,GAAM1e,SAAS8e,cAAc,MAC/BC,UAAYF,EARD,MASdD,EAAOF,EAAGM,aAMD7rB,WAAWyrB,EAAK/wB,OAAS,IAAmC,SAAf8wB,EACpD,OAAO,EAIT,OAAOC,IAASC,GAAiBD,I,mCCtBnC,IAAIK,EAAQ,EAAQ,OAEhBC,EAAQ,EAAQ,MAEhBC,EAAU,EAAQ,OAEtB,SAASC,EAAWlrB,EAAM5E,GACxB,IAAI8E,EAASlE,UAAUrC,OAAS,QAAsB2E,IAAjBtC,UAAU,GAAmBA,UAAU,GAAK,GAC7E3C,EAAQ2C,UAAUrC,OAAS,QAAsB2E,IAAjBtC,UAAU,GAAmBA,UAAU,GAAK,EAC5EmvB,EAAW/vB,EAAQgwB,UAAUprB,EAAKR,MAGjCQ,EAAKa,WACRb,EAAKa,SAAW,CACdzD,MAAO,CACLN,KAAM,KACNyM,OAAQ,KACRC,OAAQ,MAEVlM,IAAK,CACHR,KAAM,KACNyM,OAAQ,KACRC,OAAQ,QAKd,IAAI6hB,EAAMrrB,EAAKa,SAASzD,MACpBtC,EAAM,CAACkF,EAAKR,KAAM6rB,EAAIvuB,KAAMuuB,EAAI9hB,OAAQlQ,GAAO0F,KAAK,KAExD,IAAKksB,EAAQK,mBAAmBH,GAC9B,MAAM,IAAI1xB,MAAM,sBAAsBgE,OAAOuC,EAAKR,KAAM,uCAG1D,IAAI+rB,EAAYC,EAAaxrB,EAAMlF,EAAKM,EAAS+vB,EAAUjrB,EAAQ7G,GACnE,OAAO0xB,EAAMH,cAAcO,EAAUI,EAAWA,EAAU9rB,UAAYgsB,UAAqBntB,GAE3F,SAASmtB,IACP,OAAOzrB,EAAKP,UAAYO,EAAKP,SAASmS,KAAI,SAAU8Z,EAAWzvB,GAC7D,OAAOivB,EAAWQ,EAAWtwB,EAAS,CACpC4E,KAAMA,EACN2rB,MAAOJ,GACNtvB,OAMT,SAASuvB,EAAaxrB,EAAMlF,EAAK8wB,EAAMT,EAAUjrB,EAAQ7G,GACvD,IA0MuBgyB,EA1MnBM,EAAQ,CACV7wB,IAAKA,GAEH+wB,EAAuC,iBAAbV,GAAyBA,IAAaJ,EAAMe,SAEtEF,EAAKG,WAAa/rB,EAAKa,WACzB8qB,EAAM,kBAqMD,EADgBN,EApMqBrrB,EAAKa,UAqMrCzD,MAAMN,KAAM,IAAKuuB,EAAIjuB,MAAMmM,OAAQ,IAAK8hB,EAAI/tB,IAAIR,KAAM,IAAKuuB,EAAI/tB,IAAIiM,QAAQqI,IAAIrY,QAAQwF,KAAK,KAlMpG6sB,EAAKI,eAAiBH,IACxBF,EAAMM,eAAiBjsB,EAAKa,UAI1B+qB,EAAKM,kBAAoBhsB,EAAOF,MAAQE,EAAOF,KAAKP,WAAaosB,IACnEF,EAAMtyB,MAAQ6G,EAAOF,KAAKP,SAAS/F,QAAQsG,GAC3C2rB,EAAMQ,iBAAmBjsB,EAAOF,KAAKP,SAAS9F,QAGhD,IAAIyyB,EAA0B,OAApBpsB,EAAK4K,iBAA2CtM,IAApB0B,EAAK4K,WAE3CghB,EAAKS,YAAYrsB,EAAK4K,WAAWqe,gBAAkB,GAAK,KAExD,OAAQjpB,EAAKR,MACX,IAAK,OACH8sB,EAAcX,EAAO,CACnBY,UAAWX,EAAKW,YAElB,MAEF,IAAK,OACHZ,EAAMa,QAAU1xB,EAChB6wB,EAAMlsB,SAAWO,EAAK1G,MACtB,MAEF,IAAK,UACHqyB,EAAMc,MAAQzsB,EAAKT,MACnB,MAEF,IAAK,OACHosB,EAAMvuB,MAAQ4C,EAAK5C,MACnBuuB,EAAMhsB,QAAUK,EAAKL,QACrBgsB,EAAMlgB,OAASzL,EAAKyL,OACpBkgB,EAAMpsB,MAAQS,EAAKT,MACnB,MAEF,IAAK,WACHosB,EAAMjgB,QAAU1L,EAAK0L,QACrBigB,EAAMlgB,OAASzL,EAAKyL,OACpBkgB,EAAMhsB,QAAUK,EAAKL,QACrBgsB,EAAMtyB,MAAQ2G,EAAK3G,MACnBsyB,EAAMlsB,SA2JZ,SAA6BO,EAAME,GAGjC,OADYA,GAAUA,EAAOF,KAU/B,SAAmBA,GACjB,IAAIP,EAAWO,EAAKP,SAChBitB,EAAQ1sB,EAAKyL,OACbpS,GAAS,EAEb,MAAQqzB,KAAWrzB,EAAQoG,EAAS9F,QAClC+yB,EAAQC,EAAcltB,EAASpG,IAGjC,OAAOqzB,EAnB6BE,CAAU1sB,EAAOF,MAAQ2sB,EAAc3sB,IAC5DA,EAAKP,SAGtB,SAA0BO,GACxB,OAAOA,EAAKP,SAASotB,QAAO,SAAUC,EAAOptB,GAC3C,OAAOotB,EAAMrvB,OAAsB,cAAfiC,EAAMF,KAAuBE,EAAMD,SAAW,CAACC,MAClE,IAN4BqtB,CAAiB/sB,GA9J3BgtB,CAAoBhtB,EAAME,GAAQ0R,KAAI,SAAU8Z,EAAWzvB,GAC1E,OAAOivB,EAAWQ,EAAWE,EAAM,CACjC5rB,KAAMA,EACN2rB,MAAOA,GACN1vB,MAEL,MAEF,IAAK,aACHqwB,EAAcX,EAAO,CACnB/gB,WAAY5K,EAAK4K,WACjBG,MAAO/K,EAAK+K,MACZC,IAAKhL,EAAKgL,MAEZ,MAEF,IAAK,OACHshB,EAAcX,EAAO,CACnBsB,SAAUjtB,EAAK0K,MAAQ1K,EAAK0K,KAAKsC,MAAM,KAAM,GAAG,KAElD,MAEF,IAAK,aACH2e,EAAMlsB,SAAWO,EAAK1G,MACtBqyB,EAAMuB,QAAS,EACf,MAEF,IAAK,OACHZ,EAAcX,EAAO,CACnB5gB,MAAO/K,EAAK+K,YAASzM,EACrBnD,OAAmC,mBAApBywB,EAAKuB,WAA4BvB,EAAKuB,WAAWntB,EAAKgL,IAAKhL,EAAKP,SAAUO,EAAK+K,OAAS6gB,EAAKuB,WAC5GC,KAAMxB,EAAKyB,iBAAmBzB,EAAKyB,iBAAiBrtB,EAAKgL,IAAKhL,EAAKP,SAAUO,EAAK+K,OAAS/K,EAAKgL,MAElG,MAEF,IAAK,QACHshB,EAAcX,EAAO,CACnB/vB,IAAKgwB,EAAK0B,kBAAoB1B,EAAK0B,kBAAkBttB,EAAKgL,IAAKhL,EAAKP,SAAUO,EAAK+K,MAAO/K,EAAKsL,KAAOtL,EAAKgL,IAC3GM,IAAKtL,EAAKsL,KAAO,GACjBP,MAAO/K,EAAK+K,YAASzM,IAEvB,MAEF,IAAK,gBACHguB,EAAcX,EAAOX,EAAMoB,EAAK,CAC9BgB,KAAMxB,EAAKyB,iBAAmBzB,EAAKyB,iBAAiBjB,EAAIgB,MAAQhB,EAAIgB,QAEtE,MAEF,IAAK,iBACHd,EAAcX,EAAO,CACnB/vB,IAAKgwB,EAAK0B,mBAAqBlB,EAAIgB,KAAOxB,EAAK0B,kBAAkBlB,EAAIgB,KAAMptB,EAAKP,SAAU2sB,EAAIrhB,MAAO/K,EAAKsL,KAAO8gB,EAAIgB,KACrH9hB,IAAKtL,EAAKsL,KAAO,GACjBP,MAAOqhB,EAAIrhB,YAASzM,IAEtB,MAEF,IAAK,QACL,IAAK,YACL,IAAK,YACHqtB,EAAM4B,gBAAkBvtB,EAAKxC,MAC7B,MAEF,IAAK,WACHmuB,EAAM6B,SAAgC,cAArBttB,EAAOF,KAAKR,KAC7BmsB,EAAM4B,gBAAkBrtB,EAAOyrB,MAAM4B,gBACrC,MAEF,IAAK,YACHjB,EAAcX,EAAO,CACnB6B,SAAUttB,EAAOyrB,MAAM6B,SACvBhwB,MAAO0C,EAAOyrB,MAAM4B,gBAAgBl0B,KAEtC,MAEF,IAAK,cACHsyB,EAAM8B,IAAMztB,EAAKytB,IACjB,MAEF,IAAK,OAEH9B,EAAM+B,QAAU1tB,EAAKa,SAASzD,MAAMN,OAASkD,EAAKa,SAASvD,IAAIR,KAC/D6uB,EAAMgC,mBAAqB/B,EAAK+B,mBAChChC,EAAMiC,WAAahC,EAAKgC,WACxBjC,EAAMkC,SAAWjC,EAAKiC,SACtB,MAEF,IAAK,aAED,IAAIC,EAEA9tB,EAAKP,WACPquB,EAAiB9tB,EAAKP,SAASmS,KAAI,SAAUlS,EAAOzD,GAClD,OAAOivB,EAAWxrB,EAAOksB,EAAM,CAC7B5rB,KAAMA,EACN2rB,MAAOA,GACN1vB,OAIP0vB,EAAMgC,mBAAqB/B,EAAK+B,mBAChChC,EAAMiC,WAAahC,EAAKgC,WACxBjC,EAAMkC,SAAWjC,EAAKiC,SACtBlC,EAAMoC,QAAU/tB,EAAK+tB,QA+B7B,SAA2B/tB,EAAM8tB,GAC/B,IAAItD,EAAKxqB,EAAK+tB,QAEd,GAAIrzB,MAAMF,QAAQgwB,GAAK,CAErB,IAAIsB,EAAWf,EAAMe,UAAY,MACjC,OAAOf,EAAMH,cAAckB,EAAU,KAAMtB,GAG7C,GAAIA,EAAGmB,MAAMlsB,UAAYquB,EAAgB,CACvC,IAAIruB,EAAWsrB,EAAMiD,SAASC,QAAQzD,EAAGmB,MAAMlsB,UAAUhC,OAAOqwB,GAChE,OAAO/C,EAAMmD,aAAa1D,EAAI,KAAM/qB,GAGtC,OAAOsrB,EAAMmD,aAAa1D,EAAI,MA7CO2D,CAAkBnuB,EAAM8tB,GAAkB,KACzE,MAGJ,QACExB,EAAcX,EAAOX,EAAMhrB,EAAM,CAC/BR,UAAMlB,EACNuC,cAAUvC,EACVmB,cAAUnB,KAYhB,OARKutB,GAAoB7rB,EAAK1G,QAC5BqyB,EAAMryB,MAAQ0G,EAAK1G,OAGhBuyB,IACHF,EAAM3rB,KAAOA,GAGR2rB,EAGT,SAASW,EAAcnxB,EAAQizB,GAC7B,IAAK,IAAItzB,KAAOszB,OACY,IAAfA,EAAMtzB,KACfK,EAAOL,GAAOszB,EAAMtzB,IAkD1B,SAAS6xB,EAAc3sB,GACrB,IAAIyL,EAASzL,EAAKyL,OAGlB,OAAOA,QAA0CzL,EAAKP,SAAS9F,OAAS,EAAI8R,EAG9EzS,EAAOC,QAAUiyB,G,mCC9RjB,IAAIxpB,EAAQ,EAAQ,OAEpB1I,EAAOC,QAAU,SAAwB2G,GACvC,IAAIysB,EAAcrwB,UAAUrC,OAAS,QAAsB2E,IAAjBtC,UAAU,GAAmBA,UAAU,GAAK,GAStF,OARA0F,EAAM9B,EAAM,cAAc,SAAUI,GAClC,IAAI4K,EAAa5K,EAAK4K,WAAWqe,cAC7Bre,KAAcyhB,IAClBA,EAAYzhB,GAAc,CACxBwiB,KAAMptB,EAAKgL,IACXD,MAAO/K,EAAK+K,WAGTshB,I,mCCZT,IAAI3qB,EAAQ,EAAQ,OAEhB7C,EAAS,GAAGA,OAYhB,SAASwvB,EAAWC,EAAOC,GACzB,OAEA,SAAmB3uB,GAEjB,OADA8B,EAAM9B,EAAM4uB,GACL5uB,GAIT,SAAS4uB,EAAOxuB,EAAM3G,EAAO6G,GAC3B,GAAIA,IAAWouB,EAAMtuB,EAAM3G,EAAO6G,GAAS,CACzC,IAAI8mB,EAAa,CAAC3tB,EAAO,GAOzB,MALa,WAATk1B,GAAqBvuB,EAAKP,WAC5BunB,EAAaA,EAAWvpB,OAAOuC,EAAKP,WAGtCZ,EAAOqC,MAAMhB,EAAOT,SAAUunB,GACvB3tB,IA5BbJ,EAAQw1B,OAAS,SAAUC,EAAOH,GAChC,OAAOF,GAEP,SAAeruB,EAAM3G,EAAO6G,GAC1B,OAAQwuB,EAAMC,SAAS3uB,EAAKR,QAHL+uB,IAO3Bt1B,EAAQo1B,WAAaA,G,mCCPrB,IAAI3sB,EAAQ,EAAQ,OAEhBlC,EAAO,cACPovB,EAAgB,2FAChBC,EAAc,uBAElB71B,EAAOC,QAAU,SAAU2G,GACzB,IAAIyK,EACAykB,EAmCJ,OAlCAptB,EAAM9B,EAAM,QAAQ,SAAUI,EAAM3G,EAAO6G,GACrC4uB,IAAkB5uB,IACpBmK,EAAO,GACPykB,EAAgB5uB,GAGlB,IAAI6uB,EAoDR,SAAwB/uB,GACtB,IAAIc,EAAQd,EAAK1G,MAAMwH,MAAM8tB,GAC7B,QAAO9tB,GAAQA,EAAM,GAtDDkuB,CAAehvB,GAEjC,GAAI+uB,EAMF,OALA7uB,EAAOT,SAASZ,OAAOxF,EAAO,EAAG,CAC/BmG,KAAMA,EACNiuB,IAAKsB,EACLluB,SAAUb,EAAKa,YAEV,EAGT,IAAIouB,EAgCR,SAAsBjvB,EAAME,GAC1B,IAAIY,EAAQd,EAAK1G,MAAMwH,MAAM+tB,GAC7B,QAAO/tB,GAAQ,CACb2sB,IAAK3sB,EAAM,GACXouB,SAAUpuB,EAAM,GAChBd,KAAMA,GArCQmvB,CAAanvB,GAE3B,IAAKivB,EACH,OAAO,EAGT,IAAIG,EAcR,SAAqB/kB,EAAMglB,GACzB,IAAIpzB,EAAIoO,EAAK1Q,OAEb,KAAOsC,KACL,GAAIoO,EAAKpO,GAAGwxB,MAAQ4B,EAClB,OAAOhlB,EAAKxL,OAAO5C,EAAG,GAAG,GAI7B,OAAO,EAvBUqzB,CAAYjlB,EAAM4kB,EAAQxB,KAQzC,OANI2B,EACFlvB,EAAOT,SAASZ,OAAOxF,EAAO,EAqCpC,SAAiBk2B,EAAUC,EAAQtvB,GACjC,IAAIuvB,EAAYvvB,EAAOT,SAAS/F,QAAQ61B,EAASvvB,MAC7C0vB,EAAUxvB,EAAOT,SAAS/F,QAAQ81B,EAAOxvB,MAEzCP,EADYS,EAAOT,SAASZ,OAAO4wB,EAAWC,EAAUD,EAAY,GAC/CruB,MAAM,GAAI,GACnC,MAAO,CACL5B,KAAMA,EACNC,SAAUA,EACVguB,IAAK8B,EAAS9B,IACd5sB,SAAU,CACRzD,MAAOmyB,EAASvvB,KAAKa,SAASzD,MAC9BE,IAAKkyB,EAAOxvB,KAAKa,SAASvD,IAC1BqyB,OAAQ,KAjDyBC,CAAQX,EAASG,EAAUlvB,IAClD+uB,EAAQC,SAClB7kB,EAAK9L,KAAK0wB,IAGL,KACN,GAEIrvB,I,mCChDT,IAAIorB,EAAQ,EAAQ,MAEhB6E,EAAU,EAAQ,OAElBC,EAAQ,EAAQ,MAEhBC,EAAY,EAAQ,OAEpBC,EAAkB,EAAQ,OAE1BC,EAAY,EAAQ,OAEpBC,EAAe,EAAQ,OAEvBhF,EAAa,EAAQ,OAErBiF,EAAgB,EAAQ,OAExBC,EAAiB,EAAQ,OAEzBC,EAAiB,EAAQ,OAEzBC,EAAmB,EAAQ,OAE3BC,EAAU,EAAQ,OAElBC,EAAWx2B,OAAOy2B,KAAKH,GAEvBI,EAAgB,SAAuB/E,GAEzC,IAAI/vB,EAAM+vB,EAAMxyB,QAAUwyB,EAAMlsB,UAAY,GAE5C,GAAIksB,EAAMgF,cAAgBhF,EAAMiF,gBAC9B,MAAM,IAAIn3B,MAAM,sEAGlB,IAAI2xB,EAAYJ,EAAMsF,EAAkB3E,EAAMP,WAC1CyF,EAAYhB,IAAUtR,IAAIuR,GAAOvR,IAAIoN,EAAMmF,SAAW,IAEtDlxB,EAAOixB,EAAUE,QAAQF,EAAUf,MAAMl0B,IACzCo1B,EAAchG,EAAMW,EAAO,CAC7BP,UAAWA,EACXiB,YAAa+D,EAAexwB,KAK9B,OAGF,SAAuC+rB,GACrC,IAAIrpB,EAAa,CAAC6tB,EAAeH,KAC7BY,EAAkBjF,EAAMiF,gBAExBjF,EAAMgF,eACRC,EAAkBJ,EAAShC,QAAO,SAAUhvB,GAC1C,MAAgB,SAATA,IAAyD,IAAtCmsB,EAAMgF,aAAaj3B,QAAQ8F,OAIzD,IAAIyxB,EAAgBtF,EAAMuF,iBAAmB,SAAW,SAEpDN,GAAmBA,EAAgBj3B,OAAS,GAC9C2I,EAAW/D,KAAK2xB,EAAazB,OAAOmC,EAAiBK,IAGnDtF,EAAMwF,WACR7uB,EAAW/D,KAAK2xB,EAAa7B,WAAW1C,EAAMwF,UAAWF,IAI3D,IAAIG,GAAczF,EAAMgC,qBAA2C,IAArBhC,EAAMiC,cAA0BjC,EAAMkC,SAChFwD,GAAiB1F,EAAM2F,YAAc,IAAIC,MAAK,SAAUC,GAC1D,OAAOA,EAAUC,WAAalB,EAAQmB,cAGpCN,IAAeC,GACjB/uB,EAAW/D,KAAK0xB,GAGdtE,EAAM2F,aACRhvB,EAAaA,EAAW7E,OAAOkuB,EAAM2F,aAKvC,OADAhvB,EAAW/D,KAAK2sB,GACT5oB,EA1CPqvB,CAA8BhG,GAAOiG,SAAQ,SAAUJ,GACrD5xB,EAAO4xB,EAAU5xB,EAAMoxB,MAElBpxB,GA0CT8wB,EAAcmB,aAAe,CAC3BxE,iBAAkBgD,GAEpBK,EAAcoB,UAAY,CACxBvF,UAAWwD,EAAUn2B,OACrBT,OAAQ42B,EAAUn2B,OAClB6F,SAAUswB,EAAUn2B,OACpBmyB,UAAWgE,EAAUgC,KACrB/F,aAAc+D,EAAUgC,KACxBnE,WAAYmC,EAAUgC,KACtBpE,mBAAoBoC,EAAUgC,KAC9BlE,SAAUkC,EAAUgC,KACpBZ,UAAWpB,EAAUiC,KACrBrB,aAAcZ,EAAUkC,QAAQlC,EAAUmC,MAAM1B,IAChDI,gBAAiBb,EAAUkC,QAAQlC,EAAUmC,MAAM1B,IACnDnD,iBAAkB0C,EAAUoC,UAAU,CAACpC,EAAUiC,KAAMjC,EAAUgC,OACjE5E,WAAY4C,EAAUoC,UAAU,CAACpC,EAAUiC,KAAMjC,EAAUn2B,SAC3D0zB,kBAAmByC,EAAUiC,KAC7BV,WAAYvB,EAAUkC,QAAQlC,EAAUiC,MACxCd,iBAAkBnB,EAAUgC,KAC5B3G,UAAW2E,EAAU1G,OACrByH,QAASf,EAAUjD,OAErB4D,EAAchC,MAAQ8B,EACtBE,EAActF,UAAYkF,EAC1BI,EAAcL,eAAiBA,EAC/Br3B,EAAOC,QAAUy3B,G,mCClHjB,IAAI1F,EAAQ,EAAQ,MAEhBD,EAAQ,EAAQ,OAIhBqH,EAAuB3nB,UAAUsgB,EAAMsH,SAAW,MAAMjxB,MAAM,EAAG,GAAI,KAAO,GAC5EwpB,EAAgBG,EAAMH,cA+C1B,SAAS0H,EAAe7E,EAAK9B,GAC3B,OAAOf,EAAc6C,EAAK8E,EAAa5G,GAAQA,EAAMlsB,UA0FvD,SAAS8yB,EAAa5G,GACpB,IAAIxyB,EAASwyB,EAAM,kBAGnB,OAAOxyB,EAAS,CACd,iBAAkBA,GAChB,GA/INH,EAAOC,QAAU,CACfu5B,MAAO,KACPptB,UAAW,IACXlB,SAAU,KACVyB,OAAQ,SACRC,cAAe,KACf6sB,WAAY,aACZnkB,OAAQ,MACR3L,KAAM,IACNgC,MAAO,MACP+tB,cAAe,IACfC,eAAgB,MAChBr2B,MAAOg2B,EAAeM,KAAK,KAAM,SACjCC,UAAWP,EAAeM,KAAK,KAAM,SACrCE,UAAWR,EAAeM,KAAK,KAAM,SACrC/jB,SAAUyjB,EAAeM,KAAK,KAAM,MACpCpjB,UAkCF,SAAmBmc,GACjB,IAAIra,EAAQqa,EAAMnuB,MAAQ,CACxBu1B,UAAWpH,EAAMnuB,YACfc,EACA00B,EAAYT,EAAa5G,GAC7B,OAAOf,EAAce,EAAM6B,SAAW,KAAO,KAAMlc,EAAQ0Z,EAAM,CAC/D1Z,MAAOA,GACN0hB,GAAaA,EAAWrH,EAAMlsB,WAxCjCwzB,KAqBF,SAActH,GACZ,IAAIY,EAAYZ,EAAMY,UAClB0G,GAAQ1G,GAAaxB,EAAMe,UAAY,MAC3C,OAAOlB,EAAcqI,EAAM1G,EAAY,CACrCA,UAAWA,GACT,KAAMZ,EAAMlsB,WAzBhB0L,KAYF,SAAsBwgB,GAEpB,IAAIlsB,EAAWksB,EAAMlsB,UAAY,GAGjC,OAAO2yB,EAAuB3yB,EAAWmrB,EAAc,OAAQ,KAAMnrB,IAhBrEwF,KA6CF,SAAc0mB,GACZ,IAAIyC,EAAQmE,EAAa5G,GAEL,OAAhBA,EAAMvuB,OAAkC,IAAhBuuB,EAAMvuB,YAA+BkB,IAAhBqtB,EAAMvuB,QACrDgxB,EAAMhxB,MAAQuuB,EAAMvuB,MAAMhD,YAG5B,OAAOwwB,EAAce,EAAMhsB,QAAU,KAAO,KAAMyuB,EAAOzC,EAAMlsB,WAnD/DoF,SAsDF,SAAkB8mB,GAChB,IAAIuH,EAAW,KAEf,GAAsB,OAAlBvH,EAAMjgB,cAAsCpN,IAAlBqtB,EAAMjgB,QAAuB,CACzD,IAAIA,EAAUigB,EAAMjgB,QACpBwnB,EAAWtI,EAAc,QAAS,CAChCprB,KAAM,WACNkM,QAASA,EACTynB,UAAU,IAId,OAAOvI,EAAc,KAAM2H,EAAa5G,GAAQuH,EAAUvH,EAAMlsB,WAjEhEqE,WAgHF,WACE,OAAO,MAhHPd,QAsCF,SAAiB2oB,GACf,OAAOf,EAAc,IAAIntB,OAAOkuB,EAAMc,OAAQ8F,EAAa5G,GAAQA,EAAMlsB,WAtCzEiQ,WA0EF,SAAoBic,GAClB,OAAOf,EAAc,OAAQ2H,EAAa5G,GAAQA,EAAMlsB,WA1ExDxC,KAiEF,SAAmB0uB,GACjB,IAAIY,EAAYZ,EAAMsB,UAAY,YAAYxvB,OAAOkuB,EAAMsB,UACvDhwB,EAAO2tB,EAAc,OAAQ2B,EAAY,CAC3CA,UAAWA,GACT,KAAMZ,EAAMryB,OAChB,OAAOsxB,EAAc,MAAO2H,EAAa5G,GAAQ1uB,IArEjDsH,KA4EF,SAAconB,GACZ,GAAIA,EAAMkC,SACR,OAAO,KAGT,IAAIuF,EAAYzH,EAAMgC,qBAA2C,IAArBhC,EAAMiC,WAC9CH,EAAM9B,EAAM+B,QAAU,MAAQ,OAElC,IAAK0F,EAEH,OAAOxI,EAAcG,EAAMe,UAAY2B,EAAK,KAAM9B,EAAMryB,OAG1D,IAAIiyB,EAAY,CACd8H,wBAAyB,CACvBC,OAAQ3H,EAAMryB,QAGlB,OAAOsxB,EAAc6C,EAAKlC,IA7F1BgI,YAuGF,SAAqB5H,GACnB,OAAOf,EAAce,EAAM8B,IAAK8E,EAAa5G,GAAQA,EAAMlsB,WAvG3D+zB,WA+FF,SAAoB7H,GAElB,OAAOA,EAAM,kBAAoBZ,EAAMmD,aAAavC,EAAMoC,QAAS,CACjE,iBAAkBpC,EAAM,oBACrBA,EAAMoC,W,iCCvIb,IAAI2D,EAAa,sBAGjBz4B,EAAQy4B,WAA+B,oBAAX+B,OAAyB/B,EAAa+B,OAAO/B,I,+BCHzE,IAAIgC,EAAY,CAAC,OAAQ,QAAS,SAAU,OAE5C16B,EAAOC,QAAU,SAAwB06B,GACvC,IAAI3oB,GAAO2oB,GAAO,IAAIC,OAClBC,EAAQ7oB,EAAI2F,OAAO,GAEvB,GAAc,MAAVkjB,GAA2B,MAAVA,EACnB,OAAO7oB,EAGT,IAAIvM,EAAQuM,EAAItR,QAAQ,KAExB,IAAe,IAAX+E,EACF,OAAOuM,EAMT,IAHA,IAAIrR,EAAS+5B,EAAU/5B,OACnBN,GAAS,IAEJA,EAAQM,GAAQ,CACvB,IAAI8S,EAAWinB,EAAUr6B,GAEzB,GAAIoF,IAAUgO,EAAS9S,QAAUqR,EAAI5J,MAAM,EAAGqL,EAAS9S,QAAQmR,gBAAkB2B,EAC/E,OAAOzB,EAMX,OAAe,KAFf3R,EAAQ2R,EAAItR,QAAQ,OAEA+E,EAAQpF,IAMb,KAFfA,EAAQ2R,EAAItR,QAAQ,OAEA+E,EAAQpF,EALnB2R,EAUF,uB,mCCxCT,IAAItJ,EAAQ,EAAQ,OAOpB,SAASoyB,EAAKx3B,GACZ,IAAImD,EAAWnD,EAAMmD,SACrBnD,EAAMmD,SAAW,CAAC,CAChBD,KAAM,YACNhC,MAAOlB,EAAMkB,MACbiC,SAAU,CAACA,EAAS,IACpBoB,SAAUpB,EAAS,GAAGoB,WAGpBpB,EAAS9F,OAAS,GACpB2C,EAAMmD,SAASlB,KAAK,CAClBiB,KAAM,YACNhC,MAAOlB,EAAMkB,MACbiC,SAAUA,EAAS2B,MAAM,GACzBP,SAAU,CACRzD,MAAOqC,EAAS,GAAGoB,SAASzD,MAC5BE,IAAKmC,EAASA,EAAS9F,OAAS,GAAGkH,SAASvD,OArBpDtE,EAAOC,QAAU,SAAU+G,GAEzB,OADA0B,EAAM1B,EAAM,QAAS8zB,GACd9zB,I,kCCJThH,EAAOC,QAIP,SAAemC,GACb,IAAIyY,EAAOtJ,KACXA,KAAKwpB,OAEL,SAAeC,GACb,OAAOC,EAAaD,EAAKh6B,OAAOmP,OAAO,GAAI0K,EAAKjQ,KAAK,YAAaxI,EAAS,CAIzE+G,WAAY0R,EAAKjQ,KAAK,wBAA0B,GAChD4E,gBAAiBqL,EAAKjQ,KAAK,2BAA6B,QAZ9D,IAAIqwB,EAAe,EAAQ,Q,mCCF3B,IAAIC,EAAO,EAAQ,OAEf3wB,EAAS,EAAQ,OAEjB5H,EAAS,EAAQ,OAEjBw4B,EAAQ,EAAQ,OAEhBC,EAAS,EAAQ,OAEjBC,EAAQ,EAAQ,OAGpBr7B,EAAOC,QAoCP,SAAS42B,IACP,IAIIyE,EAJAC,EAAY,GACZC,EAAeJ,IACfK,EAAY,GACZC,GAAe,EAiBnB,OAdA7D,EAAUjtB,KAoEV,SAAc9I,EAAKxB,GACjB,GAAmB,iBAARwB,EAET,OAAyB,IAArBkB,UAAUrC,QACZg7B,EAAe,OAAQL,GACvBG,EAAU35B,GAAOxB,EACVu3B,GAIF3nB,EAAIvO,KAAK85B,EAAW35B,IAAQ25B,EAAU35B,IAAQ,KAIvD,GAAIA,EAGF,OAFA65B,EAAe,OAAQL,GACvBG,EAAY35B,EACL+1B,EAIT,OAAO4D,GAvFT5D,EAAU+D,OAASA,EAEnB/D,EAAU0D,UAAYA,EACtB1D,EAAUtS,IA8FV,SAAajlB,GACX,IAAI4D,EAGJ,GAFAy3B,EAAe,MAAOL,GAElBh7B,cACG,GAAqB,mBAAVA,EAChBu7B,EAAU3zB,MAAM,KAAMlF,eACjB,IAAqB,iBAAV1C,EAOhB,MAAM,IAAIG,MAAM,+BAAiCH,EAAQ,KANrD,WAAYA,EACdw7B,EAAQx7B,GAERy7B,EAAUz7B,GAMV4D,IACFu3B,EAAUv3B,SAAWvB,EAAO84B,EAAUv3B,UAAY,GAAIA,IAGxD,OAAO2zB,EAEP,SAASkE,EAAU90B,GACjB60B,EAAQ70B,EAAO6wB,SAEX7wB,EAAO/C,WACTA,EAAWvB,EAAOuB,GAAY,GAAI+C,EAAO/C,WAI7C,SAASkqB,EAAI9tB,GACX,GAAqB,mBAAVA,EACTu7B,EAAUv7B,OACL,IAAqB,iBAAVA,EAOhB,MAAM,IAAIG,MAAM,+BAAiCH,EAAQ,KANrD,WAAYA,EACdu7B,EAAU3zB,MAAM,KAAM5H,GAEtBy7B,EAAUz7B,IAOhB,SAASw7B,EAAQhE,GACf,IAAIz3B,GAAS,EAEb,GAAIy3B,aACG,IAAuB,iBAAZA,KAAwB,WAAYA,GAKpD,MAAM,IAAIr3B,MAAM,oCAAsCq3B,EAAU,KAJhE,OAASz3B,EAAQy3B,EAAQn3B,QACvBytB,EAAI0J,EAAQz3B,KAOlB,SAASw7B,EAAUG,EAAQ17B,GACzB,IAAI27B,EAAQ50B,EAAK20B,GAEbC,GACEd,EAAMc,EAAM,KAAOd,EAAM76B,KAC3BA,EAAQqC,GAAO,EAAMs5B,EAAM,GAAI37B,IAGjC27B,EAAM,GAAK37B,GAEXi7B,EAAUh2B,KAAK6C,EAAMzG,KAAKqB,cAhKhC60B,EAAUf,MAiLV,SAAekE,GACb,IACID,EADAmB,EAAOb,EAAML,GAMjB,GAJAY,IAEAO,EAAa,QADbpB,EAASlD,EAAUkD,QAGfqB,EAAQrB,EAAQ,SAClB,OAAO,IAAIA,EAAOx6B,OAAO27B,GAAOA,GAAMpF,QAGxC,OAAOiE,EAAOx6B,OAAO27B,GAAOA,IA3L9BrE,EAAUwE,UAkPV,SAAmBr1B,EAAMg0B,GACvB,IACIsB,EADAJ,EAAOb,EAAML,GAOjB,GALAY,IAEAW,EAAe,YADfD,EAAWzE,EAAUyE,UAErBE,EAAWx1B,GAEPo1B,EAAQE,EAAU,WACpB,OAAO,IAAIA,EAASt1B,EAAMk1B,GAAMzsB,UAGlC,OAAO6sB,EAASt1B,EAAMk1B,IA7PxBrE,EAAU4E,IAAMA,EAChB5E,EAAUE,QAgOV,SAAiB/wB,EAAMk1B,GACrB,IAAIj1B,EACAy1B,EAGJ,OAFAD,EAAIz1B,EAAMk1B,EAAMhiB,GAChByiB,EAAW,UAAW,MAAOD,GACtBz1B,EAEP,SAASiT,EAAK0iB,EAAOh2B,GACnB81B,GAAW,EACXz1B,EAASL,EACTs0B,EAAK0B,KAzOT/E,EAAUgF,QAAUA,EACpBhF,EAAUiF,YA+RV,SAAqB9B,GACnB,IAAIkB,EACAQ,EAOJ,OANAd,IACAO,EAAa,cAAetE,EAAUkD,QACtCwB,EAAe,cAAe1E,EAAUyE,UAExCO,EADAX,EAAOb,EAAML,GACC9gB,GACdyiB,EAAW,cAAe,UAAWD,GAC9BR,EAEP,SAAShiB,EAAK0iB,GACZF,GAAW,EACXxB,EAAK0B,KA1SF/E,EAEP,SAASA,IAIP,IAHA,IAAIkF,EAAclG,IACdx2B,GAAS,IAEJA,EAAQk7B,EAAU56B,QACzBo8B,EAAYxX,IAAIrd,MAAM,KAAMqzB,EAAUl7B,IAIxC,OADA08B,EAAYnyB,KAAKjI,GAAO,EAAM,GAAI84B,IAC3BsB,EAUT,SAASnB,IACP,IAAI7iB,EACAikB,EAEJ,GAAI1B,EACF,OAAOzD,EAGT,OAAS6D,EAAcH,EAAU56B,SAGb,KAFlBoY,EAASwiB,EAAUG,IAER,MAIO,IAAd3iB,EAAO,KACTA,EAAO,QAAKzT,GAKa,mBAF3B03B,EAAcjkB,EAAO,GAAG7Q,MAAM2vB,EAAW9e,EAAO3Q,MAAM,MAGpDozB,EAAajW,IAAIyX,IAMrB,OAFA1B,GAAS,EACTI,EAActT,IACPyP,EA6GT,SAASxwB,EAAK20B,GAGZ,IAFA,IAAI37B,GAAS,IAEJA,EAAQk7B,EAAU56B,QACzB,GAAI46B,EAAUl7B,GAAO,KAAO27B,EAC1B,OAAOT,EAAUl7B,GAuBvB,SAASo8B,EAAIz1B,EAAMk1B,EAAMe,GASvB,GARAT,EAAWx1B,GACX40B,IAEKqB,GAAsB,mBAATf,IAChBe,EAAKf,EACLA,EAAO,OAGJe,EACH,OAAO,IAAIC,QAAQC,GAKrB,SAASA,EAASre,EAASse,GACzB5B,EAAaiB,IAAIz1B,EAAMq0B,EAAMa,IAE7B,SAAcU,EAAOh2B,EAAMs1B,GACzBt1B,EAAOA,GAAQI,EAEX41B,EACFQ,EAAOR,GACE9d,EACTA,EAAQlY,GAERq2B,EAAG,KAAMr2B,EAAMs1B,MAbrBiB,EAAS,KAAMF,GAwDjB,SAASJ,EAAQ7B,EAAKiC,GAKpB,GAJArB,IACAO,EAAa,UAAWtE,EAAUkD,QAClCwB,EAAe,UAAW1E,EAAUyE,WAE/BW,EACH,OAAO,IAAIC,QAAQC,GAKrB,SAASA,EAASre,EAASse,GACzB,IAAIlB,EAAOb,EAAML,GACjBqC,EAASZ,IAAI5E,EAAW,CACtBqE,KAAMA,IAGR,SAAcU,GACRA,EACFQ,EAAOR,GACE9d,EACTA,EAAQod,GAERe,EAAG,KAAMf,MAdfiB,EAAS,KAAMF,IAjUFpG,GAAU+E,SAC3B,IAAIxzB,EAAQ,GAAGA,MACX8H,EAAM,GAAGhP,eAETm8B,EAAWjC,IAAS7V,KAExB,SAAuBnK,EAAGkiB,GACxBA,EAAI12B,KAAOwU,EAAE0b,MAAMwG,EAAIpB,SAHkB3W,KAM3C,SAAqBnK,EAAGkiB,EAAKjc,GAC3BjG,EAAEqhB,IAAIa,EAAI12B,KAAM02B,EAAIpB,MAEpB,SAAcU,EAAOh2B,EAAMs1B,GACrBU,EACFvb,EAAKub,IAELU,EAAI12B,KAAOA,EACX02B,EAAIpB,KAAOA,EACX7a,WAfsDkE,KAoB5D,SAA2BnK,EAAGkiB,GAC5B,IAAIr2B,EAASmU,EAAEihB,UAAUiB,EAAI12B,KAAM02B,EAAIpB,MAEnCj1B,UACyB,iBAAXA,GAAuBsD,EAAOtD,GAC9Cq2B,EAAIpB,KAAKqB,SAAWt2B,EAEpBq2B,EAAIpB,KAAKj1B,OAASA,MA0UtB,SAASm1B,EAAQ97B,EAAO+B,GACtB,MAAwB,mBAAV/B,GAAwBA,EAAMW,YAO9C,SAAcX,GACZ,IAAIwB,EAEJ,IAAKA,KAAOxB,EACV,OAAO,EAGT,OAAO,EAXPm3B,CAAKn3B,EAAMW,YAAcoB,KAAQ/B,EAAMW,WAezC,SAASk7B,EAAa95B,EAAM04B,GAC1B,GAAsB,mBAAXA,EACT,MAAM,IAAIt6B,MAAM,WAAa4B,EAAO,sBAKxC,SAASk6B,EAAel6B,EAAMi6B,GAC5B,GAAwB,mBAAbA,EACT,MAAM,IAAI77B,MAAM,WAAa4B,EAAO,wBAKxC,SAASs5B,EAAet5B,EAAMi5B,GAC5B,GAAIA,EACF,MAAM,IAAI76B,MAAM,kBAAoB4B,EAAO,qHAK/C,SAASm6B,EAAWx1B,GAClB,IAAKA,GAA6B,iBAAdA,EAAKR,KACvB,MAAM,IAAI/F,MAAM,uBAAyBuG,EAAO,KAKpD,SAAS21B,EAAWt6B,EAAMm7B,EAAWd,GACnC,IAAKA,EACH,MAAM,IAAIj8B,MAAM,IAAM4B,EAAO,0BAA4Bm7B,EAAY,e,mCCvazE,IAMIC,EANAC,EAAS,EAAQ,OAEjBzC,EAAe,EAAQ,OAEvB0C,EAAa,EAAQ,OAGzB39B,EAAOC,QAEP,SAAamC,GACX,IAAIwI,EAAO2G,KAAK3G,QAGX6yB,IAAkBlsB,KAAKwpB,QAAUxpB,KAAKwpB,OAAO95B,WAAasQ,KAAKwpB,OAAO95B,UAAU28B,iBAAmBrsB,KAAK+qB,UAAY/qB,KAAK+qB,SAASr7B,WAAasQ,KAAK+qB,SAASr7B,UAAU48B,YAC1KJ,GAAgB,EAChBK,QAAQC,KAAK,yEAOf,SAAS3P,EAAIvK,EAAOvjB,GAEdsK,EAAKiZ,GAAQjZ,EAAKiZ,GAAOte,KAAKjF,GAAYsK,EAAKiZ,GAAS,CAACvjB,GAN/D8tB,EAAI,sBAAuBsP,EAAOt7B,IAClCgsB,EAAI,yBAA0B6M,GAC9B7M,EAAI,uBAAwBuP,EAAWv7B,M,+BCXzC,IACI47B,EADAC,EAAM,GAMVj+B,EAAOC,QAmBP,SAAgBi+B,EAAKC,GACnB,GAAmB,iBAARD,EACT,MAAM,IAAIr9B,UAAU,qBAItB,GAAY,IAARs9B,EAAW,OAAOD,EACtB,GAAY,IAARC,EAAW,OAAOD,EAAMA,EAC5B,IAAIt4B,EAAMs4B,EAAIv9B,OAASw9B,EAEvB,GAAIH,IAAUE,QAAwB,IAAVF,EAC1BA,EAAQE,EACRD,EAAM,QACD,GAAIA,EAAIt9B,QAAUiF,EACvB,OAAOq4B,EAAIG,OAAO,EAAGx4B,GAGvB,KAAOA,EAAMq4B,EAAIt9B,QAAUw9B,EAAM,GACrB,EAANA,IACFF,GAAOC,GAGTC,IAAQ,EACRD,GAAOA,EAKT,OADAD,GADAA,GAAOC,GACGE,OAAO,EAAGx4B,K,mCC7DtB,IAAIk1B,EAAO,EAAQ,OAEnB96B,EAAOC,QAAUm7B,EACjBA,EAAON,KAAOA,EACd,IAAI1yB,EAAQ,GAAGA,MAEf,SAASgzB,IACP,IAAIiD,EAAM,GACNC,EAAa,CACjB,IAIA,WACE,IAAIj+B,GAAS,EACT8H,EAAQC,EAAMzG,KAAKqB,UAAW,GAAI,GAClCkX,EAAOlX,UAAUA,UAAUrC,OAAS,GAExC,GAAoB,mBAATuZ,EACT,MAAM,IAAIzZ,MAAM,2CAA6CyZ,GAK/D,SAASmH,EAAKnhB,GACZ,IAAIq+B,EAAKF,IAAMh+B,GACXm+B,EAASp2B,EAAMzG,KAAKqB,UAAW,GAC/B+V,EAASylB,EAAOp2B,MAAM,GACtBzH,EAASwH,EAAMxH,OACf0xB,GAAO,EAEX,GAAInyB,EACFga,EAAKha,OADP,CAMA,OAASmyB,EAAM1xB,GACO,OAAhBoY,EAAOsZ,SAAiC/sB,IAAhByT,EAAOsZ,KACjCtZ,EAAOsZ,GAAOlqB,EAAMkqB,IAIxBlqB,EAAQ4Q,EAEJwlB,EACFzD,EAAKyD,EAAIld,GAAMnZ,MAAM,KAAMC,GAE3B+R,EAAKhS,MAAM,KAAM,CAAC,MAAMzD,OAAO0D,KA1BnCkZ,EAAKnZ,MAAM,KAAM,CAAC,MAAMzD,OAAO0D,KAZjC,IA4CA,SAAao2B,GACX,GAAkB,mBAAPA,EACT,MAAM,IAAI99B,MAAM,uCAAyC89B,GAI3D,OADAF,EAAI94B,KAAKg5B,GACFD,IAjDT,OAAOA,I,+BCXT,IAAIl2B,EAAQ,GAAGA,MACfpI,EAAOC,QAIP,SAAcs+B,EAAIE,GAChB,IAAIC,EACJ,OAEA,WACE,IAEIz3B,EAFAu3B,EAASp2B,EAAMzG,KAAKqB,UAAW,GAC/By7B,EAAWF,EAAG59B,OAAS69B,EAAO79B,OAG9B89B,GACFD,EAAOj5B,KAAK2U,GAGd,IACEjT,EAASs3B,EAAGr2B,MAAM,KAAMs2B,GACxB,MAAO5B,GAMP,GAAI6B,GAAYC,EACd,MAAM9B,EAGR,OAAO1iB,EAAK0iB,GAGT6B,IACCx3B,GAAiC,mBAAhBA,EAAO03B,KAC1B13B,EAAO03B,KAAKA,EAAMzkB,GACTjT,aAAkBxG,MAC3ByZ,EAAKjT,GAEL03B,EAAK13B,KAMX,SAASiT,IACFwkB,IACHA,GAAU,EACVD,EAASv2B,MAAM,KAAMlF,YAMzB,SAAS27B,EAAKr+B,GACZ4Z,EAAK,KAAM5Z,M,+BCrDf,SAASqI,EAAQoL,GACf,GAAY,MAARA,EACF,OAAOwF,EAGT,GAAoB,iBAATxF,EACT,OAuDJ,SAAqBA,GACnB,OAAOvN,EAEP,SAASA,EAAKQ,GACZ,OAAO43B,QAAQ53B,GAAQA,EAAKR,OAASuN,IA3D9B8qB,CAAY9qB,GAGrB,GAAoB,iBAATA,EACT,MAAO,WAAYA,EA0BvB,SAAoB+qB,GAClB,IAAIC,EAAS,GACT1+B,GAAS,EAEb,OAASA,EAAQy+B,EAAMn+B,QACrBo+B,EAAO1+B,GAASsI,EAAQm2B,EAAMz+B,IAGhC,OAAO2+B,EAEP,SAASA,IAGP,IAFA,IAAI3+B,GAAS,IAEJA,EAAQ0+B,EAAOp+B,QACtB,GAAIo+B,EAAO1+B,GAAO6H,MAAMqJ,KAAMvO,WAC5B,OAAO,EAIX,OAAO,GA7CmBi8B,CAAWlrB,GAYzC,SAAoBA,GAClB,OAAO3M,EAEP,SAASA,EAAIJ,GACX,IAAIlF,EAEJ,IAAKA,KAAOiS,EACV,GAAI/M,EAAKlF,KAASiS,EAAKjS,GAAM,OAAO,EAGtC,OAAO,GAtBsCo9B,CAAWnrB,GAG1D,GAAoB,mBAATA,EACT,OAAOA,EAGT,MAAM,IAAItT,MAAM,gDAqDlB,SAAS8Y,IACP,OAAO,EAzETvZ,EAAOC,QAAU0I,G,8BCAjB,IAAIuH,EAAM,GAAGhP,eA4Bb,SAASoP,EAAMA,GAKb,OAJKA,GAA0B,iBAAVA,IACnBA,EAAQ,IAGHjQ,EAAMiQ,EAAMxM,MAAQ,IAAMzD,EAAMiQ,EAAMC,QAG/C,SAAS1I,EAASwqB,GAKhB,OAJKA,GAAsB,iBAARA,IACjBA,EAAM,IAGD/hB,EAAM+hB,EAAIjuB,OAAS,IAAMkM,EAAM+hB,EAAI/tB,KAG5C,SAASjE,EAAMC,GACb,OAAOA,GAA0B,iBAAVA,EAAqBA,EAAQ,EA5CtDN,EAAOC,QAEP,SAAmBK,GAEjB,IAAKA,GAA0B,iBAAVA,EACnB,MAAO,GAIT,GAAI4P,EAAIvO,KAAKrB,EAAO,aAAe4P,EAAIvO,KAAKrB,EAAO,QACjD,OAAOuH,EAASvH,EAAMuH,UAIxB,GAAIqI,EAAIvO,KAAKrB,EAAO,UAAY4P,EAAIvO,KAAKrB,EAAO,OAC9C,OAAOuH,EAASvH,GAIlB,GAAI4P,EAAIvO,KAAKrB,EAAO,SAAW4P,EAAIvO,KAAKrB,EAAO,UAC7C,OAAOgQ,EAAMhQ,GAIf,MAAO,K,kBC3BTN,EAAOC,QAEP,SAAkBiR,GAChB,OAAOA,I,mCCDTlR,EAAOC,QAAUk/B,EAEjB,IAAIx2B,EAAU,EAAQ,OAElBy2B,EAAQ,EAAQ,OAEhBC,GAAW,EACXC,EAAO,OACPC,GAAO,EAKX,SAASJ,EAAav4B,EAAMmN,EAAMlN,EAAS24B,GACzC,IAAIC,EACAC,EAEgB,mBAAT3rB,GAA0C,mBAAZlN,IACvC24B,EAAU34B,EACVA,EAAUkN,EACVA,EAAO,MAGT2rB,EAAK/2B,EAAQoL,GACb0rB,EAAOD,GAAW,EAAI,EAGtB,SAASG,EAAQ34B,EAAM3G,EAAOgG,GAC5B,IACIhE,EADA/B,EAAwB,iBAAT0G,GAA8B,OAATA,EAAgBA,EAAO,GAGrC,iBAAf1G,EAAMkG,OACfnE,EAAgC,iBAAlB/B,EAAMmpB,QAAuBnpB,EAAMmpB,QAAgC,iBAAfnpB,EAAM+B,KAAoB/B,EAAM+B,UAAOiD,EACzGoD,EAAMk3B,YAAc,SAAWR,EAAM9+B,EAAMkG,MAAQnE,EAAO,IAAMA,EAAO,IAAM,KAAO,KAGtF,OAAOqG,EAEP,SAASA,IACP,IAEIm3B,EACArvB,EAHAsvB,EAAez5B,EAAQ5B,OAAOuC,GAC9BC,EAAS,GAIb,KAAK8M,GAAQ2rB,EAAG14B,EAAM3G,EAAOgG,EAAQA,EAAQ1F,OAAS,IAAM,SAC1DsG,EA0BR,SAAkB3G,GAChB,GAAc,OAAVA,GAAmC,iBAAVA,GAAsB,WAAYA,EAC7D,OAAOA,EAGT,GAAqB,iBAAVA,EACT,MAAO,CAAC++B,EAAU/+B,GAGpB,MAAO,CAACA,GAnCOy/B,CAASl5B,EAAQG,EAAMX,KAErB,KAAOk5B,EAChB,OAAOt4B,EAIX,GAAID,EAAKP,UAAYQ,EAAO,KAAOq4B,EAGjC,IAFA9uB,GAAUgvB,EAAUx4B,EAAKP,SAAS9F,QAAU,GAAK8+B,EAE1CjvB,GAAU,GAAKA,EAASxJ,EAAKP,SAAS9F,QAAQ,CAGnD,IAFAk/B,EAAYF,EAAQ34B,EAAKP,SAAS+J,GAASA,EAAQsvB,EAAvCH,IAEE,KAAOJ,EACnB,OAAOM,EAGTrvB,EAAiC,iBAAjBqvB,EAAU,GAAkBA,EAAU,GAAKrvB,EAASivB,EAIxE,OAAOx4B,GAzCX04B,CAAQ/4B,EAAM,KAAM,GAApB+4B,GAhBFR,EAAaE,SAHE,KAIfF,EAAaG,KAAOA,EACpBH,EAAaI,KAAOA,G,mCCXpBv/B,EAAOC,QAAUyI,EAEjB,IAAIy2B,EAAe,EAAQ,OAEvBE,EAAWF,EAAaE,SACxBC,EAAOH,EAAaG,KACpBC,EAAOJ,EAAaI,KAKxB,SAAS72B,EAAM9B,EAAMmN,EAAMlN,EAAS24B,GACd,mBAATzrB,GAA0C,mBAAZlN,IACvC24B,EAAU34B,EACVA,EAAUkN,EACVA,EAAO,MAGTorB,EAAav4B,EAAMmN,GAEnB,SAAkB/M,EAAMX,GACtB,IAAIa,EAASb,EAAQA,EAAQ1F,OAAS,GAClCN,EAAQ6G,EAASA,EAAOT,SAAS/F,QAAQsG,GAAQ,KACrD,OAAOH,EAAQG,EAAM3G,EAAO6G,KALKs4B,GAXrC92B,EAAM22B,SAAWA,EACjB32B,EAAM42B,KAAOA,EACb52B,EAAM62B,KAAOA,G,mCCTb,IAAIlD,EAAY,EAAQ,MAIxB,SAAS2D,KAFThgC,EAAOC,QAAUggC,EAIjBD,EAAkB/+B,UAAYR,MAAMQ,UACpCg/B,EAASh/B,UAAY,IAAI++B,EAEzB,IAAIE,EAAQD,EAASh/B,UAcrB,SAASg/B,EAASE,EAAQt4B,EAAUu4B,GAClC,IAAIxsB,EACAysB,EACAC,EAEoB,iBAAbz4B,IACTu4B,EAASv4B,EACTA,EAAW,MAGb+L,EA2CF,SAAqBwsB,GACnB,IACI//B,EADA4G,EAAS,CAAC,KAAM,MAGE,iBAAXm5B,KAGM,KAFf//B,EAAQ+/B,EAAO1/B,QAAQ,MAGrBuG,EAAO,GAAKm5B,GAEZn5B,EAAO,GAAKm5B,EAAOh4B,MAAM,EAAG/H,GAC5B4G,EAAO,GAAKm5B,EAAOh4B,MAAM/H,EAAQ,KAIrC,OAAO4G,EA1DCs5B,CAAYH,GACpBC,EAAQhE,EAAUx0B,IAAa,MAC/By4B,EAAW,CACTl8B,MAAO,CACLN,KAAM,KACNyM,OAAQ,MAEVjM,IAAK,CACHR,KAAM,KACNyM,OAAQ,OAIR1I,GAAYA,EAASA,WACvBA,EAAWA,EAASA,UAGlBA,IAEEA,EAASzD,OACXk8B,EAAWz4B,EACXA,EAAWA,EAASzD,OAGpBk8B,EAASl8B,MAAQyD,GAIjBs4B,EAAOr5B,QACTyK,KAAKzK,MAAQq5B,EAAOr5B,MACpBq5B,EAASA,EAAOK,SAGlBjvB,KAAKivB,QAAUL,EACf5uB,KAAKlP,KAAOg+B,EACZ9uB,KAAK4uB,OAASA,EACd5uB,KAAKzN,KAAO+D,EAAWA,EAAS/D,KAAO,KACvCyN,KAAKhB,OAAS1I,EAAWA,EAAS0I,OAAS,KAC3CgB,KAAK+uB,SAAWA,EAChB/uB,KAAKpR,OAASyT,EAAM,GACpBrC,KAAKkvB,OAAS7sB,EAAM,GA/DtBssB,EAAMhE,KAAO,GACbgE,EAAM79B,KAAO,GACb69B,EAAMC,OAAS,GACfD,EAAMM,QAAU,GAChBN,EAAMp5B,MAAQ,GACdo5B,EAAMQ,MAAQ,KACdR,EAAM3vB,OAAS,KACf2vB,EAAMp8B,KAAO,M,mCCjBb9D,EAAOC,QAAU,EAAjB,Q,iCCAA,IAAImb,EAAI,EAAQ,OAEZulB,EAAO,EAAQ,OAEfp2B,EAAS,EAAQ,OAErBvK,EAAOC,QAAU2gC,EACjB,IAAI1wB,EAAM,GAAGhP,eAIT2/B,EAAQ,CAAC,UAAW,OAAQ,WAAY,OAAQ,UAAW,WA4B/D,SAASD,EAAMx+B,GACb,IAAI0+B,EACAzgC,EAEJ,GAAK+B,GAEE,GAAuB,iBAAZA,GAAwBmI,EAAOnI,GAC/CA,EAAU,CACRm7B,SAAUn7B,QAEP,GAAI,YAAaA,GAAW,aAAcA,EAC/C,OAAOA,OANPA,EAAU,GASZ,KAAMmP,gBAAgBqvB,GACpB,OAAO,IAAIA,EAAMx+B,GAUnB,IAPAmP,KAAK3G,KAAO,GACZ2G,KAAKwvB,SAAW,GAChBxvB,KAAKyvB,QAAU,GACfzvB,KAAK0vB,IAAMN,EAAKM,MAEhB5gC,GAAS,IAEAA,EAAQwgC,EAAMlgC,QACrBmgC,EAAOD,EAAMxgC,GAET6P,EAAIvO,KAAKS,EAAS0+B,KACpBvvB,KAAKuvB,GAAQ1+B,EAAQ0+B,IAKzB,IAAKA,KAAQ1+B,EACPy+B,EAAMngC,QAAQogC,GAAQ,IACxBvvB,KAAKuvB,GAAQ1+B,EAAQ0+B,IA2E3B,SAASI,EAAWC,EAAM9+B,GACxB,GAAI8+B,GAAQA,EAAKzgC,QAAQ0a,EAAEgmB,MAAQ,EACjC,MAAM,IAAI3gC,MAAM,IAAM4B,EAAO,uCAAyC+Y,EAAEgmB,IAAM,KAKlF,SAASC,EAAeF,EAAM9+B,GAC5B,IAAK8+B,EACH,MAAM,IAAI1gC,MAAM,IAAM4B,EAAO,qBAKjC,SAASi/B,EAAW3tB,EAAMtR,GACxB,IAAKsR,EACH,MAAM,IAAIlT,MAAM,YAAc4B,EAAO,mCA1JzCu+B,EAAM3/B,UAAUG,SAqIhB,SAAkB6H,GAChB,OAAQsI,KAAKgsB,UAAY,IAAIn8B,SAAS6H,IApIxCjI,OAAOK,eAAeu/B,EAAM3/B,UAAW,OAAQ,CAC7CsgC,IAiEF,WACE,OAAOhwB,KAAKyvB,QAAQzvB,KAAKyvB,QAAQrgC,OAAS,IAjE1C6gC,IAoEF,SAAiB7tB,GACf0tB,EAAe1tB,EAAM,QAEjBpC,KAAKoC,OAASA,GAChBpC,KAAKyvB,QAAQz7B,KAAKoO,MArEtB3S,OAAOK,eAAeu/B,EAAM3/B,UAAW,UAAW,CAChDsgC,IAwEF,WACE,MAA4B,iBAAdhwB,KAAKoC,KAAoByH,EAAEqmB,QAAQlwB,KAAKoC,WAAQrO,GAxE9Dk8B,IA2EF,SAAoBC,GAClBH,EAAW/vB,KAAKoC,KAAM,WACtBpC,KAAKoC,KAAOyH,EAAErV,KAAK07B,GAAW,GAAIlwB,KAAKmwB,aA1EzC1gC,OAAOK,eAAeu/B,EAAM3/B,UAAW,WAAY,CACjDsgC,IA4EF,WACE,MAA4B,iBAAdhwB,KAAKoC,KAAoByH,EAAEsmB,SAASnwB,KAAKoC,WAAQrO,GA5E/Dk8B,IA+EF,SAAqBE,GACnBL,EAAeK,EAAU,YACzBR,EAAWQ,EAAU,YACrBnwB,KAAKoC,KAAOyH,EAAErV,KAAKwL,KAAKkwB,SAAW,GAAIC,MA/EzC1gC,OAAOK,eAAeu/B,EAAM3/B,UAAW,UAAW,CAChDsgC,IAiFF,WACE,MAA4B,iBAAdhwB,KAAKoC,KAAoByH,EAAEumB,QAAQpwB,KAAKoC,WAAQrO,GAjF9Dk8B,IAoFF,SAAoBG,GAIlB,GAHAT,EAAWS,EAAS,WACpBL,EAAW/vB,KAAKoC,KAAM,WAElBguB,EAAS,CACX,GAA8B,KAA1BA,EAAQ17B,WAAW,GAGnB,MAAM,IAAIxF,MAAM,iCAGpB,GAAIkhC,EAAQjhC,QAAQ,IAAK,IAAM,EAC7B,MAAM,IAAID,MAAM,0CAIpB8Q,KAAKoC,KAAOyH,EAAErV,KAAKwL,KAAKkwB,QAASlwB,KAAKqwB,MAAQD,GAAW,QAjG3D3gC,OAAOK,eAAeu/B,EAAM3/B,UAAW,OAAQ,CAC7CsgC,IAmGF,WACE,MAA4B,iBAAdhwB,KAAKoC,KAAoByH,EAAEsmB,SAASnwB,KAAKoC,KAAMpC,KAAKowB,cAAWr8B,GAnG7Ek8B,IAsGF,SAAiBI,GACfP,EAAeO,EAAM,QACrBV,EAAWU,EAAM,QACjBrwB,KAAKoC,KAAOyH,EAAErV,KAAKwL,KAAKkwB,SAAW,GAAIG,GAAQrwB,KAAKowB,SAAW,S,mCC7IjE,IAAI1B,EAAW,EAAQ,OAEnBW,EAAQ,EAAQ,KAEpB5gC,EAAOC,QAAU2gC,EACjBA,EAAM3/B,UAAUu/B,QAKhB,SAAiBL,EAAQt4B,EAAUu4B,GACjC,IAAII,EAAU,IAAIP,EAASE,EAAQt4B,EAAUu4B,GAEzC7uB,KAAKoC,OACP6sB,EAAQn+B,KAAOkP,KAAKoC,KAAO,IAAM6sB,EAAQn+B,KACzCm+B,EAAQtE,KAAO3qB,KAAKoC,MAKtB,OAFA6sB,EAAQE,OAAQ,EAChBnvB,KAAKwvB,SAASx7B,KAAKi7B,GACZA,GAdTI,EAAM3/B,UAAU8lB,KA0BhB,WACE,IAAIyZ,EAAUjvB,KAAKivB,QAAQt4B,MAAMqJ,KAAMvO,WAEvC,OADAw9B,EAAQE,MAAQ,KACTF,GA5BTI,EAAM3/B,UAAU4gC,KAiBhB,WACE,IAAIrB,EAAUjvB,KAAKivB,QAAQt4B,MAAMqJ,KAAMvO,WAEvC,MADAw9B,EAAQE,OAAQ,EACVF,I,iCCqOR,SAASsB,EAAUnuB,GACjB,IAAIouB,EACAzhC,EAkBJ,OAjBAghC,EAAW3tB,GACXouB,EAAkC,KAAvBpuB,EAAK1N,WAAW,IAI3B3F,EAgBF,SAAyBqT,EAAMquB,GAC7B,IAKI/9B,EACAg+B,EANAh7B,EAAS,GACTi7B,EAAoB,EACpBC,GAAa,EACbC,EAAO,EACP/hC,GAAS,EAIb,OAASA,GAASsT,EAAKhT,QAAQ,CAC7B,GAAIN,EAAQsT,EAAKhT,OACfsD,EAAO0P,EAAK1N,WAAW5F,OAClB,IAAa,KAAT4D,EAGP,MAEFA,EAAO,GAIT,GAAa,KAATA,EAEF,CACE,GAAIk+B,IAAc9hC,EAAQ,GAAc,IAAT+hC,QACxB,GAAID,IAAc9hC,EAAQ,GAAc,IAAT+hC,EAAY,CAChD,GAAIn7B,EAAOtG,OAAS,GAA2B,IAAtBuhC,GAAoE,KAAzCj7B,EAAOhB,WAAWgB,EAAOtG,OAAS,IAE1C,KAAzCsG,EAAOhB,WAAWgB,EAAOtG,OAAS,GAGjC,GAAIsG,EAAOtG,OAAS,GAIlB,IAHAshC,EAAiBh7B,EAAOo7B,YAAY,QAGbp7B,EAAOtG,OAAS,EAAG,CACpCshC,EAAiB,GACnBh7B,EAAS,GACTi7B,EAAoB,GAGpBA,GADAj7B,EAASA,EAAOmB,MAAM,EAAG65B,IACEthC,OAAS,EAAIsG,EAAOo7B,YAAY,KAG7DF,EAAY9hC,EACZ+hC,EAAO,EACP,eAEG,GAAIn7B,EAAOtG,OAAQ,CACxBsG,EAAS,GACTi7B,EAAoB,EACpBC,EAAY9hC,EACZ+hC,EAAO,EACP,SAIFJ,IACF/6B,EAASA,EAAOtG,OAASsG,EAAS,MAAQ,KAC1Ci7B,EAAoB,QAGlBj7B,EAAOtG,OACTsG,GAAU,IAAM0M,EAAKvL,MAAM+5B,EAAY,EAAG9hC,GAE1C4G,EAAS0M,EAAKvL,MAAM+5B,EAAY,EAAG9hC,GAGrC6hC,EAAoB7hC,EAAQ8hC,EAAY,EAG1CA,EAAY9hC,EACZ+hC,EAAO,OACW,KAATn+B,GAEVm+B,GAAQ,EACTA,IAEAA,GAAQ,EAIZ,OAAOn7B,EAlGCq7B,CAAgB3uB,GAAOouB,IAEpBphC,QAAWohC,IACpBzhC,EAAQ,KAGNA,EAAMK,QAA+C,KAArCgT,EAAK1N,WAAW0N,EAAKhT,OAAS,KAG9CL,GAAS,KAGNyhC,EAAW,IAAMzhC,EAAQA,EAyFlC,SAASghC,EAAW3tB,GAClB,GAAoB,iBAATA,EACT,MAAM,IAAI9S,UAAU,mCAAqC0hC,KAAKlG,UAAU1oB,IA9T5E1T,EAAQyhC,SAMR,SAAkB/tB,EAAM6uB,GACtB,IAEIniC,EACAoiC,EACAC,EACAC,EALAv+B,EAAQ,EACRE,GAAO,EAMX,QAAYgB,IAARk9B,GAAoC,iBAARA,EAC9B,MAAM,IAAI3hC,UAAU,mCAMtB,GAHAygC,EAAW3tB,GACXtT,EAAQsT,EAAKhT,YAED2E,IAARk9B,IAAsBA,EAAI7hC,QAAU6hC,EAAI7hC,OAASgT,EAAKhT,OAAQ,CAChE,KAAON,KACL,GAA+B,KAA3BsT,EAAK1N,WAAW5F,IAKhB,GAAIqiC,EAAc,CAChBt+B,EAAQ/D,EAAQ,EAChB,YAEOiE,EAAM,IAGjBo+B,GAAe,EACfp+B,EAAMjE,EAAQ,GAIlB,OAAOiE,EAAM,EAAI,GAAKqP,EAAKvL,MAAMhE,EAAOE,GAG1C,GAAIk+B,IAAQ7uB,EACV,MAAO,GAGT8uB,GAAoB,EACpBE,EAAWH,EAAI7hC,OAAS,EAExB,KAAON,KACL,GAA+B,KAA3BsT,EAAK1N,WAAW5F,IAKhB,GAAIqiC,EAAc,CAChBt+B,EAAQ/D,EAAQ,EAChB,YAGAoiC,EAAmB,IAGrBC,GAAe,EACfD,EAAmBpiC,EAAQ,GAGzBsiC,GAAY,IAEVhvB,EAAK1N,WAAW5F,KAAWmiC,EAAIv8B,WAAW08B,KACxCA,EAAW,IAGbr+B,EAAMjE,IAKRsiC,GAAY,EACZr+B,EAAMm+B,IAMVr+B,IAAUE,EACZA,EAAMm+B,EACGn+B,EAAM,IACfA,EAAMqP,EAAKhT,QAGb,OAAOgT,EAAKvL,MAAMhE,EAAOE,IA3F3BrE,EAAQwhC,QA8FR,SAAiB9tB,GACf,IAAIrP,EACAs+B,EACAviC,EAGJ,GAFAihC,EAAW3tB,IAENA,EAAKhT,OACR,MAAO,IAGT2D,GAAO,EACPjE,EAAQsT,EAAKhT,OAEb,OAASN,GACP,GAA+B,KAA3BsT,EAAK1N,WAAW5F,IAGhB,GAAIuiC,EAAgB,CAClBt+B,EAAMjE,EACN,YAEQuiC,IAEZA,GAAiB,GAIrB,OAAOt+B,EAAM,EAA2B,KAAvBqP,EAAK1N,WAAW,GAE/B,IAAM,IAAc,IAAR3B,GAAoC,KAAvBqP,EAAK1N,WAAW,GAEzC,KAAO0N,EAAKvL,MAAM,EAAG9D,IA5HzBrE,EAAQ0hC,QA+HR,SAAiBhuB,GACf,IAMIivB,EACA3+B,EACA5D,EARAwiC,GAAY,EACZC,EAAY,EACZx+B,GAAO,EAGPy+B,EAAc,EAIlBzB,EAAW3tB,GACXtT,EAAQsT,EAAKhT,OAEb,KAAON,KAGL,GAAa,MAFb4D,EAAO0P,EAAK1N,WAAW5F,IAenBiE,EAAM,IAGRs+B,GAAiB,EACjBt+B,EAAMjE,EAAQ,GAGH,KAAT4D,EAII4+B,EAAW,EACbA,EAAWxiC,EACc,IAAhB0iC,IACTA,EAAc,GAEPF,GAAY,IAGvBE,GAAe,QA3Bb,GAAIH,EAAgB,CAClBE,EAAYziC,EAAQ,EACpB,MA6BR,GAAIwiC,EAAW,GAAKv+B,EAAM,GACV,IAAhBy+B,GACgB,IAAhBA,GAAqBF,IAAav+B,EAAM,GAAKu+B,IAAaC,EAAY,EACpE,MAAO,GAGT,OAAOnvB,EAAKvL,MAAMy6B,EAAUv+B,IAxL9BrE,EAAQ8F,KA2LR,WACE,IACIi9B,EADA3iC,GAAS,EAGb,OAASA,EAAQ2C,UAAUrC,QACzB2gC,EAAWt+B,UAAU3C,IAEjB2C,UAAU3C,KACZ2iC,OAAoB19B,IAAX09B,EAAuBhgC,UAAU3C,GAAS2iC,EAAS,IAAMhgC,UAAU3C,IAIhF,YAAkBiF,IAAX09B,EAAuB,IAAMlB,EAAUkB,IAtMhD/iC,EAAQmhC,IAAM,K,iCCnDdnhC,EAAQghC,IAER,WACE,MAAO,M,2FCCT,SAASgC,EAAT,GAAkG,IAApFlxB,EAAmF,EAAnFA,MAAmF,IAA5EmxB,eAA4E,MAAlE,KAAkE,EAA5DC,EAA4D,EAA5DA,YAA4D,IAA/Cx3B,aAA+C,MAAvC,KAAuC,MAAjCy3B,iBAAiC,aAAd1xB,YAAc,MAAP,KAAO,EACtF2xB,GAAYC,mBAAZD,SACDE,GAAeC,SAGjBC,EAKAF,EALAE,aACAC,EAIAH,EAJAG,cACAC,EAGAJ,EAHAI,mBACAC,EAEAL,EAFAK,aACAC,EACAN,EADAM,QAGEC,EAAM,CACR/xB,MAAOA,GAAS0xB,EAChBP,QAASA,GAAWnxB,GAAS0xB,EAC7BN,YAAaA,GAAeQ,EAC5Bh4B,MAAM,GAAIk4B,GAAUl4B,GAASi4B,GAC7B5xB,IAAI,GAAI6xB,EAAUR,GAKtB,OACI,QAAC,EAAAU,OAAD,CACIhyB,MAAO+xB,EAAI/xB,MACX2xB,cAAeA,IAEf,gBAAMhyB,KAAMA,KAEZ,gBAAMrP,KAAK,cAAc6c,QAAS4kB,EAAIX,eACtC,gBAAM9gC,KAAK,QAAQ6c,QAAS4kB,EAAIn4B,QAE/Bm4B,EAAIZ,UAAW,gBAAMc,SAAS,WAAW9kB,QAAS4kB,EAAIZ,UACtDY,EAAIX,cAAe,gBAAMa,SAAS,iBAAiB9kB,QAAS4kB,EAAIX,cAChEW,EAAIn4B,QAAS,gBAAMq4B,SAAS,WAAW9kB,QAAS4kB,EAAIn4B,QACpDm4B,EAAI9xB,MAAO,gBAAMgyB,SAAS,SAAS9kB,QAAS4kB,EAAI9xB,MAChD8xB,EAAIn4B,QAAS,gBAAMtJ,KAAK,eAAe6c,QAAQ,wBAC/CkkB,IAAa,gBAAMY,SAAS,UAAU9kB,QAAQ,aAK3D+jB,EAAIpK,aAAe,CACfqK,QAAS,KACTC,YAAa,KACbzxB,KAAM,KACN/F,MAAO,KACPy3B,WAAW,GAaf,O,wZCnDMa,EAAiB,kBAEjBC,EAAwB,UACxBC,EAAqB,OACrBC,EAA0B,aAC1BC,EAAwB,UAExBC,EAAwB,UAExBC,IAAe,MARQ,IASD,CAACliC,MAAM,QAAC,EAAAmiC,MAAD,eAAuBC,MAAM,QAAC,IAAD,OAD3C,UAEQ,CAACpiC,MAAM,QAAC,EAAAmiC,MAAD,gBAAwBC,MAAM,QAAC,IAAD,OAF7C,OAGK,CAACpiC,MAAM,QAAC,EAAAmiC,MAAD,aAAqBC,MAAM,QAAC,IAAD,OAHvC,EAIhBL,GAA0B,CAAC/hC,MAAM,QAAC,EAAAmiC,MAAD,mBAA2BC,MAAM,QAAC,IAAD,OAJlD,EAKhBJ,GAAwB,CAAChiC,MAAM,QAAC,EAAAmiC,MAAD,gBAAwBC,MAAM,QAAC,IAAD,OAL7C,SAMO,CAACpiC,MAAM,QAAC,EAAAmiC,MAAD,eAAuBC,MAAM,QAAC,IAAD,OAN3C,EAOhBH,GAAwB,CAACjiC,MAAM,QAAC,EAAAmiC,MAAD,gBAAwBC,MAAM,QAAC,IAAD,OAP7C,aAQW,CAACpiC,MAAM,QAAC,EAAAmiC,MAAD,mBAA2BC,MAAM,QAAC,IAAD,OARnD,GAUfC,EAAiB,CAlBM,GAoBzBR,EACAC,EACAC,GASEO,EAAoB,CAEtBn+B,KAAM,CACFA,KAAM,SACNo+B,SAAU,SACVviC,MAAM,QAAC,EAAAmiC,MAAD,gB,kDClCd,IAlBwB,WAepB,OAdeK,oBAAe,cAAvBC,KAcKvB,e,yWCFVwB,EAAuB,CACzB,EAAGC,KACH,EAAGC,KACH,EAAGC,KACH,EAAGC,KACH,EAAGC,KACH,EAAGC,MAEDvN,EAAU,CACZ,CAACwN,IAAK,CAACC,aAAa,KAwClBC,GAAoB,kCACpBC,KADoB,UAETC,gBAFS,gBAGHC,YAHG,KAMpBX,KANoB,IAOpBC,KAPoB,IAQpBC,KARoB,IASpBC,KAToB,IAUpBC,KAVoB,IAWpBC,KAXoB,gBAYHM,YAZG,wBAgBpBX,KAhBoB,qDAsBpBC,KAtBoB,qDA4BpBC,KA5BoB,qBAgCpBC,KAhCoB,qBAoCpBC,KApCoB,qBAwCpBC,KAxCoB,wCA6CpBO,IA7CoB,0RAwE2BF,gBAxE3B,KAwEiDA,WAxEjD,cA4ELA,gBA5EK,+DA4G1B,EAjBuB,SAAC,GAAD,IA/HLG,EA+HO3mB,EAAF,EAAEA,QAAS4mB,EAAX,EAAWA,cAAX,OACnB,QAACN,EAAD,MACI,QAAC,IAAD,CAAe1N,QAASA,EAAS1F,WAjIvByT,EAiI4CC,EAjIjC,CACzBn8B,KAAM,cAAE3C,KAAF,IAAQP,EAAR,EAAQA,SAAaksB,GAArB,mBAAgC,QAAC,MAAD,UAAUA,EAAV,CAAiBxwB,OAAO,WAAUsE,IACxE2F,UAAW,cAAEpF,KAAF,IAAQP,EAAR,EAAQA,SAAaksB,GAArB,mBAAgC,QAAC,EAAAiT,EAAMjT,EAAQlsB,IAC1DuD,QAAS,YAAuC,EAArChD,KAAsC,IAAhCysB,EAA+B,EAA/BA,MAAOhtB,EAAwB,EAAxBA,SAAaksB,GAAW,YACtCoT,EAAUhB,EAAqBtR,GACrC,OAAO,QAACsS,EAAYpT,EAAQlsB,IAEhCkF,MAAO,YAAiD,EAA/C3E,KAA+C,EAAzCP,SAGX,IAHqD,IAAhC7D,EAA+B,EAA/BA,IAAK0P,EAA0B,EAA1BA,IAAKP,EAAqB,EAArBA,MAAU4gB,GAAW,YAG3C1vB,EAAI,EAAGA,EAAI4iC,EAAOllC,OAAQsC,IAC/B,GAAIL,EAAI+yB,SAASkQ,EAAO5iC,GAAGZ,MACvB,OACI,uBACI,QAAC,EAAA2jC,GAAD,QACIC,GAAG,OACHt6B,OAAOu6B,OAASL,EAAO5iC,GAAGkjC,iBAC1B7zB,IAAKA,GACDqgB,IAEP5gB,IAAS,QAAC,KAAD,KAAaA,IAMvC,OAAO,QAuG+D4iB,oBAAkB,GACnFzV,K,uEC9IPknB,GAAoB,mCACpBC,KADoB,oGAmBJX,cAnBI,QA6BpBY,EAAsB,SAAC,GAAwC,IAAvCC,EAAsC,EAAtCA,YAAaC,EAAyB,EAAzBA,SAAUC,EAAe,EAAfA,UAC1CC,GAAKC,sBAALD,EAEDE,EAAa,yCAA4CJ,EACzDK,EAAa,uDAA0DL,EACvEM,EAAY,wCAA2CN,EAA3C,SAA4DC,EAA5D,sBAElB,OACI,QAACL,EAAD,CAAsB7S,UAAU,UAC5B,mBAAMgT,IACN,mBACI,mBACI,aAAGnS,KAAMwS,EAAe70B,MAAO20B,EAAE,qBAAsBvkC,OAAO,SAAS4kC,IAAI,eACvE,QAAC,IAAD,SAGR,mBACI,aAAG3S,KAAMyS,EAAe90B,MAAO20B,EAAE,qBAAsBvkC,OAAO,SAAS4kC,IAAI,eACvE,QAAC,IAAD,SAGR,mBACI,aAAG3S,KAAM0S,EAAc/0B,MAAO20B,EAAE,oBAAqBvkC,OAAO,SAAS4kC,IAAI,eACrE,QAAC,IAAD,WAcxBT,EAAoBzN,aAAe,CAC/B4N,UAAW,IAOf,QC/EMO,GAAwB,OAAOC,KAAP,sBAAH,gDAGRC,eAHQ,sDASFC,QATE,8EAuBrBC,EAAkB,SAAC,GAAD,QAAEC,iBAAF,MAAc,KAAd,MAAoB9T,iBAApB,MAAgC,GAAhC,EAAoC9sB,EAApC,EAAoCA,SAApC,OACpB,QAACugC,EAAD,CAAuBzT,UAAWA,IAC9B,eAAKA,UAAU,mBACX,eAAKA,UAAU,sCACV8T,IACG,eAAK9T,UAAU,oBACV8T,KAIb,mBAAS9T,UAAU,sCACd9sB,MAYjB2gC,EAAgBvO,aAAe,CAC3BwO,UAAW,KACX9T,UAAW,IAOf,Q,0CC/CA,I,EAAM+T,GAAkB,0PAaI5B,WAbJ,8GAsBEA,gBAtBF,+EA8BHA,gBA9BG,gBA+BGwB,eA/BH,gBAgCGvB,cAhCH,qMAuDdP,KAvDc,0FAoEC+B,QApED,yQAkFDA,QAlFC,mBAoFZnC,KApFY,IAqFRuC,KArFQ,QA2FlBC,EAAqB,+FAwD3B,EA1CqB,SAAC,GAAY,IAAD,EAAVC,EAAU,EAAVA,KACbC,EAAeD,EAAKjhC,OAAS49B,MAC/B,QAAC,KAAD,CACI7Q,UAAU,gBACVoU,GAAIF,EAAKG,MAAM,GAAG1L,KAAK2L,UAAUC,UACjCC,QAAO,gBAAkBN,EAAK11B,MAC9Bi2B,UAAQ,IAER,QAAC,EAAAxD,MAAD,6BACA,QAAC,IAAD,OAEJ,KAEJ,OACI,QAAC8C,EAAD,MACI,QAAC,KAAD,CAASW,IAAKT,EAAuB77B,OAAOu6B,OAASuB,EAAKS,cAAcL,cAExE,eAAKtU,UAAU,iBACX,eAAKA,UAAU,QACX,eAAKA,UAAU,YACVgR,KAAgBkD,EAAKjhC,MAAMi+B,MAC5B,iBAAIF,KAAgBkD,EAAKjhC,MAAMnE,QAEnC,eAAKkxB,UAAU,UAAf,UAAyBkU,EAAKU,UAAU,UAAxC,aAAyB,EAAmB1T,OAEhD,QAAC,EAAAuQ,GAAD,KAAKyC,EAAK11B,QACV,QAAC,EAAAqzB,GAAD,KAAKqC,EAAKW,WAETV,K,qBC7HXW,IAAsB,MACvB/D,MAAwBgE,KADD,EAEvBjE,MAAwBkE,KAFD,GAStBC,GAAe,0HAQM7C,cARN,iDAgBIwB,QAhBJ,iGA+BfsB,EAAY,SAAC,GAAqB,IAApBhB,EAAmB,EAAnBA,KAAMiB,EAAa,EAAbA,QACfhC,GAAKC,sBAALD,EAEP,OACI,QAAC8B,EAAD,MACI,eAAKjV,UAAU,YACX,QAAC,EAAAoV,GAAD,MAAI,QAAC,EAAAnE,MAAD,qBACJ,QAAC,EAAAmE,GAAD,CAAIpV,UAAU,WAAWkU,EAAKmB,iBAAiBvmC,QAEnD,eAAKkxB,UAAU,YACX,QAAC,EAAAoV,GAAD,MAAI,QAAC,EAAAnE,MAAD,eACJ,QAAC,EAAAmE,GAAD,CAAIpV,UAAU,WAAWkU,EAAKoB,gBAElC,QAAC,EAAD,CACItC,YAAaG,EAAE,sBACfF,SAAUkC,EACVjC,UAAWgB,EAAK11B,UAW1B+2B,GAAY,yKAaO3B,QAbP,+DAmBOA,QAnBP,6CA2BZ4B,GAAwBd,QAAH,mBAGrBhB,KAHqB,yBAObhC,KAPa,yCAWQU,eAXR,gDAkBCD,iBAlBD,SAuBrBsD,IAAkB,2HAEgDtD,WAFhD,uCAGsBuD,IAHtB,8BAiFxB,GAtEqB,SAAC,GAAsB,IAArBr+B,EAAoB,EAApBA,KAAM01B,EAAc,EAAdA,UACL4I,gBAAWC,KAC/BC,EAAY,GACZ,IAAO1C,GAAKC,sBAALD,EAGDgC,GAAUlF,SAAkBK,QAAUvD,EAAS+C,SAE/CoE,EAAO78B,EAAKy+B,eACZC,EAAkBjB,EAAuBZ,EAAKjhC,MAE9C6gC,GAAY,QAACoB,EAAD,CAAWhB,KAAMA,EAAMiB,QAASA,IAC5Ca,EAAkB9B,EAAKtE,aAAc,QAAC,EAAAiC,GAAD,CAAI7R,UAAU,yBAAyBkU,EAAKtE,aAAoB,KACrGqG,EAAkBF,GAAkB,QAACA,EAAD,CAAiBG,aAAchC,EAAKG,MAAM,GAAGj+B,OAAW,KAE5F+/B,EAAejC,EAAKjhC,OAAS49B,MAC/B,QAAC,KAAD,CAAcz6B,KAAK,uBAAuBggC,SAAUjD,EAAE,iBAAkBkD,UAAWb,IAC/E,QAAC,EAAA9D,GAAD,MACI,QAAC,EAAAT,MAAD,MACI,gBAAMjR,UAAU,QAAhB,gCACC,IAFL,gBAIK,KACD,gBAAMA,UAAU,QAAhB,WAGR,QAAC,KAAD,MAAQ,QAAC,EAAAiR,MAAD,kDAEZ,KAEJ,OACI,yBACI,QAACvB,EAAA,EAAD,CACIlxB,MAAO01B,EAAK11B,MACZmxB,QAAYuE,EAAK11B,MAAV,YACPoxB,YAAasE,EAAKtE,YAClBx3B,OAAOk+B,OAAOpC,EAAKS,cAAcL,WACjCzE,WAAS,KAGb,QAAC,EAAD,CAAcqE,KAAMA,KAEpB,QAACuB,GAAD,MACI,QAAC,EAAD,CAAiB3B,UAAWA,IACxB,QAACyB,EAAD,KACKS,GAED,eAAKhW,UAAU,sBACX,QAAC,EAAD,CAAgBrU,QAASuoB,EAAKvoB,QAAS4mB,cAAe2B,EAAKqC,iBAE1DN,KAKZE,M,sBClNjB,IAAI3X,EAAQ,EAAQ,OAEpB,SAASgY,EAAUpX,GACf,OAAOZ,EAAMH,cAAc,MAAMe,EAAMZ,EAAMH,cAAc,IAAI,CAAC,MAAQ,CAAC,OAAS,OAAO,YAAc,MAAM,KAAO,OAAO,SAAW,UAAU,cAAgB,QAAQ,eAAiB,SAAS,UAAY,kBAAkB,CAACG,EAAMH,cAAc,OAAO,CAAC,EAAI,yEAAyE,IAAM,IAAIG,EAAMH,cAAc,OAAO,CAAC,EAAI,eAAe,IAAM,IAAIG,EAAMH,cAAc,OAAO,CAAC,EAAI,YAAY,IAAM,OAGncmY,EAASlR,aAAe,CAAC,OAAS,KAAK,QAAU,YAAY,MAAQ,MAErE74B,EAAOC,QAAU8pC,EAEjBA,EAAS3jB,QAAU2jB,G,sBCVnB,IAAIhY,EAAQ,EAAQ,OAEpB,SAASiY,EAASrX,GACd,OAAOZ,EAAMH,cAAc,MAAMe,EAAMZ,EAAMH,cAAc,IAAI,CAAC,MAAQ,CAAC,KAAO,OAAO,SAAW,UAAU,cAAgB,QAAQ,eAAiB,QAAQ,OAAS,OAAO,YAAc,QAAQ,CAACG,EAAMH,cAAc,OAAO,CAAC,EAAI,eAAe,IAAM,IAAIG,EAAMH,cAAc,OAAO,CAAC,EAAI,aAAa,IAAM,IAAIG,EAAMH,cAAc,OAAO,CAAC,EAAI,kBAAkB,UAAY,wBAAwB,IAAM,OAGpZoY,EAAQnR,aAAe,CAAC,OAAS,KAAK,QAAU,YAAY,MAAQ,MAEpE74B,EAAOC,QAAU+pC,EAEjBA,EAAQ5jB,QAAU4jB,G,sBCVlB,IAAIjY,EAAQ,EAAQ,OAEpB,SAASkY,EAAMtX,GACX,OAAOZ,EAAMH,cAAc,MAAMe,EAAMZ,EAAMH,cAAc,IAAI,CAAC,MAAQ,CAAC,KAAO,OAAO,SAAW,UAAU,cAAgB,QAAQ,eAAiB,QAAQ,OAAS,OAAO,YAAc,QAAQ,CAACG,EAAMH,cAAc,OAAO,CAAC,EAAI,kBAAkB,UAAY,wBAAwB,IAAM,IAAIG,EAAMH,cAAc,OAAO,CAAC,EAAI,kBAAkB,IAAM,IAAIG,EAAMH,cAAc,OAAO,CAAC,EAAI,2BAA2B,IAAM,OAGraqY,EAAKpR,aAAe,CAAC,OAAS,KAAK,QAAU,YAAY,MAAQ,MAEjE74B,EAAOC,QAAUgqC,EAEjBA,EAAK7jB,QAAU6jB,G,sBCVf,IAAIlY,EAAQ,EAAQ,OAEpB,SAASmY,EAAWvX,GAChB,OAAOZ,EAAMH,cAAc,MAAMe,EAAMZ,EAAMH,cAAc,IAAI,CAAC,MAAQ,CAAC,KAAO,OAAO,SAAW,UAAU,cAAgB,QAAQ,eAAiB,QAAQ,OAAS,OAAO,YAAc,QAAQ,CAACG,EAAMH,cAAc,OAAO,CAAC,EAAI,uCAAuC,IAAM,IAAIG,EAAMH,cAAc,OAAO,CAAC,EAAI,yCAAyC,IAAM,IAAIG,EAAMH,cAAc,SAAS,CAAC,GAAK,YAAY,GAAK,YAAY,EAAI,IAAI,UAAY,sEAAsE,IAAM,OAG5gBsY,EAAUrR,aAAe,CAAC,OAAS,KAAK,QAAU,YAAY,MAAQ,MAEtE74B,EAAOC,QAAUiqC,EAEjBA,EAAU9jB,QAAU8jB,G,sBCVpB,IAAInY,EAAQ,EAAQ,OAEpB,SAASoY,EAAQxX,GACb,OAAOZ,EAAMH,cAAc,MAAMe,EAAMZ,EAAMH,cAAc,IAAI,CAAC,MAAQ,CAAC,KAAO,OAAO,SAAW,UAAU,cAAgB,QAAQ,eAAiB,QAAQ,OAAS,OAAO,YAAc,QAAQ,CAACG,EAAMH,cAAc,SAAS,CAAC,GAAK,KAAK,GAAK,KAAK,EAAI,KAAK,IAAM,IAAIG,EAAMH,cAAc,OAAO,CAAC,EAAI,kBAAkB,IAAM,IAAIG,EAAMH,cAAc,OAAO,CAAC,EAAI,wBAAwB,IAAM,OAGvYuY,EAAOtR,aAAe,CAAC,OAAS,KAAK,QAAU,YAAY,MAAQ,MAEnE74B,EAAOC,QAAUkqC,EAEjBA,EAAO/jB,QAAU+jB,G,sBCVjB,IAAIpY,EAAQ,EAAQ,OAEpB,SAASqY,EAASzX,GACd,OAAOZ,EAAMH,cAAc,MAAMe,EAAMZ,EAAMH,cAAc,IAAI,CAAC,MAAQ,CAAC,KAAO,OAAO,SAAW,UAAU,cAAgB,QAAQ,eAAiB,QAAQ,OAAS,OAAO,YAAc,QAAQ,CAACG,EAAMH,cAAc,OAAO,CAAC,EAAI,kBAAkB,UAAY,wBAAwB,IAAM,IAAIG,EAAMH,cAAc,OAAO,CAAC,EAAI,oBAAoB,UAAY,yBAAyB,IAAM,OAGvYwY,EAAQvR,aAAe,CAAC,OAAS,KAAK,QAAU,YAAY,MAAQ,MAEpE74B,EAAOC,QAAUmqC,EAEjBA,EAAQhkB,QAAUgkB,G,sBCVlB,IAAIrY,EAAQ,EAAQ,OAEpB,SAASsY,EAAQ1X,GACb,OAAOZ,EAAMH,cAAc,MAAMe,EAAMZ,EAAMH,cAAc,IAAI,CAAC,MAAQ,CAAC,KAAO,OAAO,SAAW,UAAU,cAAgB,QAAQ,eAAiB,QAAQ,OAAS,OAAO,YAAc,QAAQ,CAACG,EAAMH,cAAc,OAAO,CAAC,EAAI,sBAAsB,UAAY,yBAAyB,IAAM,IAAIG,EAAMH,cAAc,OAAO,CAAC,EAAI,2BAA2B,IAAM,OAG9WyY,EAAOxR,aAAe,CAAC,OAAS,KAAK,QAAU,YAAY,MAAQ,MAEnE74B,EAAOC,QAAUoqC,EAEjBA,EAAOjkB,QAAUikB,G,sBCVjB,IAAItY,EAAQ,EAAQ,OAEpB,SAASuY,EAAS3X,GACd,OAAOZ,EAAMH,cAAc,MAAMe,EAAMZ,EAAMH,cAAc,IAAI,CAAC,MAAQ,CAAC,KAAO,OAAO,SAAW,UAAU,cAAgB,QAAQ,eAAiB,QAAQ,OAAS,OAAO,YAAc,QAAQ,CAACG,EAAMH,cAAc,OAAO,CAAC,EAAI,kBAAkB,UAAY,wBAAwB,IAAM,IAAIG,EAAMH,cAAc,OAAO,CAAC,EAAI,eAAe,IAAM,OAG7V0Y,EAAQzR,aAAe,CAAC,OAAS,KAAK,QAAU,YAAY,MAAQ,MAEpE74B,EAAOC,QAAUqqC,EAEjBA,EAAQlkB,QAAUkkB,G,sBCVlB,IAAIvY,EAAQ,EAAQ,OAEpB,SAASwY,EAAY5X,GACjB,OAAOZ,EAAMH,cAAc,MAAMe,EAAMZ,EAAMH,cAAc,IAAI,CAAC,MAAQ,CAAC,KAAO,OAAO,SAAW,UAAU,cAAgB,QAAQ,eAAiB,QAAQ,OAAS,OAAO,YAAc,QAAQ,CAACG,EAAMH,cAAc,OAAO,CAAC,EAAI,sCAAsC,UAAY,wBAAwB,IAAM,IAAIG,EAAMH,cAAc,OAAO,CAAC,EAAI,6BAA6B,IAAM,OAG/X2Y,EAAW1R,aAAe,CAAC,OAAS,KAAK,QAAU,YAAY,MAAQ,MAEvE74B,EAAOC,QAAUsqC,EAEjBA,EAAWnkB,QAAUmkB,G,kCCVrB,IAAe,IAA0B","file":"component---src-templates-blog-post-js-cd1f042e5ad9a0c41d47.js","sourcesContent":["'use strict';\n\nmodule.exports = bail;\n\nfunction bail(err) {\n  if (err) {\n    throw err;\n  }\n}","'use strict';\n\nmodule.exports = ccount;\n\nfunction ccount(source, character) {\n  var value = String(source);\n  var count = 0;\n  var index;\n\n  if (typeof character !== 'string') {\n    throw new Error('Expected character');\n  }\n\n  index = value.indexOf(character);\n\n  while (index !== -1) {\n    count++;\n    index = value.indexOf(character, index + character.length);\n  }\n\n  return count;\n}","'use strict';\n\nmodule.exports = function (string) {\n  if (typeof string !== 'string') {\n    throw new TypeError('Expected a string');\n  } // Escape characters with special meaning either inside or outside character sets.\n  // Use a simple backslash escape when it’s always valid, and a \\unnnn escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.\n\n\n  return string.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d');\n};","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n  if (typeof Array.isArray === 'function') {\n    return Array.isArray(arr);\n  }\n\n  return toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n  if (!obj || toStr.call(obj) !== '[object Object]') {\n    return false;\n  }\n\n  var hasOwnConstructor = hasOwn.call(obj, 'constructor');\n  var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); // Not own constructor property must be Object\n\n  if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n    return false;\n  } // Own properties are enumerated firstly, so to speed up,\n  // if last one is own, then all properties are own.\n\n\n  var key;\n\n  for (key in obj) {\n    /**/\n  }\n\n  return typeof key === 'undefined' || hasOwn.call(obj, key);\n}; // If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\n\n\nvar setProperty = function setProperty(target, options) {\n  if (defineProperty && options.name === '__proto__') {\n    defineProperty(target, options.name, {\n      enumerable: true,\n      configurable: true,\n      value: options.newValue,\n      writable: true\n    });\n  } else {\n    target[options.name] = options.newValue;\n  }\n}; // Return undefined instead of __proto__ if '__proto__' is not an own property\n\n\nvar getProperty = function getProperty(obj, name) {\n  if (name === '__proto__') {\n    if (!hasOwn.call(obj, name)) {\n      return void 0;\n    } else if (gOPD) {\n      // In early versions of node, obj['__proto__'] is buggy when obj has\n      // __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n      return gOPD(obj, name).value;\n    }\n  }\n\n  return obj[name];\n};\n\nmodule.exports = function extend() {\n  var options, name, src, copy, copyIsArray, clone;\n  var target = arguments[0];\n  var i = 1;\n  var length = arguments.length;\n  var deep = false; // Handle a deep copy situation\n\n  if (typeof target === 'boolean') {\n    deep = target;\n    target = arguments[1] || {}; // skip the boolean and the target\n\n    i = 2;\n  }\n\n  if (target == null || typeof target !== 'object' && typeof target !== 'function') {\n    target = {};\n  }\n\n  for (; i < length; ++i) {\n    options = arguments[i]; // Only deal with non-null/undefined values\n\n    if (options != null) {\n      // Extend the base object\n      for (name in options) {\n        src = getProperty(target, name);\n        copy = getProperty(options, name); // Prevent never-ending loop\n\n        if (target !== copy) {\n          // Recurse if we're merging plain objects or arrays\n          if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n            if (copyIsArray) {\n              copyIsArray = false;\n              clone = src && isArray(src) ? src : [];\n            } else {\n              clone = src && isPlainObject(src) ? src : {};\n            } // Never move original objects, clone them\n\n\n            setProperty(target, {\n              name: name,\n              newValue: extend(deep, clone, copy)\n            }); // Don't bring in undefined values\n          } else if (typeof copy !== 'undefined') {\n            setProperty(target, {\n              name: name,\n              newValue: copy\n            });\n          }\n        }\n      }\n    }\n  } // Return the modified object\n\n\n  return target;\n};","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\nmodule.exports = function isBuffer(obj) {\n  return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj);\n};","'use strict';\n\nmodule.exports = function (value) {\n  if (Object.prototype.toString.call(value) !== '[object Object]') {\n    return false;\n  }\n\n  var prototype = Object.getPrototypeOf(value);\n  return prototype === null || prototype === Object.prototype;\n};","'use strict';\n\nvar repeat = require('repeat-string');\n\nmodule.exports = markdownTable;\nvar trailingWhitespace = / +$/; // Characters.\n\nvar space = ' ';\nvar lineFeed = '\\n';\nvar dash = '-';\nvar colon = ':';\nvar verticalBar = '|';\nvar x = 0;\nvar C = 67;\nvar L = 76;\nvar R = 82;\nvar c = 99;\nvar l = 108;\nvar r = 114; // Create a table from a matrix of strings.\n\nfunction markdownTable(table, options) {\n  var settings = options || {};\n  var padding = settings.padding !== false;\n  var start = settings.delimiterStart !== false;\n  var end = settings.delimiterEnd !== false;\n  var align = (settings.align || []).concat();\n  var alignDelimiters = settings.alignDelimiters !== false;\n  var alignments = [];\n  var stringLength = settings.stringLength || defaultStringLength;\n  var rowIndex = -1;\n  var rowLength = table.length;\n  var cellMatrix = [];\n  var sizeMatrix = [];\n  var row = [];\n  var sizes = [];\n  var longestCellByColumn = [];\n  var mostCellsPerRow = 0;\n  var cells;\n  var columnIndex;\n  var columnLength;\n  var largest;\n  var size;\n  var cell;\n  var lines;\n  var line;\n  var before;\n  var after;\n  var code; // This is a superfluous loop if we don’t align delimiters, but otherwise we’d\n  // do superfluous work when aligning, so optimize for aligning.\n\n  while (++rowIndex < rowLength) {\n    cells = table[rowIndex];\n    columnIndex = -1;\n    columnLength = cells.length;\n    row = [];\n    sizes = [];\n\n    if (columnLength > mostCellsPerRow) {\n      mostCellsPerRow = columnLength;\n    }\n\n    while (++columnIndex < columnLength) {\n      cell = serialize(cells[columnIndex]);\n\n      if (alignDelimiters === true) {\n        size = stringLength(cell);\n        sizes[columnIndex] = size;\n        largest = longestCellByColumn[columnIndex];\n\n        if (largest === undefined || size > largest) {\n          longestCellByColumn[columnIndex] = size;\n        }\n      }\n\n      row.push(cell);\n    }\n\n    cellMatrix[rowIndex] = row;\n    sizeMatrix[rowIndex] = sizes;\n  } // Figure out which alignments to use.\n\n\n  columnIndex = -1;\n  columnLength = mostCellsPerRow;\n\n  if (typeof align === 'object' && 'length' in align) {\n    while (++columnIndex < columnLength) {\n      alignments[columnIndex] = toAlignment(align[columnIndex]);\n    }\n  } else {\n    code = toAlignment(align);\n\n    while (++columnIndex < columnLength) {\n      alignments[columnIndex] = code;\n    }\n  } // Inject the alignment row.\n\n\n  columnIndex = -1;\n  columnLength = mostCellsPerRow;\n  row = [];\n  sizes = [];\n\n  while (++columnIndex < columnLength) {\n    code = alignments[columnIndex];\n    before = '';\n    after = '';\n\n    if (code === l) {\n      before = colon;\n    } else if (code === r) {\n      after = colon;\n    } else if (code === c) {\n      before = colon;\n      after = colon;\n    } // There *must* be at least one hyphen-minus in each alignment cell.\n\n\n    size = alignDelimiters ? Math.max(1, longestCellByColumn[columnIndex] - before.length - after.length) : 1;\n    cell = before + repeat(dash, size) + after;\n\n    if (alignDelimiters === true) {\n      size = before.length + size + after.length;\n\n      if (size > longestCellByColumn[columnIndex]) {\n        longestCellByColumn[columnIndex] = size;\n      }\n\n      sizes[columnIndex] = size;\n    }\n\n    row[columnIndex] = cell;\n  } // Inject the alignment row.\n\n\n  cellMatrix.splice(1, 0, row);\n  sizeMatrix.splice(1, 0, sizes);\n  rowIndex = -1;\n  rowLength = cellMatrix.length;\n  lines = [];\n\n  while (++rowIndex < rowLength) {\n    row = cellMatrix[rowIndex];\n    sizes = sizeMatrix[rowIndex];\n    columnIndex = -1;\n    columnLength = mostCellsPerRow;\n    line = [];\n\n    while (++columnIndex < columnLength) {\n      cell = row[columnIndex] || '';\n      before = '';\n      after = '';\n\n      if (alignDelimiters === true) {\n        size = longestCellByColumn[columnIndex] - (sizes[columnIndex] || 0);\n        code = alignments[columnIndex];\n\n        if (code === r) {\n          before = repeat(space, size);\n        } else if (code === c) {\n          if (size % 2 === 0) {\n            before = repeat(space, size / 2);\n            after = before;\n          } else {\n            before = repeat(space, size / 2 + 0.5);\n            after = repeat(space, size / 2 - 0.5);\n          }\n        } else {\n          after = repeat(space, size);\n        }\n      }\n\n      if (start === true && columnIndex === 0) {\n        line.push(verticalBar);\n      }\n\n      if (padding === true && // Don’t add the opening space if we’re not aligning and the cell is\n      // empty: there will be a closing space.\n      !(alignDelimiters === false && cell === '') && (start === true || columnIndex !== 0)) {\n        line.push(space);\n      }\n\n      if (alignDelimiters === true) {\n        line.push(before);\n      }\n\n      line.push(cell);\n\n      if (alignDelimiters === true) {\n        line.push(after);\n      }\n\n      if (padding === true) {\n        line.push(space);\n      }\n\n      if (end === true || columnIndex !== columnLength - 1) {\n        line.push(verticalBar);\n      }\n    }\n\n    line = line.join('');\n\n    if (end === false) {\n      line = line.replace(trailingWhitespace, '');\n    }\n\n    lines.push(line);\n  }\n\n  return lines.join(lineFeed);\n}\n\nfunction serialize(value) {\n  return value === null || value === undefined ? '' : String(value);\n}\n\nfunction defaultStringLength(value) {\n  return value.length;\n}\n\nfunction toAlignment(value) {\n  var code = typeof value === 'string' ? value.charCodeAt(0) : x;\n  return code === L || code === l ? l : code === R || code === r ? r : code === C || code === c ? c : x;\n}","var visitWithParents = require('unist-util-visit-parents');\n\nfunction addListMetadata() {\n  return function (ast) {\n    visitWithParents(ast, 'list', function (listNode, parents) {\n      var depth = 0,\n          i,\n          n;\n\n      for (i = 0, n = parents.length; i < n; i++) {\n        if (parents[i].type === 'list') depth += 1;\n      }\n\n      for (i = 0, n = listNode.children.length; i < n; i++) {\n        var child = listNode.children[i];\n        child.index = i;\n        child.ordered = listNode.ordered;\n      }\n\n      listNode.depth = depth;\n    });\n    return ast;\n  };\n}\n\nmodule.exports = addListMetadata;","'use strict';\n/* Expose. */\n\nmodule.exports = visitParents;\n/* Visit. */\n\nfunction visitParents(tree, type, visitor) {\n  var stack = [];\n\n  if (typeof type === 'function') {\n    visitor = type;\n    type = null;\n  }\n\n  one(tree);\n  /* Visit a single node. */\n\n  function one(node) {\n    var result;\n\n    if (!type || node.type === type) {\n      result = visitor(node, stack.concat());\n    }\n\n    if (node.children && result !== false) {\n      return all(node.children, node);\n    }\n\n    return result;\n  }\n  /* Visit children in `parent`. */\n\n\n  function all(children, parent) {\n    var length = children.length;\n    var index = -1;\n    var child;\n    stack.push(parent);\n\n    while (++index < length) {\n      child = children[index];\n\n      if (child && one(child) === false) {\n        return false;\n      }\n    }\n\n    stack.pop();\n    return true;\n  }\n}","'use strict';\n\nmodule.exports = findAndReplace;\n\nvar visit = require('unist-util-visit-parents');\n\nvar convert = require('unist-util-is/convert');\n\nvar escape = require('escape-string-regexp');\n\nvar splice = [].splice;\n\nfunction findAndReplace(tree, find, replace, options) {\n  var settings;\n  var schema;\n\n  if (typeof find === 'string' || find && typeof find.exec === 'function') {\n    schema = [[find, replace]];\n  } else {\n    schema = find;\n    options = replace;\n  }\n\n  settings = options || {};\n  search(tree, settings, handlerFactory(toPairs(schema)));\n  return tree;\n\n  function handlerFactory(pairs) {\n    var pair = pairs[0];\n    return handler;\n\n    function handler(node, parent) {\n      var find = pair[0];\n      var replace = pair[1];\n      var nodes = [];\n      var start = 0;\n      var index = parent.children.indexOf(node);\n      var position;\n      var match;\n      var subhandler;\n      var value;\n      find.lastIndex = 0;\n      match = find.exec(node.value);\n\n      while (match) {\n        position = match.index;\n        value = replace.apply(null, [].concat(match, {\n          index: match.index,\n          input: match.input\n        }));\n\n        if (value !== false) {\n          if (start !== position) {\n            nodes.push({\n              type: 'text',\n              value: node.value.slice(start, position)\n            });\n          }\n\n          if (typeof value === 'string' && value.length > 0) {\n            value = {\n              type: 'text',\n              value: value\n            };\n          }\n\n          if (value) {\n            nodes = [].concat(nodes, value);\n          }\n\n          start = position + match[0].length;\n        }\n\n        if (!find.global) {\n          break;\n        }\n\n        match = find.exec(node.value);\n      }\n\n      if (position === undefined) {\n        nodes = [node];\n        index--;\n      } else {\n        if (start < node.value.length) {\n          nodes.push({\n            type: 'text',\n            value: node.value.slice(start)\n          });\n        }\n\n        nodes.unshift(index, 1);\n        splice.apply(parent.children, nodes);\n      }\n\n      if (pairs.length > 1) {\n        subhandler = handlerFactory(pairs.slice(1));\n        position = -1;\n\n        while (++position < nodes.length) {\n          node = nodes[position];\n\n          if (node.type === 'text') {\n            subhandler(node, parent);\n          } else {\n            search(node, settings, subhandler);\n          }\n        }\n      }\n\n      return index + nodes.length + 1;\n    }\n  }\n}\n\nfunction search(tree, settings, handler) {\n  var ignored = convert(settings.ignore || []);\n  var result = [];\n  visit(tree, 'text', visitor);\n  return result;\n\n  function visitor(node, parents) {\n    var index = -1;\n    var parent;\n    var grandparent;\n\n    while (++index < parents.length) {\n      parent = parents[index];\n\n      if (ignored(parent, grandparent ? grandparent.children.indexOf(parent) : undefined, grandparent)) {\n        return;\n      }\n\n      grandparent = parent;\n    }\n\n    return handler(node, grandparent);\n  }\n}\n\nfunction toPairs(schema) {\n  var result = [];\n  var key;\n  var index;\n\n  if (typeof schema !== 'object') {\n    throw new Error('Expected array or object as schema');\n  }\n\n  if ('length' in schema) {\n    index = -1;\n\n    while (++index < schema.length) {\n      result.push([toExpression(schema[index][0]), toFunction(schema[index][1])]);\n    }\n  } else {\n    for (key in schema) {\n      result.push([toExpression(key), toFunction(schema[key])]);\n    }\n  }\n\n  return result;\n}\n\nfunction toExpression(find) {\n  return typeof find === 'string' ? new RegExp(escape(find), 'g') : find;\n}\n\nfunction toFunction(replace) {\n  return typeof replace === 'function' ? replace : returner;\n\n  function returner() {\n    return replace;\n  }\n}","'use strict';\n\nmodule.exports = fromMarkdown; // These three are compiled away in the `dist/`\n\nvar toString = require('mdast-util-to-string');\n\nvar assign = require('micromark/dist/constant/assign');\n\nvar own = require('micromark/dist/constant/has-own-property');\n\nvar normalizeIdentifier = require('micromark/dist/util/normalize-identifier');\n\nvar safeFromInt = require('micromark/dist/util/safe-from-int');\n\nvar parser = require('micromark/dist/parse');\n\nvar preprocessor = require('micromark/dist/preprocess');\n\nvar postprocess = require('micromark/dist/postprocess');\n\nvar decode = require('parse-entities/decode-entity');\n\nvar stringifyPosition = require('unist-util-stringify-position');\n\nfunction fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding;\n    encoding = undefined;\n  }\n\n  return compiler(options)(postprocess(parser(options).document().write(preprocessor()(value, encoding, true))));\n} // Note this compiler only understand complete buffering, not streaming.\n\n\nfunction compiler(options) {\n  var settings = options || {};\n  var config = configure({\n    transforms: [],\n    canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],\n    enter: {\n      autolink: opener(link),\n      autolinkProtocol: onenterdata,\n      autolinkEmail: onenterdata,\n      atxHeading: opener(heading),\n      blockQuote: opener(blockQuote),\n      characterEscape: onenterdata,\n      characterReference: onenterdata,\n      codeFenced: opener(codeFlow),\n      codeFencedFenceInfo: buffer,\n      codeFencedFenceMeta: buffer,\n      codeIndented: opener(codeFlow, buffer),\n      codeText: opener(codeText, buffer),\n      codeTextData: onenterdata,\n      data: onenterdata,\n      codeFlowValue: onenterdata,\n      definition: opener(definition),\n      definitionDestinationString: buffer,\n      definitionLabelString: buffer,\n      definitionTitleString: buffer,\n      emphasis: opener(emphasis),\n      hardBreakEscape: opener(hardBreak),\n      hardBreakTrailing: opener(hardBreak),\n      htmlFlow: opener(html, buffer),\n      htmlFlowData: onenterdata,\n      htmlText: opener(html, buffer),\n      htmlTextData: onenterdata,\n      image: opener(image),\n      label: buffer,\n      link: opener(link),\n      listItem: opener(listItem),\n      listItemValue: onenterlistitemvalue,\n      listOrdered: opener(list, onenterlistordered),\n      listUnordered: opener(list),\n      paragraph: opener(paragraph),\n      reference: onenterreference,\n      referenceString: buffer,\n      resourceDestinationString: buffer,\n      resourceTitleString: buffer,\n      setextHeading: opener(heading),\n      strong: opener(strong),\n      thematicBreak: opener(thematicBreak)\n    },\n    exit: {\n      atxHeading: closer(),\n      atxHeadingSequence: onexitatxheadingsequence,\n      autolink: closer(),\n      autolinkEmail: onexitautolinkemail,\n      autolinkProtocol: onexitautolinkprotocol,\n      blockQuote: closer(),\n      characterEscapeValue: onexitdata,\n      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n      characterReferenceValue: onexitcharacterreferencevalue,\n      codeFenced: closer(onexitcodefenced),\n      codeFencedFence: onexitcodefencedfence,\n      codeFencedFenceInfo: onexitcodefencedfenceinfo,\n      codeFencedFenceMeta: onexitcodefencedfencemeta,\n      codeFlowValue: onexitdata,\n      codeIndented: closer(onexitcodeindented),\n      codeText: closer(onexitcodetext),\n      codeTextData: onexitdata,\n      data: onexitdata,\n      definition: closer(),\n      definitionDestinationString: onexitdefinitiondestinationstring,\n      definitionLabelString: onexitdefinitionlabelstring,\n      definitionTitleString: onexitdefinitiontitlestring,\n      emphasis: closer(),\n      hardBreakEscape: closer(onexithardbreak),\n      hardBreakTrailing: closer(onexithardbreak),\n      htmlFlow: closer(onexithtmlflow),\n      htmlFlowData: onexitdata,\n      htmlText: closer(onexithtmltext),\n      htmlTextData: onexitdata,\n      image: closer(onexitimage),\n      label: onexitlabel,\n      labelText: onexitlabeltext,\n      lineEnding: onexitlineending,\n      link: closer(onexitlink),\n      listItem: closer(),\n      listOrdered: closer(),\n      listUnordered: closer(),\n      paragraph: closer(),\n      referenceString: onexitreferencestring,\n      resourceDestinationString: onexitresourcedestinationstring,\n      resourceTitleString: onexitresourcetitlestring,\n      resource: onexitresource,\n      setextHeading: closer(onexitsetextheading),\n      setextHeadingLineSequence: onexitsetextheadinglinesequence,\n      setextHeadingText: onexitsetextheadingtext,\n      strong: closer(),\n      thematicBreak: closer()\n    }\n  }, settings.mdastExtensions || []);\n  var data = {};\n  return compile;\n\n  function compile(events) {\n    var tree = {\n      type: 'root',\n      children: []\n    };\n    var stack = [tree];\n    var tokenStack = [];\n    var listStack = [];\n    var index = -1;\n    var handler;\n    var listStart;\n    var context = {\n      stack: stack,\n      tokenStack: tokenStack,\n      config: config,\n      enter: enter,\n      exit: exit,\n      buffer: buffer,\n      resume: resume,\n      setData: setData,\n      getData: getData\n    };\n\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (events[index][1].type === 'listOrdered' || events[index][1].type === 'listUnordered') {\n        if (events[index][0] === 'enter') {\n          listStack.push(index);\n        } else {\n          listStart = listStack.pop(index);\n          index = prepareList(events, listStart, index);\n        }\n      }\n    }\n\n    index = -1;\n\n    while (++index < events.length) {\n      handler = config[events[index][0]];\n\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(assign({\n          sliceSerialize: events[index][2].sliceSerialize\n        }, context), events[index][1]);\n      }\n    }\n\n    if (tokenStack.length) {\n      throw new Error('Cannot close document, a token (`' + tokenStack[tokenStack.length - 1].type + '`, ' + stringifyPosition({\n        start: tokenStack[tokenStack.length - 1].start,\n        end: tokenStack[tokenStack.length - 1].end\n      }) + ') is still open');\n    } // Figure out `root` position.\n\n\n    tree.position = {\n      start: point(events.length ? events[0][1].start : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }),\n      end: point(events.length ? events[events.length - 2][1].end : {\n        line: 1,\n        column: 1,\n        offset: 0\n      })\n    };\n    index = -1;\n\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree;\n    }\n\n    return tree;\n  }\n\n  function prepareList(events, start, length) {\n    var index = start - 1;\n    var containerBalance = -1;\n    var listSpread = false;\n    var listItem;\n    var tailIndex;\n    var lineIndex;\n    var tailEvent;\n    var event;\n    var firstBlankLineIndex;\n    var atMarker;\n\n    while (++index <= length) {\n      event = events[index];\n\n      if (event[1].type === 'listUnordered' || event[1].type === 'listOrdered' || event[1].type === 'blockQuote') {\n        if (event[0] === 'enter') {\n          containerBalance++;\n        } else {\n          containerBalance--;\n        }\n\n        atMarker = undefined;\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (listItem && !atMarker && !containerBalance && !firstBlankLineIndex) {\n            firstBlankLineIndex = index;\n          }\n\n          atMarker = undefined;\n        }\n      } else if (event[1].type === 'linePrefix' || event[1].type === 'listItemValue' || event[1].type === 'listItemMarker' || event[1].type === 'listItemPrefix' || event[1].type === 'listItemPrefixWhitespace') {// Empty.\n      } else {\n        atMarker = undefined;\n      }\n\n      if (!containerBalance && event[0] === 'enter' && event[1].type === 'listItemPrefix' || containerBalance === -1 && event[0] === 'exit' && (event[1].type === 'listUnordered' || event[1].type === 'listOrdered')) {\n        if (listItem) {\n          tailIndex = index;\n          lineIndex = undefined;\n\n          while (tailIndex--) {\n            tailEvent = events[tailIndex];\n\n            if (tailEvent[1].type === 'lineEnding' || tailEvent[1].type === 'lineEndingBlank') {\n              if (tailEvent[0] === 'exit') continue;\n\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank';\n                listSpread = true;\n              }\n\n              tailEvent[1].type = 'lineEnding';\n              lineIndex = tailIndex;\n            } else if (tailEvent[1].type === 'linePrefix' || tailEvent[1].type === 'blockQuotePrefix' || tailEvent[1].type === 'blockQuotePrefixWhitespace' || tailEvent[1].type === 'blockQuoteMarker' || tailEvent[1].type === 'listItemIndent') {// Empty\n            } else {\n              break;\n            }\n          }\n\n          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {\n            listItem._spread = true;\n          } // Fix position.\n\n\n          listItem.end = point(lineIndex ? events[lineIndex][1].start : event[1].end);\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]]);\n          index++;\n          length++;\n        } // Create a new list item.\n\n\n        if (event[1].type === 'listItemPrefix') {\n          listItem = {\n            type: 'listItem',\n            _spread: false,\n            start: point(event[1].start)\n          };\n          events.splice(index, 0, ['enter', listItem, event[2]]);\n          index++;\n          length++;\n          firstBlankLineIndex = undefined;\n          atMarker = true;\n        }\n      }\n    }\n\n    events[start][1]._spread = listSpread;\n    return length;\n  }\n\n  function setData(key, value) {\n    data[key] = value;\n  }\n\n  function getData(key) {\n    return data[key];\n  }\n\n  function point(d) {\n    return {\n      line: d.line,\n      column: d.column,\n      offset: d.offset\n    };\n  }\n\n  function opener(create, and) {\n    return open;\n\n    function open(token) {\n      enter.call(this, create(token), token);\n      if (and) and.call(this, token);\n    }\n  }\n\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    });\n  }\n\n  function enter(node, token) {\n    this.stack[this.stack.length - 1].children.push(node);\n    this.stack.push(node);\n    this.tokenStack.push(token);\n    node.position = {\n      start: point(token.start)\n    };\n    return node;\n  }\n\n  function closer(and) {\n    return close;\n\n    function close(token) {\n      if (and) and.call(this, token);\n      exit.call(this, token);\n    }\n  }\n\n  function exit(token) {\n    var node = this.stack.pop();\n    var open = this.tokenStack.pop();\n\n    if (!open) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): it’s not open');\n    } else if (open.type !== token.type) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): a different token (`' + open.type + '`, ' + stringifyPosition({\n        start: open.start,\n        end: open.end\n      }) + ') is open');\n    }\n\n    node.position.end = point(token.end);\n    return node;\n  }\n\n  function resume() {\n    return toString(this.stack.pop());\n  } //\n  // Handlers.\n  //\n\n\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true);\n  }\n\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      this.stack[this.stack.length - 2].start = parseInt(this.sliceSerialize(token), 10);\n      setData('expectingFirstListItemValue');\n    }\n  }\n\n  function onexitcodefencedfenceinfo() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].lang = data;\n  }\n\n  function onexitcodefencedfencemeta() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].meta = data;\n  }\n\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (getData('flowCodeInside')) return;\n    this.buffer();\n    setData('flowCodeInside', true);\n  }\n\n  function onexitcodefenced() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '');\n    setData('flowCodeInside');\n  }\n\n  function onexitcodeindented() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexitdefinitionlabelstring(token) {\n    // Discard label, use the source content instead.\n    var label = this.resume();\n    this.stack[this.stack.length - 1].label = label;\n    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n\n  function onexitdefinitiontitlestring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].title = data;\n  }\n\n  function onexitdefinitiondestinationstring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].url = data;\n  }\n\n  function onexitatxheadingsequence(token) {\n    if (!this.stack[this.stack.length - 1].depth) {\n      this.stack[this.stack.length - 1].depth = this.sliceSerialize(token).length;\n    }\n  }\n\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true);\n  }\n\n  function onexitsetextheadinglinesequence(token) {\n    this.stack[this.stack.length - 1].depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2;\n  }\n\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding');\n  }\n\n  function onenterdata(token) {\n    var siblings = this.stack[this.stack.length - 1].children;\n    var tail = siblings[siblings.length - 1];\n\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text();\n      tail.position = {\n        start: point(token.start)\n      };\n      this.stack[this.stack.length - 1].children.push(tail);\n    }\n\n    this.stack.push(tail);\n  }\n\n  function onexitdata(token) {\n    var tail = this.stack.pop();\n    tail.value += this.sliceSerialize(token);\n    tail.position.end = point(token.end);\n  }\n\n  function onexitlineending(token) {\n    var context = this.stack[this.stack.length - 1]; // If we’re at a hard break, include the line ending in there.\n\n    if (getData('atHardBreak')) {\n      context.children[context.children.length - 1].position.end = point(token.end);\n      setData('atHardBreak');\n      return;\n    }\n\n    if (!getData('setextHeadingSlurpLineEnding') && config.canContainEols.indexOf(context.type) > -1) {\n      onenterdata.call(this, token);\n      onexitdata.call(this, token);\n    }\n  }\n\n  function onexithardbreak() {\n    setData('atHardBreak', true);\n  }\n\n  function onexithtmlflow() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexithtmltext() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexitcodetext() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].value = data;\n  }\n\n  function onexitlink() {\n    var context = this.stack[this.stack.length - 1]; // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference';\n      context.referenceType = getData('referenceType') || 'shortcut';\n      delete context.url;\n      delete context.title;\n    } else {\n      delete context.identifier;\n      delete context.label;\n      delete context.referenceType;\n    }\n\n    setData('referenceType');\n  }\n\n  function onexitimage() {\n    var context = this.stack[this.stack.length - 1]; // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference';\n      context.referenceType = getData('referenceType') || 'shortcut';\n      delete context.url;\n      delete context.title;\n    } else {\n      delete context.identifier;\n      delete context.label;\n      delete context.referenceType;\n    }\n\n    setData('referenceType');\n  }\n\n  function onexitlabeltext(token) {\n    this.stack[this.stack.length - 2].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n\n  function onexitlabel() {\n    var fragment = this.stack[this.stack.length - 1];\n    var value = this.resume();\n    this.stack[this.stack.length - 1].label = value; // Assume a reference.\n\n    setData('inReference', true);\n\n    if (this.stack[this.stack.length - 1].type === 'link') {\n      this.stack[this.stack.length - 1].children = fragment.children;\n    } else {\n      this.stack[this.stack.length - 1].alt = value;\n    }\n  }\n\n  function onexitresourcedestinationstring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].url = data;\n  }\n\n  function onexitresourcetitlestring() {\n    var data = this.resume();\n    this.stack[this.stack.length - 1].title = data;\n  }\n\n  function onexitresource() {\n    setData('inReference');\n  }\n\n  function onenterreference() {\n    setData('referenceType', 'collapsed');\n  }\n\n  function onexitreferencestring(token) {\n    var label = this.resume();\n    this.stack[this.stack.length - 1].label = label;\n    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n    setData('referenceType', 'full');\n  }\n\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type);\n  }\n\n  function onexitcharacterreferencevalue(token) {\n    var data = this.sliceSerialize(token);\n    var type = getData('characterReferenceType');\n    var value;\n    var tail;\n\n    if (type) {\n      value = safeFromInt(data, type === 'characterReferenceMarkerNumeric' ? 10 : 16);\n      setData('characterReferenceType');\n    } else {\n      value = decode(data);\n    }\n\n    tail = this.stack.pop();\n    tail.value += value;\n    tail.position.end = point(token.end);\n  }\n\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token);\n    this.stack[this.stack.length - 1].url = this.sliceSerialize(token);\n  }\n\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token);\n    this.stack[this.stack.length - 1].url = 'mailto:' + this.sliceSerialize(token);\n  } //\n  // Creaters.\n  //\n\n\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    };\n  }\n\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    };\n  }\n\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    };\n  }\n\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    };\n  }\n\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    };\n  }\n\n  function heading() {\n    return {\n      type: 'heading',\n      depth: undefined,\n      children: []\n    };\n  }\n\n  function hardBreak() {\n    return {\n      type: 'break'\n    };\n  }\n\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    };\n  }\n\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    };\n  }\n\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    };\n  }\n\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      spread: token._spread,\n      children: []\n    };\n  }\n\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    };\n  }\n\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    };\n  }\n\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    };\n  }\n\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    };\n  }\n\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    };\n  }\n}\n\nfunction configure(config, extensions) {\n  var index = -1;\n\n  while (++index < extensions.length) {\n    extension(config, extensions[index]);\n  }\n\n  return config;\n}\n\nfunction extension(config, extension) {\n  var key;\n  var left;\n\n  for (key in extension) {\n    left = own.call(config, key) ? config[key] : config[key] = {};\n\n    if (key === 'canContainEols' || key === 'transforms') {\n      config[key] = [].concat(left, extension[key]);\n    } else {\n      Object.assign(left, extension[key]);\n    }\n  }\n}","'use strict';\n\nmodule.exports = require('./dist');","var ccount = require('ccount');\n\nvar findAndReplace = require('mdast-util-find-and-replace');\n\nvar unicodePunctuation = require('micromark/dist/character/unicode-punctuation');\n\nvar unicodeWhitespace = require('micromark/dist/character/unicode-whitespace');\n\nexports.transforms = [transformGfmAutolinkLiterals];\nexports.enter = {\n  literalAutolink: enterLiteralAutolink,\n  literalAutolinkEmail: enterLiteralAutolinkValue,\n  literalAutolinkHttp: enterLiteralAutolinkValue,\n  literalAutolinkWww: enterLiteralAutolinkValue\n};\nexports.exit = {\n  literalAutolink: exitLiteralAutolink,\n  literalAutolinkEmail: exitLiteralAutolinkEmail,\n  literalAutolinkHttp: exitLiteralAutolinkHttp,\n  literalAutolinkWww: exitLiteralAutolinkWww\n};\n\nfunction enterLiteralAutolink(token) {\n  this.enter({\n    type: 'link',\n    title: null,\n    url: '',\n    children: []\n  }, token);\n}\n\nfunction enterLiteralAutolinkValue(token) {\n  this.config.enter.autolinkProtocol.call(this, token);\n}\n\nfunction exitLiteralAutolinkHttp(token) {\n  this.config.exit.autolinkProtocol.call(this, token);\n}\n\nfunction exitLiteralAutolinkWww(token) {\n  this.config.exit.data.call(this, token);\n  this.stack[this.stack.length - 1].url = 'http://' + this.sliceSerialize(token);\n}\n\nfunction exitLiteralAutolinkEmail(token) {\n  this.config.exit.autolinkEmail.call(this, token);\n}\n\nfunction exitLiteralAutolink(token) {\n  this.exit(token);\n}\n\nfunction transformGfmAutolinkLiterals(tree) {\n  findAndReplace(tree, [[/(https?:\\/\\/|www(?=\\.))([-.\\w]+)([^ \\t\\r\\n]*)/i, findUrl], [/([-.\\w+]+)@([-\\w]+(?:\\.[-\\w]+)+)/, findEmail]], {\n    ignore: ['link', 'linkReference']\n  });\n}\n\nfunction findUrl($0, protocol, domain, path, match) {\n  var prefix = '';\n  var parts;\n  var result; // Not an expected previous character.\n\n  if (!previous(match)) {\n    return false;\n  } // Treat `www` as part of the domain.\n\n\n  if (/^w/i.test(protocol)) {\n    domain = protocol + domain;\n    protocol = '';\n    prefix = 'http://';\n  }\n\n  if (!isCorrectDomain(domain)) {\n    return false;\n  }\n\n  parts = splitUrl(domain + path);\n  if (!parts[0]) return false;\n  result = {\n    type: 'link',\n    title: null,\n    url: prefix + protocol + parts[0],\n    children: [{\n      type: 'text',\n      value: protocol + parts[0]\n    }]\n  };\n\n  if (parts[1]) {\n    result = [result, {\n      type: 'text',\n      value: parts[1]\n    }];\n  }\n\n  return result;\n}\n\nfunction findEmail($0, atext, label, match) {\n  // Not an expected previous character.\n  if (!previous(match, true) || /[_-]$/.test(label)) {\n    return false;\n  }\n\n  return {\n    type: 'link',\n    title: null,\n    url: 'mailto:' + atext + '@' + label,\n    children: [{\n      type: 'text',\n      value: atext + '@' + label\n    }]\n  };\n}\n\nfunction isCorrectDomain(domain) {\n  var parts = domain.split('.');\n\n  if (parts.length < 2 || parts[parts.length - 1] && (/_/.test(parts[parts.length - 1]) || !/[a-zA-Z\\d]/.test(parts[parts.length - 1])) || parts[parts.length - 2] && (/_/.test(parts[parts.length - 2]) || !/[a-zA-Z\\d]/.test(parts[parts.length - 2]))) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction splitUrl(url) {\n  var trail = /[!\"&'),.:;<>?\\]}]+$/.exec(url);\n  var closingParenIndex;\n  var openingParens;\n  var closingParens;\n\n  if (trail) {\n    url = url.slice(0, trail.index);\n    trail = trail[0];\n    closingParenIndex = trail.indexOf(')');\n    openingParens = ccount(url, '(');\n    closingParens = ccount(url, ')');\n\n    while (closingParenIndex !== -1 && openingParens > closingParens) {\n      url += trail.slice(0, closingParenIndex + 1);\n      trail = trail.slice(closingParenIndex + 1);\n      closingParenIndex = trail.indexOf(')');\n      closingParens++;\n    }\n  }\n\n  return [url, trail];\n}\n\nfunction previous(match, email) {\n  var code = match.input.charCodeAt(match.index - 1);\n  return (code !== code || unicodeWhitespace(code) || unicodePunctuation(code)) && (!email || code !== 47);\n}","var inConstruct = 'phrasing';\nvar notInConstruct = ['autolink', 'link', 'image', 'label'];\nexports.unsafe = [{\n  character: '@',\n  before: '[+\\\\-.\\\\w]',\n  after: '[\\\\-.\\\\w]',\n  inConstruct: inConstruct,\n  notInConstruct: notInConstruct\n}, {\n  character: '.',\n  before: '[Ww]',\n  after: '[\\\\-.\\\\w]',\n  inConstruct: inConstruct,\n  notInConstruct: notInConstruct\n}, {\n  character: ':',\n  before: '[ps]',\n  after: '\\\\/',\n  inConstruct: inConstruct,\n  notInConstruct: notInConstruct\n}];","exports.canContainEols = ['delete'];\nexports.enter = {\n  strikethrough: enterStrikethrough\n};\nexports.exit = {\n  strikethrough: exitStrikethrough\n};\n\nfunction enterStrikethrough(token) {\n  this.enter({\n    type: 'delete',\n    children: []\n  }, token);\n}\n\nfunction exitStrikethrough(token) {\n  this.exit(token);\n}","var phrasing = require('mdast-util-to-markdown/lib/util/container-phrasing');\n\nexports.unsafe = [{\n  character: '~',\n  inConstruct: 'phrasing'\n}];\nexports.handlers = {\n  delete: handleDelete\n};\nhandleDelete.peek = peekDelete;\n\nfunction handleDelete(node, _, context) {\n  var exit = context.enter('emphasis');\n  var value = phrasing(node, context, {\n    before: '~',\n    after: '~'\n  });\n  exit();\n  return '~~' + value + '~~';\n}\n\nfunction peekDelete() {\n  return '~';\n}","exports.enter = {\n  table: enterTable,\n  tableData: enterCell,\n  tableHeader: enterCell,\n  tableRow: enterRow\n};\nexports.exit = {\n  codeText: exitCodeText,\n  table: exitTable,\n  tableData: exit,\n  tableHeader: exit,\n  tableRow: exit\n};\n\nfunction enterTable(token) {\n  this.enter({\n    type: 'table',\n    align: token._align,\n    children: []\n  }, token);\n  this.setData('inTable', true);\n}\n\nfunction exitTable(token) {\n  this.exit(token);\n  this.setData('inTable');\n}\n\nfunction enterRow(token) {\n  this.enter({\n    type: 'tableRow',\n    children: []\n  }, token);\n}\n\nfunction exit(token) {\n  this.exit(token);\n}\n\nfunction enterCell(token) {\n  this.enter({\n    type: 'tableCell',\n    children: []\n  }, token);\n} // Overwrite the default code text data handler to unescape escaped pipes when\n// they are in tables.\n\n\nfunction exitCodeText(token) {\n  var value = this.resume();\n\n  if (this.getData('inTable')) {\n    value = value.replace(/\\\\([\\\\|])/g, replace);\n  }\n\n  this.stack[this.stack.length - 1].value = value;\n  this.exit(token);\n}\n\nfunction replace($0, $1) {\n  // Pipes work, backslashes don’t (but can’t escape pipes).\n  return $1 === '|' ? $1 : $0;\n}","var phrasing = require('mdast-util-to-markdown/lib/util/container-phrasing');\n\nvar defaultInlineCode = require('mdast-util-to-markdown/lib/handle/inline-code');\n\nvar markdownTable = require('markdown-table');\n\nmodule.exports = toMarkdown;\n\nfunction toMarkdown(options) {\n  var settings = options || {};\n  var padding = settings.tableCellPadding;\n  var alignDelimiters = settings.tablePipeAlign;\n  var stringLength = settings.stringLength;\n  var around = padding ? ' ' : '|';\n  return {\n    unsafe: [{\n      character: '\\r',\n      inConstruct: 'tableCell'\n    }, {\n      character: '\\n',\n      inConstruct: 'tableCell'\n    }, // A pipe, when followed by a tab or space (padding), or a dash or colon\n    // (unpadded delimiter row), could result in a table.\n    {\n      atBreak: true,\n      character: '|',\n      after: '[\\t :-]'\n    }, // A pipe in a cell must be encoded.\n    {\n      character: '|',\n      inConstruct: 'tableCell'\n    }, // A colon must be followed by a dash, in which case it could start a\n    // delimiter row.\n    {\n      atBreak: true,\n      character: ':',\n      after: '-'\n    }, // A delimiter row can also start with a dash, when followed by more\n    // dashes, a colon, or a pipe.\n    // This is a stricter version than the built in check for lists, thematic\n    // breaks, and setex heading underlines though:\n    // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>\n    {\n      atBreak: true,\n      character: '-',\n      after: '[:|-]'\n    }],\n    handlers: {\n      table: handleTable,\n      tableRow: handleTableRow,\n      tableCell: handleTableCell,\n      inlineCode: inlineCodeWithTable\n    }\n  };\n\n  function handleTable(node, _, context) {\n    return serializeData(handleTableAsData(node, context), node.align);\n  } // This function isn’t really used normally, because we handle rows at the\n  // table level.\n  // But, if someone passes in a table row, this ensures we make somewhat sense.\n\n\n  function handleTableRow(node, _, context) {\n    var row = handleTableRowAsData(node, context); // `markdown-table` will always add an align row\n\n    var value = serializeData([row]);\n    return value.slice(0, value.indexOf('\\n'));\n  }\n\n  function handleTableCell(node, _, context) {\n    var exit = context.enter('tableCell');\n    var value = phrasing(node, context, {\n      before: around,\n      after: around\n    });\n    exit();\n    return value;\n  }\n\n  function serializeData(matrix, align) {\n    return markdownTable(matrix, {\n      align: align,\n      alignDelimiters: alignDelimiters,\n      padding: padding,\n      stringLength: stringLength\n    });\n  }\n\n  function handleTableAsData(node, context) {\n    var children = node.children;\n    var index = -1;\n    var length = children.length;\n    var result = [];\n    var subexit = context.enter('table');\n\n    while (++index < length) {\n      result[index] = handleTableRowAsData(children[index], context);\n    }\n\n    subexit();\n    return result;\n  }\n\n  function handleTableRowAsData(node, context) {\n    var children = node.children;\n    var index = -1;\n    var length = children.length;\n    var result = [];\n    var subexit = context.enter('tableRow');\n\n    while (++index < length) {\n      result[index] = handleTableCell(children[index], node, context);\n    }\n\n    subexit();\n    return result;\n  }\n\n  function inlineCodeWithTable(node, parent, context) {\n    var value = defaultInlineCode(node, parent, context);\n\n    if (context.stack.indexOf('tableCell') !== -1) {\n      value = value.replace(/\\|/g, '\\\\$&');\n    }\n\n    return value;\n  }\n}","exports.exit = {\n  taskListCheckValueChecked: exitCheck,\n  taskListCheckValueUnchecked: exitCheck,\n  paragraph: exitParagraphWithTaskListItem\n};\n\nfunction exitCheck(token) {\n  // We’re always in a paragraph, in a list item.\n  this.stack[this.stack.length - 2].checked = token.type === 'taskListCheckValueChecked';\n}\n\nfunction exitParagraphWithTaskListItem(token) {\n  var parent = this.stack[this.stack.length - 2];\n  var node = this.stack[this.stack.length - 1];\n  var siblings = parent.children;\n  var head = node.children[0];\n  var index = -1;\n  var firstParaghraph;\n\n  if (parent && parent.type === 'listItem' && typeof parent.checked === 'boolean' && head && head.type === 'text') {\n    while (++index < siblings.length) {\n      if (siblings[index].type === 'paragraph') {\n        firstParaghraph = siblings[index];\n        break;\n      }\n    }\n\n    if (firstParaghraph === node) {\n      // Must start with a space or a tab.\n      head.value = head.value.slice(1);\n\n      if (head.value.length === 0) {\n        node.children.shift();\n      } else {\n        head.position.start.column++;\n        head.position.start.offset++;\n        node.position.start = Object.assign({}, head.position.start);\n      }\n    }\n  }\n\n  this.exit(token);\n}","var defaultListItem = require('mdast-util-to-markdown/lib/handle/list-item');\n\nexports.unsafe = [{\n  atBreak: true,\n  character: '-',\n  after: '[:|-]'\n}];\nexports.handlers = {\n  listItem: listItemWithTaskListItem\n};\n\nfunction listItemWithTaskListItem(node, parent, context) {\n  var value = defaultListItem(node, parent, context);\n  var head = node.children[0];\n\n  if (typeof node.checked === 'boolean' && head && head.type === 'paragraph') {\n    value = value.replace(/^(?:[*+-]|\\d+\\.)([\\r\\n]| {1,3})/, check);\n  }\n\n  return value;\n\n  function check($0) {\n    return $0 + '[' + (node.checked ? 'x' : ' ') + '] ';\n  }\n}","var autolinkLiteral = require('mdast-util-gfm-autolink-literal/from-markdown');\n\nvar strikethrough = require('mdast-util-gfm-strikethrough/from-markdown');\n\nvar table = require('mdast-util-gfm-table/from-markdown');\n\nvar taskListItem = require('mdast-util-gfm-task-list-item/from-markdown');\n\nvar own = {}.hasOwnProperty;\nmodule.exports = configure([autolinkLiteral, strikethrough, table, taskListItem]);\n\nfunction configure(extensions) {\n  var config = {\n    transforms: [],\n    canContainEols: []\n  };\n  var length = extensions.length;\n  var index = -1;\n\n  while (++index < length) {\n    extension(config, extensions[index]);\n  }\n\n  return config;\n}\n\nfunction extension(config, extension) {\n  var key;\n  var left;\n  var right;\n\n  for (key in extension) {\n    left = own.call(config, key) ? config[key] : config[key] = {};\n    right = extension[key];\n\n    if (key === 'canContainEols' || key === 'transforms') {\n      config[key] = [].concat(left, right);\n    } else {\n      Object.assign(left, right);\n    }\n  }\n}","var autolinkLiteral = require('mdast-util-gfm-autolink-literal/to-markdown');\n\nvar strikethrough = require('mdast-util-gfm-strikethrough/to-markdown');\n\nvar table = require('mdast-util-gfm-table/to-markdown');\n\nvar taskListItem = require('mdast-util-gfm-task-list-item/to-markdown');\n\nvar configure = require('mdast-util-to-markdown/lib/configure');\n\nmodule.exports = toMarkdown;\n\nfunction toMarkdown(options) {\n  var config = configure({\n    handlers: {},\n    join: [],\n    unsafe: [],\n    options: {}\n  }, {\n    extensions: [autolinkLiteral, strikethrough, table(options), taskListItem]\n  });\n  return Object.assign(config.options, {\n    handlers: config.handlers,\n    join: config.join,\n    unsafe: config.unsafe\n  });\n}","module.exports = configure;\n\nfunction configure(base, extension) {\n  var index = -1;\n  var key; // First do subextensions.\n\n  if (extension.extensions) {\n    while (++index < extension.extensions.length) {\n      configure(base, extension.extensions[index]);\n    }\n  }\n\n  for (key in extension) {\n    if (key === 'extensions') {// Empty.\n    } else if (key === 'unsafe' || key === 'join') {\n      base[key] = base[key].concat(extension[key] || []);\n    } else if (key === 'handlers') {\n      base[key] = Object.assign(base[key], extension[key] || {});\n    } else {\n      base.options[key] = extension[key];\n    }\n  }\n\n  return base;\n}","module.exports = inlineCode;\ninlineCode.peek = inlineCodePeek;\n\nvar patternCompile = require('../util/pattern-compile');\n\nfunction inlineCode(node, parent, context) {\n  var value = node.value || '';\n  var sequence = '`';\n  var index = -1;\n  var pattern;\n  var expression;\n  var match;\n  var position; // If there is a single grave accent on its own in the code, use a fence of\n  // two.\n  // If there are two in a row, use one.\n\n  while (new RegExp('(^|[^`])' + sequence + '([^`]|$)').test(value)) {\n    sequence += '`';\n  } // If this is not just spaces or eols (tabs don’t count), and either the\n  // first or last character are a space, eol, or tick, then pad with spaces.\n\n\n  if (/[^ \\r\\n]/.test(value) && (/[ \\r\\n`]/.test(value.charAt(0)) || /[ \\r\\n`]/.test(value.charAt(value.length - 1)))) {\n    value = ' ' + value + ' ';\n  } // We have a potential problem: certain characters after eols could result in\n  // blocks being seen.\n  // For example, if someone injected the string `'\\n# b'`, then that would\n  // result in an ATX heading.\n  // We can’t escape characters in `inlineCode`, but because eols are\n  // transformed to spaces when going from markdown to HTML anyway, we can swap\n  // them out.\n\n\n  while (++index < context.unsafe.length) {\n    pattern = context.unsafe[index]; // Only look for `atBreak`s.\n    // Btw: note that `atBreak` patterns will always start the regex at LF or\n    // CR.\n\n    if (!pattern.atBreak) continue;\n    expression = patternCompile(pattern);\n\n    while (match = expression.exec(value)) {\n      position = match.index; // Support CRLF (patterns only look for one of the characters).\n\n      if (value.charCodeAt(position) === 10\n      /* `\\n` */\n      && value.charCodeAt(position - 1) === 13\n      /* `\\r` */\n      ) {\n          position--;\n        }\n\n      value = value.slice(0, position) + ' ' + value.slice(match.index + 1);\n    }\n  }\n\n  return sequence + value + sequence;\n}\n\nfunction inlineCodePeek() {\n  return '`';\n}","module.exports = listItem;\n\nvar repeat = require('repeat-string');\n\nvar checkBullet = require('../util/check-bullet');\n\nvar checkListItemIndent = require('../util/check-list-item-indent');\n\nvar flow = require('../util/container-flow');\n\nvar indentLines = require('../util/indent-lines');\n\nfunction listItem(node, parent, context) {\n  var bullet = checkBullet(context);\n  var listItemIndent = checkListItemIndent(context);\n  var size;\n  var value;\n  var exit;\n\n  if (parent && parent.ordered) {\n    bullet = (parent.start > -1 ? parent.start : 1) + (context.options.incrementListMarker === false ? 0 : parent.children.indexOf(node)) + '.';\n  }\n\n  size = bullet.length + 1;\n\n  if (listItemIndent === 'tab' || listItemIndent === 'mixed' && (parent && parent.spread || node.spread)) {\n    size = Math.ceil(size / 4) * 4;\n  }\n\n  exit = context.enter('listItem');\n  value = indentLines(flow(node, context), map);\n  exit();\n  return value;\n\n  function map(line, index, blank) {\n    if (index) {\n      return (blank ? '' : repeat(' ', size)) + line;\n    }\n\n    return (blank ? bullet : bullet + repeat(' ', size - bullet.length)) + line;\n  }\n}","module.exports = checkBullet;\n\nfunction checkBullet(context) {\n  var marker = context.options.bullet || '*';\n\n  if (marker !== '*' && marker !== '+' && marker !== '-') {\n    throw new Error('Cannot serialize items with `' + marker + '` for `options.bullet`, expected `*`, `+`, or `-`');\n  }\n\n  return marker;\n}","module.exports = checkListItemIndent;\n\nfunction checkListItemIndent(context) {\n  var style = context.options.listItemIndent || 'tab';\n\n  if (style === 1 || style === '1') {\n    return 'one';\n  }\n\n  if (style !== 'tab' && style !== 'one' && style !== 'mixed') {\n    throw new Error('Cannot serialize items with `' + style + '` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`');\n  }\n\n  return style;\n}","module.exports = flow;\n\nvar repeat = require('repeat-string');\n\nfunction flow(parent, context) {\n  var children = parent.children || [];\n  var results = [];\n  var index = -1;\n  var child;\n\n  while (++index < children.length) {\n    child = children[index];\n    results.push(context.handle(child, parent, context, {\n      before: '\\n',\n      after: '\\n'\n    }));\n\n    if (index + 1 < children.length) {\n      results.push(between(child, children[index + 1]));\n    }\n  }\n\n  return results.join('');\n\n  function between(left, right) {\n    var index = -1;\n    var result;\n\n    while (++index < context.join.length) {\n      result = context.join[index](left, right, parent, context);\n\n      if (result === true || result === 1) {\n        break;\n      }\n\n      if (typeof result === 'number') {\n        return repeat('\\n', 1 + Number(result));\n      }\n\n      if (result === false) {\n        return '\\n\\n<!---->\\n\\n';\n      }\n    }\n\n    return '\\n\\n';\n  }\n}","module.exports = phrasing;\n\nfunction phrasing(parent, context, safeOptions) {\n  var children = parent.children || [];\n  var results = [];\n  var index = -1;\n  var before = safeOptions.before;\n  var after;\n  var handle;\n  var child;\n\n  while (++index < children.length) {\n    child = children[index];\n\n    if (index + 1 < children.length) {\n      handle = context.handle.handlers[children[index + 1].type];\n      if (handle && handle.peek) handle = handle.peek;\n      after = handle ? handle(children[index + 1], parent, context, {\n        before: '',\n        after: ''\n      }).charAt(0) : '';\n    } else {\n      after = safeOptions.after;\n    } // In some cases, html (text) can be found in phrasing right after an eol.\n    // When we’d serialize that, in most cases that would be seen as html\n    // (flow).\n    // As we can’t escape or so to prevent it from happening, we take a somewhat\n    // reasonable approach: replace that eol with a space.\n    // See: <https://github.com/syntax-tree/mdast-util-to-markdown/issues/15>\n\n\n    if (results.length > 0 && (before === '\\r' || before === '\\n') && child.type === 'html') {\n      results[results.length - 1] = results[results.length - 1].replace(/(\\r?\\n|\\r)$/, ' ');\n      before = ' ';\n    }\n\n    results.push(context.handle(child, parent, context, {\n      before: before,\n      after: after\n    }));\n    before = results[results.length - 1].slice(-1);\n  }\n\n  return results.join('');\n}","module.exports = indentLines;\nvar eol = /\\r?\\n|\\r/g;\n\nfunction indentLines(value, map) {\n  var result = [];\n  var start = 0;\n  var line = 0;\n  var match;\n\n  while (match = eol.exec(value)) {\n    one(value.slice(start, match.index));\n    result.push(match[0]);\n    start = match.index + match[0].length;\n    line++;\n  }\n\n  one(value.slice(start));\n  return result.join('');\n\n  function one(value) {\n    result.push(map(value, line, !value));\n  }\n}","module.exports = patternCompile;\n\nfunction patternCompile(pattern) {\n  var before;\n  var after;\n\n  if (!pattern._compiled) {\n    before = pattern.before ? '(?:' + pattern.before + ')' : '';\n    after = pattern.after ? '(?:' + pattern.after + ')' : '';\n\n    if (pattern.atBreak) {\n      before = '[\\\\r\\\\n][\\\\t ]*' + before;\n    }\n\n    pattern._compiled = new RegExp((before ? '(' + before + ')' : '') + (/[|\\\\{}()[\\]^$+*?.-]/.test(pattern.character) ? '\\\\' : '') + pattern.character + (after || ''), 'g');\n  }\n\n  return pattern._compiled;\n}","'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}","module.exports = require('./syntax');","var asciiAlpha = require('micromark/dist/character/ascii-alpha');\n\nvar asciiAlphanumeric = require('micromark/dist/character/ascii-alphanumeric');\n\nvar asciiControl = require('micromark/dist/character/ascii-control');\n\nvar markdownLineEnding = require('micromark/dist/character/markdown-line-ending');\n\nvar unicodePunctuation = require('micromark/dist/character/unicode-punctuation');\n\nvar unicodeWhitespace = require('micromark/dist/character/unicode-whitespace');\n\nvar www = {\n  tokenize: tokenizeWww,\n  partial: true\n};\nvar domain = {\n  tokenize: tokenizeDomain,\n  partial: true\n};\nvar path = {\n  tokenize: tokenizePath,\n  partial: true\n};\nvar punctuation = {\n  tokenize: tokenizePunctuation,\n  partial: true\n};\nvar namedCharacterReference = {\n  tokenize: tokenizeNamedCharacterReference,\n  partial: true\n};\nvar wwwAutolink = {\n  tokenize: tokenizeWwwAutolink,\n  previous: previousWww\n};\nvar httpAutolink = {\n  tokenize: tokenizeHttpAutolink,\n  previous: previousHttp\n};\nvar emailAutolink = {\n  tokenize: tokenizeEmailAutolink,\n  previous: previousEmail\n};\nvar text = {}; // Export hooked constructs.\n\nexports.text = text; // `0`\n\nvar code = 48; // While the code is smaller than `{`.\n\nwhile (code < 123) {\n  text[code] = emailAutolink;\n  code++; // Jump from `:` -> `A`\n\n  if (code === 58) code = 65; // Jump from `[` -> `a`\n  else if (code === 91) code = 97;\n} // `+`\n\n\ntext[43] = emailAutolink; // `-`\n\ntext[45] = emailAutolink; // `.`\n\ntext[46] = emailAutolink; // `_`\n\ntext[95] = emailAutolink; // `h`.\n\ntext[72] = [emailAutolink, httpAutolink];\ntext[104] = [emailAutolink, httpAutolink]; // `w`.\n\ntext[87] = [emailAutolink, wwwAutolink];\ntext[119] = [emailAutolink, wwwAutolink];\n\nfunction tokenizeEmailAutolink(effects, ok, nok) {\n  var self = this;\n  var hasDot;\n  return start;\n\n  function start(code) {\n    /* istanbul ignore next - hooks. */\n    if (!gfmAtext(code) || !previousEmail(self.previous) || previous(self.events)) {\n      return nok(code);\n    }\n\n    effects.enter('literalAutolink');\n    effects.enter('literalAutolinkEmail');\n    return atext(code);\n  }\n\n  function atext(code) {\n    if (gfmAtext(code)) {\n      effects.consume(code);\n      return atext;\n    } // `@`\n\n\n    if (code === 64) {\n      effects.consume(code);\n      return label;\n    }\n\n    return nok(code);\n  }\n\n  function label(code) {\n    // `.`\n    if (code === 46) {\n      return effects.check(punctuation, done, dotContinuation)(code);\n    }\n\n    if ( // `-`\n    code === 45 || // `_`\n    code === 95) {\n      return effects.check(punctuation, nok, dashOrUnderscoreContinuation)(code);\n    }\n\n    if (asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return label;\n    }\n\n    return done(code);\n  }\n\n  function dotContinuation(code) {\n    effects.consume(code);\n    hasDot = true;\n    return label;\n  }\n\n  function dashOrUnderscoreContinuation(code) {\n    effects.consume(code);\n    return afterDashOrUnderscore;\n  }\n\n  function afterDashOrUnderscore(code) {\n    // `.`\n    if (code === 46) {\n      return effects.check(punctuation, nok, dotContinuation)(code);\n    }\n\n    return label(code);\n  }\n\n  function done(code) {\n    if (hasDot) {\n      effects.exit('literalAutolinkEmail');\n      effects.exit('literalAutolink');\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nfunction tokenizeWwwAutolink(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    /* istanbul ignore next - hooks. */\n    if (code !== 87 && code - 32 !== 87 || !previousWww(self.previous) || previous(self.events)) {\n      return nok(code);\n    }\n\n    effects.enter('literalAutolink');\n    effects.enter('literalAutolinkWww'); // For `www.` we check instead of attempt, because when it matches, GH\n    // treats it as part of a domain (yes, it says a valid domain must come\n    // after `www.`, but that’s not how it’s implemented by them).\n\n    return effects.check(www, effects.attempt(domain, effects.attempt(path, done), nok), nok)(code);\n  }\n\n  function done(code) {\n    effects.exit('literalAutolinkWww');\n    effects.exit('literalAutolink');\n    return ok(code);\n  }\n}\n\nfunction tokenizeHttpAutolink(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    /* istanbul ignore next - hooks. */\n    if (code !== 72 && code - 32 !== 72 || !previousHttp(self.previous) || previous(self.events)) {\n      return nok(code);\n    }\n\n    effects.enter('literalAutolink');\n    effects.enter('literalAutolinkHttp');\n    effects.consume(code);\n    return t1;\n  }\n\n  function t1(code) {\n    // `t`\n    if (code === 84 || code - 32 === 84) {\n      effects.consume(code);\n      return t2;\n    }\n\n    return nok(code);\n  }\n\n  function t2(code) {\n    // `t`\n    if (code === 84 || code - 32 === 84) {\n      effects.consume(code);\n      return p;\n    }\n\n    return nok(code);\n  }\n\n  function p(code) {\n    // `p`\n    if (code === 80 || code - 32 === 80) {\n      effects.consume(code);\n      return s;\n    }\n\n    return nok(code);\n  }\n\n  function s(code) {\n    // `s`\n    if (code === 83 || code - 32 === 83) {\n      effects.consume(code);\n      return colon;\n    }\n\n    return colon(code);\n  }\n\n  function colon(code) {\n    // `:`\n    if (code === 58) {\n      effects.consume(code);\n      return slash1;\n    }\n\n    return nok(code);\n  }\n\n  function slash1(code) {\n    // `/`\n    if (code === 47) {\n      effects.consume(code);\n      return slash2;\n    }\n\n    return nok(code);\n  }\n\n  function slash2(code) {\n    // `/`\n    if (code === 47) {\n      effects.consume(code);\n      return after;\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    return asciiControl(code) || unicodeWhitespace(code) || unicodePunctuation(code) ? nok(code) : effects.attempt(domain, effects.attempt(path, done), nok)(code);\n  }\n\n  function done(code) {\n    effects.exit('literalAutolinkHttp');\n    effects.exit('literalAutolink');\n    return ok(code);\n  }\n}\n\nfunction tokenizeWww(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    // Assume a `w`.\n    effects.consume(code);\n    return w2;\n  }\n\n  function w2(code) {\n    // `w`\n    if (code === 87 || code - 32 === 87) {\n      effects.consume(code);\n      return w3;\n    }\n\n    return nok(code);\n  }\n\n  function w3(code) {\n    // `w`\n    if (code === 87 || code - 32 === 87) {\n      effects.consume(code);\n      return dot;\n    }\n\n    return nok(code);\n  }\n\n  function dot(code) {\n    // `.`\n    if (code === 46) {\n      effects.consume(code);\n      return after;\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? nok(code) : ok(code);\n  }\n}\n\nfunction tokenizeDomain(effects, ok, nok) {\n  var hasUnderscoreInLastSegment;\n  var hasUnderscoreInLastLastSegment;\n  return domain;\n\n  function domain(code) {\n    // `&`\n    if (code === 38) {\n      return effects.check(namedCharacterReference, done, punctuationContinuation)(code);\n    }\n\n    if (code === 46\n    /* `.` */\n    || code === 95\n    /* `_` */\n    ) {\n        return effects.check(punctuation, done, punctuationContinuation)(code);\n      } // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can\n    // occur, which sounds like ASCII only, but they also support `www.點看.com`,\n    // so that’s Unicode.\n    // Instead of some new production for Unicode alphanumerics, markdown\n    // already has that for Unicode punctuation and whitespace, so use those.\n\n\n    if (asciiControl(code) || unicodeWhitespace(code) || code !== 45\n    /* `-` */\n    && unicodePunctuation(code)) {\n      return done(code);\n    }\n\n    effects.consume(code);\n    return domain;\n  }\n\n  function punctuationContinuation(code) {\n    // `.`\n    if (code === 46) {\n      hasUnderscoreInLastLastSegment = hasUnderscoreInLastSegment;\n      hasUnderscoreInLastSegment = undefined;\n      effects.consume(code);\n      return domain;\n    } // `_`\n\n\n    if (code === 95) hasUnderscoreInLastSegment = true;\n    effects.consume(code);\n    return domain;\n  }\n\n  function done(code) {\n    if (!hasUnderscoreInLastLastSegment && !hasUnderscoreInLastSegment) {\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nfunction tokenizePath(effects, ok) {\n  var balance = 0;\n  return inPath;\n\n  function inPath(code) {\n    // `&`\n    if (code === 38) {\n      return effects.check(namedCharacterReference, ok, continuedPunctuation)(code);\n    } // `(`\n\n\n    if (code === 40) {\n      balance++;\n    } // `)`\n\n\n    if (code === 41) {\n      return effects.check(punctuation, parenAtPathEnd, continuedPunctuation)(code);\n    }\n\n    if (pathEnd(code)) {\n      return ok(code);\n    }\n\n    if (trailingPunctuation(code)) {\n      return effects.check(punctuation, ok, continuedPunctuation)(code);\n    }\n\n    effects.consume(code);\n    return inPath;\n  }\n\n  function continuedPunctuation(code) {\n    effects.consume(code);\n    return inPath;\n  }\n\n  function parenAtPathEnd(code) {\n    balance--;\n    return balance < 0 ? ok(code) : continuedPunctuation(code);\n  }\n}\n\nfunction tokenizeNamedCharacterReference(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    // Assume an ampersand.\n    effects.consume(code);\n    return inside;\n  }\n\n  function inside(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return inside;\n    } // `;`\n\n\n    if (code === 59) {\n      effects.consume(code);\n      return after;\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    // If the named character reference is followed by the end of the path, it’s\n    // not continued punctuation.\n    return pathEnd(code) ? ok(code) : nok(code);\n  }\n}\n\nfunction tokenizePunctuation(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    // Always a valid trailing punctuation marker.\n    effects.consume(code);\n    return after;\n  }\n\n  function after(code) {\n    // Check the next.\n    if (trailingPunctuation(code)) {\n      effects.consume(code);\n      return after;\n    } // If the punctuation marker is followed by the end of the path, it’s not\n    // continued punctuation.\n\n\n    return pathEnd(code) ? ok(code) : nok(code);\n  }\n}\n\nfunction trailingPunctuation(code) {\n  return (// `!`\n    code === 33 || // `\"`\n    code === 34 || // `'`\n    code === 39 || // `)`\n    code === 41 || // `*`\n    code === 42 || // `,`\n    code === 44 || // `.`\n    code === 46 || // `:`\n    code === 58 || // `;`\n    code === 59 || // `<`\n    code === 60 || // `?`\n    code === 63 || // `_`.\n    code === 95 || // `~`\n    code === 126\n  );\n}\n\nfunction pathEnd(code) {\n  return (// EOF.\n    code === null || // CR, LF, CRLF, HT, VS.\n    code < 0 || // Space.\n    code === 32 || // `<`\n    code === 60\n  );\n}\n\nfunction gfmAtext(code) {\n  return code === 43\n  /* `+` */\n  || code === 45\n  /* `-` */\n  || code === 46\n  /* `.` */\n  || code === 95\n  /* `_` */\n  || asciiAlphanumeric(code);\n}\n\nfunction previousWww(code) {\n  return code === null || code < 0 || code === 32\n  /* ` ` */\n  || code === 40\n  /* `(` */\n  || code === 42\n  /* `*` */\n  || code === 95\n  /* `_` */\n  || code === 126\n  /* `~` */\n  ;\n}\n\nfunction previousHttp(code) {\n  return code === null || !asciiAlpha(code);\n}\n\nfunction previousEmail(code) {\n  return code !== 47\n  /* `/` */\n  && previousHttp(code);\n}\n\nfunction previous(events) {\n  var index = events.length;\n\n  while (index--) {\n    if ((events[index][1].type === 'labelLink' || events[index][1].type === 'labelImage') && !events[index][1]._balanced) {\n      return true;\n    }\n  }\n}","module.exports = create;\n\nvar classifyCharacter = require('micromark/dist/util/classify-character');\n\nvar chunkedSplice = require('micromark/dist/util/chunked-splice');\n\nvar resolveAll = require('micromark/dist/util/resolve-all');\n\nvar shallow = require('micromark/dist/util/shallow');\n\nfunction create(options) {\n  var settings = options || {};\n  var single = settings.singleTilde;\n  var tokenizer = {\n    tokenize: tokenizeStrikethrough,\n    resolveAll: resolveAllStrikethrough\n  };\n\n  if (single === null || single === undefined) {\n    single = true;\n  }\n\n  return {\n    text: {\n      126: tokenizer\n    },\n    insideSpan: {\n      null: tokenizer\n    }\n  }; // Take events and resolve strikethrough.\n\n  function resolveAllStrikethrough(events, context) {\n    var index = -1;\n    var strikethrough;\n    var text;\n    var open;\n    var nextEvents; // Walk through all events.\n\n    while (++index < events.length) {\n      // Find a token that can close.\n      if (events[index][0] === 'enter' && events[index][1].type === 'strikethroughSequenceTemporary' && 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 === 'strikethroughSequenceTemporary' && events[open][1]._open && // If the sizes are the same:\n          events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) {\n            events[index][1].type = 'strikethroughSequence';\n            events[open][1].type = 'strikethroughSequence';\n            strikethrough = {\n              type: 'strikethrough',\n              start: shallow(events[open][1].start),\n              end: shallow(events[index][1].end)\n            };\n            text = {\n              type: 'strikethroughText',\n              start: shallow(events[open][1].end),\n              end: shallow(events[index][1].start)\n            }; // Opening.\n\n            nextEvents = [['enter', strikethrough, context], ['enter', events[open][1], context], ['exit', events[open][1], context], ['enter', text, context]]; // Between.\n\n            chunkedSplice(nextEvents, nextEvents.length, 0, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context)); // Closing.\n\n            chunkedSplice(nextEvents, nextEvents.length, 0, [['exit', text, context], ['enter', events[index][1], context], ['exit', events[index][1], context], ['exit', strikethrough, context]]);\n            chunkedSplice(events, open - 1, index - open + 3, nextEvents);\n            index = open + nextEvents.length - 2;\n            break;\n          }\n        }\n      }\n    }\n\n    return removeRemainingSequences(events);\n  }\n\n  function removeRemainingSequences(events) {\n    var index = -1;\n    var length = events.length;\n\n    while (++index < length) {\n      if (events[index][1].type === 'strikethroughSequenceTemporary') {\n        events[index][1].type = 'data';\n      }\n    }\n\n    return events;\n  }\n\n  function tokenizeStrikethrough(effects, ok, nok) {\n    var previous = this.previous;\n    var events = this.events;\n    var size = 0;\n    return start;\n\n    function start(code) {\n      if (code !== 126 || previous === 126 && events[events.length - 1][1].type !== 'characterEscape') {\n        return nok(code);\n      }\n\n      effects.enter('strikethroughSequenceTemporary');\n      return more(code);\n    }\n\n    function more(code) {\n      var before = classifyCharacter(previous);\n      var token;\n      var after;\n\n      if (code === 126) {\n        // If this is the third marker, exit.\n        if (size > 1) return nok(code);\n        effects.consume(code);\n        size++;\n        return more;\n      }\n\n      if (size < 2 && !single) return nok(code);\n      token = effects.exit('strikethroughSequenceTemporary');\n      after = classifyCharacter(code);\n      token._open = !after || after === 2 && before;\n      token._close = !before || before === 2 && after;\n      return ok(code);\n    }\n  }\n}","module.exports = require('./syntax');","exports.flow = {\n  null: {\n    tokenize: tokenizeTable,\n    resolve: resolveTable,\n    interruptible: true\n  }\n};\n\nvar createSpace = require('micromark/dist/tokenize/factory-space');\n\nvar setextUnderlineMini = {\n  tokenize: tokenizeSetextUnderlineMini,\n  partial: true\n};\nvar nextPrefixedOrBlank = {\n  tokenize: tokenizeNextPrefixedOrBlank,\n  partial: true\n};\n\nfunction resolveTable(events, context) {\n  var length = events.length;\n  var index = -1;\n  var token;\n  var inHead;\n  var inDelimiterRow;\n  var inRow;\n  var cell;\n  var content;\n  var text;\n  var contentStart;\n  var contentEnd;\n  var cellStart;\n\n  while (++index < length) {\n    token = events[index][1];\n\n    if (inRow) {\n      if (token.type === 'temporaryTableCellContent') {\n        contentStart = contentStart || index;\n        contentEnd = index;\n      }\n\n      if ( // Combine separate content parts into one.\n      (token.type === 'tableCellDivider' || token.type === 'tableRow') && contentEnd) {\n        content = {\n          type: 'tableContent',\n          start: events[contentStart][1].start,\n          end: events[contentEnd][1].end\n        };\n        text = {\n          type: 'chunkText',\n          start: content.start,\n          end: content.end,\n          contentType: 'text'\n        };\n        events.splice(contentStart, contentEnd - contentStart + 1, ['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]);\n        index -= contentEnd - contentStart - 3;\n        length = events.length;\n        contentStart = undefined;\n        contentEnd = undefined;\n      }\n    }\n\n    if (events[index][0] === 'exit' && cellStart && cellStart + 1 < index && (token.type === 'tableCellDivider' || token.type === 'tableRow' && (cellStart + 3 < index || events[cellStart][1].type !== 'whitespace'))) {\n      cell = {\n        type: inDelimiterRow ? 'tableDelimiter' : inHead ? 'tableHeader' : 'tableData',\n        start: events[cellStart][1].start,\n        end: events[index][1].end\n      };\n      events.splice(index + (token.type === 'tableCellDivider' ? 1 : 0), 0, ['exit', cell, context]);\n      events.splice(cellStart, 0, ['enter', cell, context]);\n      index += 2;\n      length = events.length;\n      cellStart = index + 1;\n    }\n\n    if (token.type === 'tableRow') {\n      inRow = events[index][0] === 'enter';\n\n      if (inRow) {\n        cellStart = index + 1;\n      }\n    }\n\n    if (token.type === 'tableDelimiterRow') {\n      inDelimiterRow = events[index][0] === 'enter';\n\n      if (inDelimiterRow) {\n        cellStart = index + 1;\n      }\n    }\n\n    if (token.type === 'tableHead') {\n      inHead = events[index][0] === 'enter';\n    }\n  }\n\n  return events;\n}\n\nfunction tokenizeTable(effects, ok, nok) {\n  var align = [];\n  var tableHeaderCount = 0;\n  var seenDelimiter;\n  var hasDash;\n  return start;\n\n  function start(code) {\n    /* istanbul ignore if - used to be passed in beta micromark versions. */\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return nok(code);\n    }\n\n    effects.enter('table')._align = align;\n    effects.enter('tableHead');\n    effects.enter('tableRow'); // If we start with a pipe, we open a cell marker.\n\n    if (code === 124) {\n      return cellDividerHead(code);\n    }\n\n    tableHeaderCount++;\n    effects.enter('temporaryTableCellContent'); // Can’t be space or eols at the start of a construct, so we’re in a cell.\n\n    return inCellContentHead(code);\n  }\n\n  function cellDividerHead(code) {\n    // Always a pipe.\n    effects.enter('tableCellDivider');\n    effects.consume(code);\n    effects.exit('tableCellDivider');\n    seenDelimiter = true;\n    return cellBreakHead;\n  }\n\n  function cellBreakHead(code) {\n    // EOF, CR, LF, CRLF.\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return atRowEndHead(code);\n    } // HT, VS, SP.\n\n\n    if (code === -2 || code === -1 || code === 32) {\n      effects.enter('whitespace');\n      effects.consume(code);\n      return inWhitespaceHead;\n    }\n\n    if (seenDelimiter) {\n      seenDelimiter = undefined;\n      tableHeaderCount++;\n    } // `|`\n\n\n    if (code === 124) {\n      return cellDividerHead(code);\n    } // Anything else is cell content.\n\n\n    effects.enter('temporaryTableCellContent');\n    return inCellContentHead(code);\n  }\n\n  function inWhitespaceHead(code) {\n    // HT, VS, SP.\n    if (code === -2 || code === -1 || code === 32) {\n      effects.consume(code);\n      return inWhitespaceHead;\n    }\n\n    effects.exit('whitespace');\n    return cellBreakHead(code);\n  }\n\n  function inCellContentHead(code) {\n    // EOF, whitespace, pipe\n    if (code === null || code < 0 || code === 32 || code === 124) {\n      effects.exit('temporaryTableCellContent');\n      return cellBreakHead(code);\n    }\n\n    effects.consume(code); // `\\`\n\n    return code === 92 ? inCellContentEscapeHead : inCellContentHead;\n  }\n\n  function inCellContentEscapeHead(code) {\n    // `\\` or `|`\n    if (code === 92 || code === 124) {\n      effects.consume(code);\n      return inCellContentHead;\n    } // Anything else.\n\n\n    return inCellContentHead(code);\n  }\n\n  function atRowEndHead(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    effects.exit('tableRow');\n    effects.exit('tableHead'); // Always a line ending.\n\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding'); // If a setext heading, exit.\n\n    return effects.check(setextUnderlineMini, nok, // Support an indent before the delimiter row.\n    createSpace(effects, rowStartDelimiter, 'linePrefix', 4));\n  }\n\n  function rowStartDelimiter(code) {\n    // If there’s another space, or we’re at the EOL/EOF, exit.\n    if (code === null || code < 0 || code === 32) {\n      return nok(code);\n    }\n\n    effects.enter('tableDelimiterRow');\n    return atDelimiterRowBreak(code);\n  }\n\n  function atDelimiterRowBreak(code) {\n    // EOF, CR, LF, CRLF.\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return rowEndDelimiter(code);\n    } // HT, VS, SP.\n\n\n    if (code === -2 || code === -1 || code === 32) {\n      effects.enter('whitespace');\n      effects.consume(code);\n      return inWhitespaceDelimiter;\n    } // `-`\n\n\n    if (code === 45) {\n      effects.enter('tableDelimiterFiller');\n      effects.consume(code);\n      hasDash = true;\n      align.push(null);\n      return inFillerDelimiter;\n    } // `:`\n\n\n    if (code === 58) {\n      effects.enter('tableDelimiterAlignment');\n      effects.consume(code);\n      effects.exit('tableDelimiterAlignment');\n      align.push('left');\n      return afterLeftAlignment;\n    } // If we start with a pipe, we open a cell marker.\n\n\n    if (code === 124) {\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      return atDelimiterRowBreak;\n    }\n\n    return nok(code);\n  }\n\n  function inWhitespaceDelimiter(code) {\n    // HT, VS, SP.\n    if (code === -2 || code === -1 || code === 32) {\n      effects.consume(code);\n      return inWhitespaceDelimiter;\n    }\n\n    effects.exit('whitespace');\n    return atDelimiterRowBreak(code);\n  }\n\n  function inFillerDelimiter(code) {\n    // `-`\n    if (code === 45) {\n      effects.consume(code);\n      return inFillerDelimiter;\n    }\n\n    effects.exit('tableDelimiterFiller'); // `:`\n\n    if (code === 58) {\n      effects.enter('tableDelimiterAlignment');\n      effects.consume(code);\n      effects.exit('tableDelimiterAlignment');\n      align[align.length - 1] = align[align.length - 1] === 'left' ? 'center' : 'right';\n      return afterRightAlignment;\n    }\n\n    return atDelimiterRowBreak(code);\n  }\n\n  function afterLeftAlignment(code) {\n    // `-`\n    if (code === 45) {\n      effects.enter('tableDelimiterFiller');\n      effects.consume(code);\n      hasDash = true;\n      return inFillerDelimiter;\n    } // Anything else is not ok.\n\n\n    return nok(code);\n  }\n\n  function afterRightAlignment(code) {\n    // EOF, CR, LF, CRLF.\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return rowEndDelimiter(code);\n    } // HT, VS, SP.\n\n\n    if (code === -2 || code === -1 || code === 32) {\n      effects.enter('whitespace');\n      effects.consume(code);\n      return inWhitespaceDelimiter;\n    } // `|`\n\n\n    if (code === 124) {\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      return atDelimiterRowBreak;\n    }\n\n    return nok(code);\n  }\n\n  function rowEndDelimiter(code) {\n    effects.exit('tableDelimiterRow'); // Exit if there was no dash at all, or if the header cell count is not the\n    // delimiter cell count.\n\n    if (!hasDash || tableHeaderCount !== align.length) {\n      return nok(code);\n    }\n\n    if (code === null) {\n      return tableClose(code);\n    }\n\n    return effects.check(nextPrefixedOrBlank, tableClose, tableContinue)(code);\n  }\n\n  function tableClose(code) {\n    effects.exit('table');\n    return ok(code);\n  }\n\n  function tableContinue(code) {\n    // Always a line ending.\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding'); // We checked that it’s not a prefixed or blank line, so we’re certain a\n    // body is coming, though it may be indented.\n\n    return createSpace(effects, bodyStart, 'linePrefix', 4);\n  }\n\n  function bodyStart(code) {\n    effects.enter('tableBody');\n    return rowStartBody(code);\n  }\n\n  function rowStartBody(code) {\n    effects.enter('tableRow'); // If we start with a pipe, we open a cell marker.\n\n    if (code === 124) {\n      return cellDividerBody(code);\n    }\n\n    effects.enter('temporaryTableCellContent'); // Can’t be space or eols at the start of a construct, so we’re in a cell.\n\n    return inCellContentBody(code);\n  }\n\n  function cellDividerBody(code) {\n    // Always a pipe.\n    effects.enter('tableCellDivider');\n    effects.consume(code);\n    effects.exit('tableCellDivider');\n    return cellBreakBody;\n  }\n\n  function cellBreakBody(code) {\n    // EOF, CR, LF, CRLF.\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return atRowEndBody(code);\n    } // HT, VS, SP.\n\n\n    if (code === -2 || code === -1 || code === 32) {\n      effects.enter('whitespace');\n      effects.consume(code);\n      return inWhitespaceBody;\n    } // `|`\n\n\n    if (code === 124) {\n      return cellDividerBody(code);\n    } // Anything else is cell content.\n\n\n    effects.enter('temporaryTableCellContent');\n    return inCellContentBody(code);\n  }\n\n  function inWhitespaceBody(code) {\n    // HT, VS, SP.\n    if (code === -2 || code === -1 || code === 32) {\n      effects.consume(code);\n      return inWhitespaceBody;\n    }\n\n    effects.exit('whitespace');\n    return cellBreakBody(code);\n  }\n\n  function inCellContentBody(code) {\n    // EOF, whitespace, pipe\n    if (code === null || code < 0 || code === 32 || code === 124) {\n      effects.exit('temporaryTableCellContent');\n      return cellBreakBody(code);\n    }\n\n    effects.consume(code); // `\\`\n\n    return code === 92 ? inCellContentEscapeBody : inCellContentBody;\n  }\n\n  function inCellContentEscapeBody(code) {\n    // `\\` or `|`\n    if (code === 92 || code === 124) {\n      effects.consume(code);\n      return inCellContentBody;\n    } // Anything else.\n\n\n    return inCellContentBody(code);\n  }\n\n  function atRowEndBody(code) {\n    effects.exit('tableRow');\n\n    if (code === null) {\n      return tableBodyClose(code);\n    }\n\n    return effects.check(nextPrefixedOrBlank, tableBodyClose, tableBodyContinue)(code);\n  }\n\n  function tableBodyClose(code) {\n    effects.exit('tableBody');\n    return tableClose(code);\n  }\n\n  function tableBodyContinue(code) {\n    // Always a line ending.\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding'); // Support an optional prefix, then start a body row.\n\n    return createSpace(effects, rowStartBody, 'linePrefix', 4);\n  }\n} // Based on micromark, but that won’t work as we’re in a table, and that expects\n// content.\n// <https://github.com/micromark/micromark/blob/main/lib/tokenize/setext-underline.js>\n\n\nfunction tokenizeSetextUnderlineMini(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    // `-`\n    if (code !== 45) {\n      return nok(code);\n    }\n\n    effects.enter('setextUnderline');\n    return sequence(code);\n  }\n\n  function sequence(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return sequence;\n    }\n\n    return whitespace(code);\n  }\n\n  function whitespace(code) {\n    if (code === -2 || code === -1 || code === 32) {\n      effects.consume(code);\n      return whitespace;\n    }\n\n    if (code === null || code === -5 || code === -4 || code === -3) {\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nfunction tokenizeNextPrefixedOrBlank(effects, ok, nok) {\n  var size = 0;\n  return start;\n\n  function start(code) {\n    // This is a check, so we don’t care about tokens, but we open a bogus one\n    // so we’re valid.\n    effects.enter('check'); // EOL.\n\n    effects.consume(code);\n    return whitespace;\n  }\n\n  function whitespace(code) {\n    // VS or SP.\n    if (code === -1 || code === 32) {\n      effects.consume(code);\n      size++;\n      return size === 4 ? ok : whitespace;\n    } // EOF or whitespace\n\n\n    if (code === null || code < 0) {\n      return ok(code);\n    } // Anything else.\n\n\n    return nok(code);\n  }\n}","module.exports = require('./syntax');","var markdownLineEndingOrSpace = require('micromark/dist/character/markdown-line-ending-or-space');\n\nvar spaceFactory = require('micromark/dist/tokenize/factory-space');\n\nvar prefixSize = require('micromark/dist/util/prefix-size');\n\nvar tasklistCheck = {\n  tokenize: tokenizeTasklistCheck\n};\nexports.text = {\n  91: tasklistCheck\n};\n\nfunction tokenizeTasklistCheck(effects, ok, nok) {\n  var self = this;\n  return open;\n\n  function open(code) {\n    if ( // Exit if not `[`.\n    code !== 91 || // Exit if there’s stuff before.\n    self.previous !== null || // Exit if not in the first content that is the first child of a list\n    // item.\n    !self._gfmTasklistFirstContentOfListItem) {\n      return nok(code);\n    }\n\n    effects.enter('taskListCheck');\n    effects.enter('taskListCheckMarker');\n    effects.consume(code);\n    effects.exit('taskListCheckMarker');\n    return inside;\n  }\n\n  function inside(code) {\n    // Tab or space.\n    if (code === -2 || code === 32) {\n      effects.enter('taskListCheckValueUnchecked');\n      effects.consume(code);\n      effects.exit('taskListCheckValueUnchecked');\n      return close;\n    } // Upper- and lower `x`.\n\n\n    if (code === 88 || code === 120) {\n      effects.enter('taskListCheckValueChecked');\n      effects.consume(code);\n      effects.exit('taskListCheckValueChecked');\n      return close;\n    }\n\n    return nok(code);\n  }\n\n  function close(code) {\n    // `]`\n    if (code === 93) {\n      effects.enter('taskListCheckMarker');\n      effects.consume(code);\n      effects.exit('taskListCheckMarker');\n      effects.exit('taskListCheck');\n      return effects.check({\n        tokenize: spaceThenNonSpace\n      }, ok, nok);\n    }\n\n    return nok(code);\n  }\n}\n\nfunction spaceThenNonSpace(effects, ok, nok) {\n  var self = this;\n  return spaceFactory(effects, after, 'whitespace');\n\n  function after(code) {\n    return prefixSize(self.events, 'whitespace') && code !== null && !markdownLineEndingOrSpace(code) ? ok(code) : nok(code);\n  }\n}","module.exports = require('./syntax');","var combine = require('micromark/dist/util/combine-extensions');\n\nvar autolink = require('micromark-extension-gfm-autolink-literal');\n\nvar strikethrough = require('micromark-extension-gfm-strikethrough');\n\nvar table = require('micromark-extension-gfm-table');\n\nvar tasklist = require('micromark-extension-gfm-task-list-item');\n\nmodule.exports = create;\n\nfunction create(options) {\n  return combine([autolink, strikethrough(options), table, tasklist]);\n}","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiAlpha = regexCheck(/[A-Za-z]/);\nmodule.exports = asciiAlpha;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\nmodule.exports = asciiAlphanumeric;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\nmodule.exports = asciiAtext;","'use strict'; // Note: EOF is seen as ASCII control here, because `null < 32 == true`.\n\nfunction asciiControl(code) {\n  return (// Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code < 32 || code === 127\n  );\n}\n\nmodule.exports = asciiControl;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiDigit = regexCheck(/\\d/);\nmodule.exports = asciiDigit;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\nmodule.exports = asciiHexDigit;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\nmodule.exports = asciiPunctuation;","'use strict';\n\nfunction markdownLineEndingOrSpace(code) {\n  return code < 0 || code === 32;\n}\n\nmodule.exports = markdownLineEndingOrSpace;","'use strict';\n\nfunction markdownLineEnding(code) {\n  return code < -2;\n}\n\nmodule.exports = markdownLineEnding;","'use strict';\n\nfunction markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\nmodule.exports = markdownSpace;","'use strict';\n\nvar unicodePunctuationRegex = require('../constant/unicode-punctuation-regex.js');\n\nvar regexCheck = require('../util/regex-check.js'); // In fact adds to the bundle size.\n\n\nvar unicodePunctuation = regexCheck(unicodePunctuationRegex);\nmodule.exports = unicodePunctuation;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar unicodeWhitespace = regexCheck(/\\s/);\nmodule.exports = unicodeWhitespace;","'use strict';\n\nvar assign = Object.assign;\nmodule.exports = assign;","'use strict';\n\nvar fromCharCode = String.fromCharCode;\nmodule.exports = fromCharCode;","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = own;","'use strict'; // This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\n\nvar basics = ['address', 'article', 'aside', 'base', 'basefont', 'blockquote', 'body', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hr', 'html', 'iframe', 'legend', 'li', 'link', 'main', 'menu', 'menuitem', 'nav', 'noframes', 'ol', 'optgroup', 'option', 'p', 'param', 'section', 'source', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul'];\nmodule.exports = basics;","'use strict'; // This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.\n\nvar raws = ['pre', 'script', 'style', 'textarea'];\nmodule.exports = raws;","'use strict';\n\nvar splice = [].splice;\nmodule.exports = splice;","'use strict'; // This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\n\nvar unicodePunctuation = /[!-\\/:-@\\[-`\\{-~\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/;\nmodule.exports = unicodePunctuation;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar text$1 = require('./initialize/text.js');\n\nvar attention = require('./tokenize/attention.js');\n\nvar autolink = require('./tokenize/autolink.js');\n\nvar blockQuote = require('./tokenize/block-quote.js');\n\nvar characterEscape = require('./tokenize/character-escape.js');\n\nvar characterReference = require('./tokenize/character-reference.js');\n\nvar codeFenced = require('./tokenize/code-fenced.js');\n\nvar codeIndented = require('./tokenize/code-indented.js');\n\nvar codeText = require('./tokenize/code-text.js');\n\nvar definition = require('./tokenize/definition.js');\n\nvar hardBreakEscape = require('./tokenize/hard-break-escape.js');\n\nvar headingAtx = require('./tokenize/heading-atx.js');\n\nvar htmlFlow = require('./tokenize/html-flow.js');\n\nvar htmlText = require('./tokenize/html-text.js');\n\nvar labelEnd = require('./tokenize/label-end.js');\n\nvar labelStartImage = require('./tokenize/label-start-image.js');\n\nvar labelStartLink = require('./tokenize/label-start-link.js');\n\nvar lineEnding = require('./tokenize/line-ending.js');\n\nvar list = require('./tokenize/list.js');\n\nvar setextUnderline = require('./tokenize/setext-underline.js');\n\nvar thematicBreak = require('./tokenize/thematic-break.js');\n\nvar document = {\n  42: list,\n  // Asterisk\n  43: list,\n  // Plus sign\n  45: list,\n  // Dash\n  48: list,\n  // 0\n  49: list,\n  // 1\n  50: list,\n  // 2\n  51: list,\n  // 3\n  52: list,\n  // 4\n  53: list,\n  // 5\n  54: list,\n  // 6\n  55: list,\n  // 7\n  56: list,\n  // 8\n  57: list,\n  // 9\n  62: blockQuote // Greater than\n\n};\nvar contentInitial = {\n  91: definition // Left square bracket\n\n};\nvar flowInitial = {\n  '-2': codeIndented,\n  // Horizontal tab\n  '-1': codeIndented,\n  // Virtual space\n  32: codeIndented // Space\n\n};\nvar flow = {\n  35: headingAtx,\n  // Number sign\n  42: thematicBreak,\n  // Asterisk\n  45: [setextUnderline, thematicBreak],\n  // Dash\n  60: htmlFlow,\n  // Less than\n  61: setextUnderline,\n  // Equals to\n  95: thematicBreak,\n  // Underscore\n  96: codeFenced,\n  // Grave accent\n  126: codeFenced // Tilde\n\n};\nvar string = {\n  38: characterReference,\n  // Ampersand\n  92: characterEscape // Backslash\n\n};\nvar text = {\n  '-5': lineEnding,\n  // Carriage return\n  '-4': lineEnding,\n  // Line feed\n  '-3': lineEnding,\n  // Carriage return + line feed\n  33: labelStartImage,\n  // Exclamation mark\n  38: characterReference,\n  // Ampersand\n  42: attention,\n  // Asterisk\n  60: [autolink, htmlText],\n  // Less than\n  91: labelStartLink,\n  // Left square bracket\n  92: [hardBreakEscape, characterEscape],\n  // Backslash\n  93: labelEnd,\n  // Right square bracket\n  95: attention,\n  // Underscore\n  96: codeText // Grave accent\n\n};\nvar insideSpan = {\n  null: [attention, text$1.resolver]\n};\nvar disable = {\n  null: []\n};\nexports.contentInitial = contentInitial;\nexports.disable = disable;\nexports.document = document;\nexports.flow = flow;\nexports.flowInitial = flowInitial;\nexports.insideSpan = insideSpan;\nexports.string = string;\nexports.text = text;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('../tokenize/factory-space.js');\n\nvar tokenize = initializeContent;\n\nfunction initializeContent(effects) {\n  var contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\n  var previous;\n  return contentStart;\n\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, contentStart, 'linePrefix');\n  }\n\n  function paragraphInitial(code) {\n    effects.enter('paragraph');\n    return lineStart(code);\n  }\n\n  function lineStart(code) {\n    var token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous: previous\n    });\n\n    if (previous) {\n      previous.next = token;\n    }\n\n    previous = token;\n    return data(code);\n  }\n\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText');\n      effects.exit('paragraph');\n      effects.consume(code);\n      return;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      effects.exit('chunkText');\n      return lineStart;\n    } // Data.\n\n\n    effects.consume(code);\n    return data;\n  }\n}\n\nexports.tokenize = tokenize;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('../tokenize/factory-space.js');\n\nvar partialBlankLine = require('../tokenize/partial-blank-line.js');\n\nvar tokenize = initializeDocument;\nvar containerConstruct = {\n  tokenize: tokenizeContainer\n};\nvar lazyFlowConstruct = {\n  tokenize: tokenizeLazyFlow\n};\n\nfunction initializeDocument(effects) {\n  var self = this;\n  var stack = [];\n  var continued = 0;\n  var inspectConstruct = {\n    tokenize: tokenizeInspect,\n    partial: true\n  };\n  var inspectResult;\n  var childFlow;\n  var childToken;\n  return start;\n\n  function start(code) {\n    if (continued < stack.length) {\n      self.containerState = stack[continued][1];\n      return effects.attempt(stack[continued][0].continuation, documentContinue, documentContinued)(code);\n    }\n\n    return documentContinued(code);\n  }\n\n  function documentContinue(code) {\n    continued++;\n    return start(code);\n  }\n\n  function documentContinued(code) {\n    // If we’re in a concrete construct (such as when expecting another line of\n    // HTML, or we resulted in lazy content), we can immediately start flow.\n    if (inspectResult && inspectResult.flowContinue) {\n      return flowStart(code);\n    }\n\n    self.interrupt = childFlow && childFlow.currentConstruct && childFlow.currentConstruct.interruptible;\n    self.containerState = {};\n    return effects.attempt(containerConstruct, containerContinue, flowStart)(code);\n  }\n\n  function containerContinue(code) {\n    stack.push([self.currentConstruct, self.containerState]);\n    self.containerState = undefined;\n    return documentContinued(code);\n  }\n\n  function flowStart(code) {\n    if (code === null) {\n      exitContainers(0, true);\n      effects.consume(code);\n      return;\n    }\n\n    childFlow = childFlow || self.parser.flow(self.now());\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    });\n    return flowContinue(code);\n  }\n\n  function flowContinue(code) {\n    if (code === null) {\n      continueFlow(effects.exit('chunkFlow'));\n      return flowStart(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      continueFlow(effects.exit('chunkFlow'));\n      return effects.check(inspectConstruct, documentAfterPeek);\n    }\n\n    effects.consume(code);\n    return flowContinue;\n  }\n\n  function documentAfterPeek(code) {\n    exitContainers(inspectResult.continued, inspectResult && inspectResult.flowEnd);\n    continued = 0;\n    return start(code);\n  }\n\n  function continueFlow(token) {\n    if (childToken) childToken.next = token;\n    childToken = token;\n    childFlow.lazy = inspectResult && inspectResult.lazy;\n    childFlow.defineSkip(token.start);\n    childFlow.write(self.sliceStream(token));\n  }\n\n  function exitContainers(size, end) {\n    var index = stack.length; // Close the flow.\n\n    if (childFlow && end) {\n      childFlow.write([null]);\n      childToken = childFlow = undefined;\n    } // Exit open containers.\n\n\n    while (index-- > size) {\n      self.containerState = stack[index][1];\n      stack[index][0].exit.call(self, effects);\n    }\n\n    stack.length = size;\n  }\n\n  function tokenizeInspect(effects, ok) {\n    var subcontinued = 0;\n    inspectResult = {};\n    return inspectStart;\n\n    function inspectStart(code) {\n      if (subcontinued < stack.length) {\n        self.containerState = stack[subcontinued][1];\n        return effects.attempt(stack[subcontinued][0].continuation, inspectContinue, inspectLess)(code);\n      } // If we’re continued but in a concrete flow, we can’t have more\n      // containers.\n\n\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        inspectResult.flowContinue = true;\n        return inspectDone(code);\n      }\n\n      self.interrupt = childFlow.currentConstruct && childFlow.currentConstruct.interruptible;\n      self.containerState = {};\n      return effects.attempt(containerConstruct, inspectFlowEnd, inspectDone)(code);\n    }\n\n    function inspectContinue(code) {\n      subcontinued++;\n      return self.containerState._closeFlow ? inspectFlowEnd(code) : inspectStart(code);\n    }\n\n    function inspectLess(code) {\n      if (childFlow.currentConstruct && childFlow.currentConstruct.lazy) {\n        // Maybe another container?\n        self.containerState = {};\n        return effects.attempt(containerConstruct, inspectFlowEnd, // Maybe flow, or a blank line?\n        effects.attempt(lazyFlowConstruct, inspectFlowEnd, effects.check(partialBlankLine, inspectFlowEnd, inspectLazy)))(code);\n      } // Otherwise we’re interrupting.\n\n\n      return inspectFlowEnd(code);\n    }\n\n    function inspectLazy(code) {\n      // Act as if all containers are continued.\n      subcontinued = stack.length;\n      inspectResult.lazy = true;\n      inspectResult.flowContinue = true;\n      return inspectDone(code);\n    } // We’re done with flow if we have more containers, or an interruption.\n\n\n    function inspectFlowEnd(code) {\n      inspectResult.flowEnd = true;\n      return inspectDone(code);\n    }\n\n    function inspectDone(code) {\n      inspectResult.continued = subcontinued;\n      self.interrupt = self.containerState = undefined;\n      return ok(code);\n    }\n  }\n}\n\nfunction tokenizeContainer(effects, ok, nok) {\n  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n}\n\nfunction tokenizeLazyFlow(effects, ok, nok) {\n  return factorySpace(effects, effects.lazy(this.parser.constructs.flow, ok, nok), 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n}\n\nexports.tokenize = tokenize;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar content = require('../tokenize/content.js');\n\nvar factorySpace = require('../tokenize/factory-space.js');\n\nvar partialBlankLine = require('../tokenize/partial-blank-line.js');\n\nvar tokenize = initializeFlow;\n\nfunction initializeFlow(effects) {\n  var self = this;\n  var initial = effects.attempt( // Try to parse a blank line.\n  partialBlankLine, atBlankEnding, // Try to parse initial flow (essentially, only code).\n  effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), 'linePrefix')));\n  return initial;\n\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEndingBlank');\n    effects.consume(code);\n    effects.exit('lineEndingBlank');\n    self.currentConstruct = undefined;\n    return initial;\n  }\n\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    self.currentConstruct = undefined;\n    return initial;\n  }\n}\n\nexports.tokenize = tokenize;","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nvar assign = require('../constant/assign.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar text = initializeFactory('text');\nvar string = initializeFactory('string');\nvar resolver = {\n  resolveAll: createResolver()\n};\n\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined)\n  };\n\n  function initializeText(effects) {\n    var self = this;\n    var constructs = this.parser.constructs[field];\n    var text = effects.attempt(constructs, start, notText);\n    return start;\n\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n\n      effects.enter('data');\n      effects.consume(code);\n      return data;\n    }\n\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data');\n        return text(code);\n      } // Data.\n\n\n      effects.consume(code);\n      return data;\n    }\n\n    function atBreak(code) {\n      var list = constructs[code];\n      var index = -1;\n\n      if (code === null) {\n        return true;\n      }\n\n      if (list) {\n        while (++index < list.length) {\n          if (!list[index].previous || list[index].previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n    }\n  }\n}\n\nfunction createResolver(extraResolver) {\n  return resolveAllText;\n\n  function resolveAllText(events, context) {\n    var index = -1;\n    var enter; // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === 'data') {\n          enter = index;\n          index++;\n        }\n      } else if (!events[index] || events[index][1].type !== 'data') {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end;\n          events.splice(enter + 2, index - enter - 2);\n          index = enter + 2;\n        }\n\n        enter = undefined;\n      }\n    }\n\n    return extraResolver ? extraResolver(events, context) : events;\n  }\n} // A rather ugly set of instructions which again looks at chunks in the input\n// stream.\n// The reason to do this here is that it is *much* faster to parse in reverse.\n// And that we can’t hook into `null` to split the line suffix before an EOF.\n// To do: figure out if we can make this into a clean utility, or even in core.\n// As it will be useful for GFMs literal autolink extension (and maybe even\n// tables?)\n\n\nfunction resolveAllLineSuffixes(events, context) {\n  var eventIndex = -1;\n  var chunks;\n  var data;\n  var chunk;\n  var index;\n  var bufferIndex;\n  var size;\n  var tabs;\n  var token;\n\n  while (++eventIndex <= events.length) {\n    if ((eventIndex === events.length || events[eventIndex][1].type === 'lineEnding') && events[eventIndex - 1][1].type === 'data') {\n      data = events[eventIndex - 1][1];\n      chunks = context.sliceStream(data);\n      index = chunks.length;\n      bufferIndex = -1;\n      size = 0;\n      tabs = undefined;\n\n      while (index--) {\n        chunk = chunks[index];\n\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\n          }\n\n          if (bufferIndex) break;\n          bufferIndex = -1;\n        } // Number\n        else if (chunk === -2) {\n            tabs = true;\n            size++;\n          } else if (chunk === -1) ;else {\n            // Replacement character, exit.\n            index++;\n            break;\n          }\n      }\n\n      if (size) {\n        token = {\n          type: eventIndex === events.length || tabs || size < 2 ? 'lineSuffix' : 'hardBreakTrailing',\n          start: {\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size,\n            _index: data.start._index + index,\n            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex\n          },\n          end: shallow(data.end)\n        };\n        data.end = shallow(token.start);\n\n        if (data.start.offset === data.end.offset) {\n          assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n\n      eventIndex++;\n    }\n  }\n\n  return events;\n}\n\nexports.resolver = resolver;\nexports.string = string;\nexports.text = text;","'use strict';\n\nvar content = require('./initialize/content.js');\n\nvar document = require('./initialize/document.js');\n\nvar flow = require('./initialize/flow.js');\n\nvar text = require('./initialize/text.js');\n\nvar combineExtensions = require('./util/combine-extensions.js');\n\nvar createTokenizer = require('./util/create-tokenizer.js');\n\nvar miniflat = require('./util/miniflat.js');\n\nvar constructs = require('./constructs.js');\n\nfunction parse(options) {\n  var settings = options || {};\n  var parser = {\n    defined: [],\n    constructs: combineExtensions([constructs].concat(miniflat(settings.extensions))),\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(text.string),\n    text: create(text.text)\n  };\n  return parser;\n\n  function create(initializer) {\n    return creator;\n\n    function creator(from) {\n      return createTokenizer(parser, initializer, from);\n    }\n  }\n}\n\nmodule.exports = parse;","'use strict';\n\nvar subtokenize = require('./util/subtokenize.js');\n\nfunction postprocess(events) {\n  while (!subtokenize(events)) {// Empty\n  }\n\n  return events;\n}\n\nmodule.exports = postprocess;","'use strict';\n\nvar search = /[\\0\\t\\n\\r]/g;\n\nfunction preprocess() {\n  var start = true;\n  var column = 1;\n  var buffer = '';\n  var atCarriageReturn;\n  return preprocessor;\n\n  function preprocessor(value, encoding, end) {\n    var chunks = [];\n    var match;\n    var next;\n    var startPosition;\n    var endPosition;\n    var code;\n    value = buffer + value.toString(encoding);\n    startPosition = 0;\n    buffer = '';\n\n    if (start) {\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n\n      start = undefined;\n    }\n\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition;\n      match = search.exec(value);\n      endPosition = match ? match.index : value.length;\n      code = value.charCodeAt(endPosition);\n\n      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\n      }\n\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3);\n        atCarriageReturn = undefined;\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5);\n          atCarriageReturn = undefined;\n        }\n\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\n        }\n\n        if (code === 0) {\n          chunks.push(65533);\n          column++;\n        } else if (code === 9) {\n          next = Math.ceil(column / 4) * 4;\n          chunks.push(-2);\n\n          while (column++ < next) {\n            chunks.push(-1);\n          }\n        } else if (code === 10) {\n          chunks.push(-4);\n          column = 1;\n        } // Must be carriage return.\n        else {\n            atCarriageReturn = true;\n            column = 1;\n          }\n      }\n\n      startPosition = endPosition + 1;\n    }\n\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n\n    return chunks;\n  }\n}\n\nmodule.exports = preprocess;","'use strict';\n\nvar chunkedPush = require('../util/chunked-push.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar classifyCharacter = require('../util/classify-character.js');\n\nvar movePoint = require('../util/move-point.js');\n\nvar resolveAll = require('../util/resolve-all.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n};\n\nfunction resolveAllAttention(events, context) {\n  var index = -1;\n  var open;\n  var group;\n  var text;\n  var openingSequence;\n  var closingSequence;\n  var use;\n  var nextEvents;\n  var offset; // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {\n      open = index; // Now walk back to find an opener.\n\n      while (open--) {\n        // Find a token that can open the closer.\n        if (events[open][0] === 'exit' && events[open][1].type === 'attentionSequence' && events[open][1]._open && // If the markers are the same:\n        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {\n            continue;\n          } // Number of markers to use from the sequence.\n\n\n          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: movePoint(shallow(events[open][1].end), -use),\n            end: shallow(events[open][1].end)\n          };\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: shallow(events[index][1].start),\n            end: movePoint(shallow(events[index][1].start), use)\n          };\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: shallow(events[open][1].end),\n            end: shallow(events[index][1].start)\n          };\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: shallow(openingSequence.start),\n            end: shallow(closingSequence.end)\n          };\n          events[open][1].end = shallow(openingSequence.start);\n          events[index][1].start = shallow(closingSequence.end);\n          nextEvents = []; // If there are more markers in the opening, add them before.\n\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = chunkedPush(nextEvents, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          } // Opening.\n\n\n          nextEvents = chunkedPush(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]); // Between.\n\n          nextEvents = chunkedPush(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context)); // Closing.\n\n          nextEvents = chunkedPush(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]); // If there are more markers in the closing, add them after.\n\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2;\n            nextEvents = chunkedPush(nextEvents, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\n          } else {\n            offset = 0;\n          }\n\n          chunkedSplice(events, open - 1, index - open + 3, nextEvents);\n          index = open + nextEvents.length - offset - 2;\n          break;\n        }\n      }\n    }\n  } // Remove remaining sequences.\n\n\n  index = -1;\n\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n\n  return events;\n}\n\nfunction tokenizeAttention(effects, ok) {\n  var before = classifyCharacter(this.previous);\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('attentionSequence');\n    marker = code;\n    return sequence(code);\n  }\n\n  function sequence(code) {\n    var token;\n    var after;\n    var open;\n    var close;\n\n    if (code === marker) {\n      effects.consume(code);\n      return sequence;\n    }\n\n    token = effects.exit('attentionSequence');\n    after = classifyCharacter(code);\n    open = !after || after === 2 && before;\n    close = !before || before === 2 && after;\n    token._open = marker === 42 ? open : open && (before || !close);\n    token._close = marker === 42 ? close : close && (after || !open);\n    return ok(code);\n  }\n}\n\nmodule.exports = attention;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar asciiAtext = require('../character/ascii-atext.js');\n\nvar asciiControl = require('../character/ascii-control.js');\n\nvar autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\n\nfunction tokenizeAutolink(effects, ok, nok) {\n  var size = 1;\n  return start;\n\n  function start(code) {\n    effects.enter('autolink');\n    effects.enter('autolinkMarker');\n    effects.consume(code);\n    effects.exit('autolinkMarker');\n    effects.enter('autolinkProtocol');\n    return open;\n  }\n\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n\n    return asciiAtext(code) ? emailAtext(code) : nok(code);\n  }\n\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code) ? schemeInsideOrEmailAtext(code) : emailAtext(code);\n  }\n\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      return urlInside;\n    }\n\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n\n    return emailAtext(code);\n  }\n\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol');\n      return end(code);\n    }\n\n    if (code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n\n    effects.consume(code);\n    return urlInside;\n  }\n\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n\n    return nok(code);\n  }\n\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail';\n      return end(code);\n    }\n\n    return emailValue(code);\n  }\n\n  function emailValue(code) {\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      effects.consume(code);\n      return code === 45 ? emailValue : emailLabel;\n    }\n\n    return nok(code);\n  }\n\n  function end(code) {\n    effects.enter('autolinkMarker');\n    effects.consume(code);\n    effects.exit('autolinkMarker');\n    effects.exit('autolink');\n    return ok;\n  }\n}\n\nmodule.exports = autolink;","'use strict';\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit: exit\n};\n\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    if (code === 62) {\n      if (!self.containerState.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        });\n        self.containerState.open = true;\n      }\n\n      effects.enter('blockQuotePrefix');\n      effects.enter('blockQuoteMarker');\n      effects.consume(code);\n      effects.exit('blockQuoteMarker');\n      return after;\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter('blockQuotePrefixWhitespace');\n      effects.consume(code);\n      effects.exit('blockQuotePrefixWhitespace');\n      effects.exit('blockQuotePrefix');\n      return ok;\n    }\n\n    effects.exit('blockQuotePrefix');\n    return ok(code);\n  }\n}\n\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  return factorySpace(effects, effects.attempt(blockQuote, ok, nok), 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n}\n\nfunction exit(effects) {\n  effects.exit('blockQuote');\n}\n\nmodule.exports = blockQuote;","'use strict';\n\nvar asciiPunctuation = require('../character/ascii-punctuation.js');\n\nvar characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\n\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('characterEscape');\n    effects.enter('escapeMarker');\n    effects.consume(code);\n    effects.exit('escapeMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (asciiPunctuation(code)) {\n      effects.enter('characterEscapeValue');\n      effects.consume(code);\n      effects.exit('characterEscapeValue');\n      effects.exit('characterEscape');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = characterEscape;","'use strict';\n\nvar decodeEntity = require('parse-entities/decode-entity.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar asciiDigit = require('../character/ascii-digit.js');\n\nvar asciiHexDigit = require('../character/ascii-hex-digit.js');\n\nfunction _interopDefaultLegacy(e) {\n  return e && typeof e === 'object' && 'default' in e ? e : {\n    default: e\n  };\n}\n\nvar decodeEntity__default = /*#__PURE__*/_interopDefaultLegacy(decodeEntity);\n\nvar characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\n\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  var self = this;\n  var size = 0;\n  var max;\n  var test;\n  return start;\n\n  function start(code) {\n    effects.enter('characterReference');\n    effects.enter('characterReferenceMarker');\n    effects.consume(code);\n    effects.exit('characterReferenceMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric');\n      effects.consume(code);\n      effects.exit('characterReferenceMarkerNumeric');\n      return numeric;\n    }\n\n    effects.enter('characterReferenceValue');\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\n  }\n\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter('characterReferenceMarkerHexadecimal');\n      effects.consume(code);\n      effects.exit('characterReferenceMarkerHexadecimal');\n      effects.enter('characterReferenceValue');\n      max = 6;\n      test = asciiHexDigit;\n      return value;\n    }\n\n    effects.enter('characterReferenceValue');\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n\n  function value(code) {\n    var token;\n\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue');\n\n      if (test === asciiAlphanumeric && !decodeEntity__default['default'](self.sliceSerialize(token))) {\n        return nok(code);\n      }\n\n      effects.enter('characterReferenceMarker');\n      effects.consume(code);\n      effects.exit('characterReferenceMarker');\n      effects.exit('characterReference');\n      return ok;\n    }\n\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = characterReference;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n};\n\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  var self = this;\n  var closingFenceConstruct = {\n    tokenize: tokenizeClosingFence,\n    partial: true\n  };\n  var initialPrefix = prefixSize(this.events, 'linePrefix');\n  var sizeOpen = 0;\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('codeFenced');\n    effects.enter('codeFencedFence');\n    effects.enter('codeFencedFenceSequence');\n    marker = code;\n    return sequenceOpen(code);\n  }\n\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n\n    effects.exit('codeFencedFenceSequence');\n    return sizeOpen < 3 ? nok(code) : factorySpace(effects, infoOpen, 'whitespace')(code);\n  }\n\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code);\n    }\n\n    effects.enter('codeFencedFenceInfo');\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return info(code);\n  }\n\n  function info(code) {\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('chunkString');\n      effects.exit('codeFencedFenceInfo');\n      return factorySpace(effects, infoAfter, 'whitespace')(code);\n    }\n\n    if (code === 96 && code === marker) return nok(code);\n    effects.consume(code);\n    return info;\n  }\n\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code);\n    }\n\n    effects.enter('codeFencedFenceMeta');\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return meta(code);\n  }\n\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString');\n      effects.exit('codeFencedFenceMeta');\n      return openAfter(code);\n    }\n\n    if (code === 96 && code === marker) return nok(code);\n    effects.consume(code);\n    return meta;\n  }\n\n  function openAfter(code) {\n    effects.exit('codeFencedFence');\n    return self.interrupt ? ok(code) : content(code);\n  }\n\n  function content(code) {\n    if (code === null) {\n      return after(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return effects.attempt(closingFenceConstruct, after, initialPrefix ? factorySpace(effects, content, 'linePrefix', initialPrefix + 1) : content);\n    }\n\n    effects.enter('codeFlowValue');\n    return contentContinue(code);\n  }\n\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue');\n      return content(code);\n    }\n\n    effects.consume(code);\n    return contentContinue;\n  }\n\n  function after(code) {\n    effects.exit('codeFenced');\n    return ok(code);\n  }\n\n  function tokenizeClosingFence(effects, ok, nok) {\n    var size = 0;\n    return factorySpace(effects, closingSequenceStart, 'linePrefix', this.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n\n    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence');\n      effects.enter('codeFencedFenceSequence');\n      return closingSequence(code);\n    }\n\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code);\n        size++;\n        return closingSequence;\n      }\n\n      if (size < sizeOpen) return nok(code);\n      effects.exit('codeFencedFenceSequence');\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code);\n    }\n\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence');\n        return ok(code);\n      }\n\n      return nok(code);\n    }\n  }\n}\n\nmodule.exports = codeFenced;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented,\n  resolve: resolveCodeIndented\n};\nvar indentedContentConstruct = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\n};\n\nfunction resolveCodeIndented(events, context) {\n  var code = {\n    type: 'codeIndented',\n    start: events[0][1].start,\n    end: events[events.length - 1][1].end\n  };\n  chunkedSplice(events, 0, 0, [['enter', code, context]]);\n  chunkedSplice(events, events.length, 0, [['exit', code, context]]);\n  return events;\n}\n\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  return effects.attempt(indentedContentConstruct, afterPrefix, nok);\n\n  function afterPrefix(code) {\n    if (code === null) {\n      return ok(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContentConstruct, afterPrefix, ok)(code);\n    }\n\n    effects.enter('codeFlowValue');\n    return content(code);\n  }\n\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue');\n      return afterPrefix(code);\n    }\n\n    effects.consume(code);\n    return content;\n  }\n}\n\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1);\n\n  function afterPrefix(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1);\n    }\n\n    return prefixSize(self.events, 'linePrefix') < 4 ? nok(code) : ok(code);\n  }\n}\n\nmodule.exports = codeIndented;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous: previous\n};\n\nfunction resolveCodeText(events) {\n  var tailExitIndex = events.length - 4;\n  var headEnterIndex = 3;\n  var index;\n  var enter; // If we start and end with an EOL or a space.\n\n  if ((events[headEnterIndex][1].type === 'lineEnding' || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === 'lineEnding' || events[tailExitIndex][1].type === 'space')) {\n    index = headEnterIndex; // And we have data.\n\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === 'codeTextData') {\n        // Then we have padding.\n        events[tailExitIndex][1].type = events[headEnterIndex][1].type = 'codeTextPadding';\n        headEnterIndex += 2;\n        tailExitIndex -= 2;\n        break;\n      }\n    }\n  } // Merge adjacent spaces and data.\n\n\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === 'lineEnding') {\n      events[enter][1].type = 'codeTextData';\n\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end;\n        events.splice(enter + 2, index - enter - 2);\n        tailExitIndex -= index - enter - 2;\n        index = enter + 2;\n      }\n\n      enter = undefined;\n    }\n  }\n\n  return events;\n}\n\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === 'characterEscape';\n}\n\nfunction tokenizeCodeText(effects, ok, nok) {\n  var sizeOpen = 0;\n  var size;\n  var token;\n  return start;\n\n  function start(code) {\n    effects.enter('codeText');\n    effects.enter('codeTextSequence');\n    return openingSequence(code);\n  }\n\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return openingSequence;\n    }\n\n    effects.exit('codeTextSequence');\n    return gap(code);\n  }\n\n  function gap(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    } // Closing fence?\n    // Could also be data.\n\n\n    if (code === 96) {\n      token = effects.enter('codeTextSequence');\n      size = 0;\n      return closingSequence(code);\n    } // Tabs don’t work, and virtual spaces don’t make sense.\n\n\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return gap;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return gap;\n    } // Data.\n\n\n    effects.enter('codeTextData');\n    return data(code);\n  } // In code.\n\n\n  function data(code) {\n    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit('codeTextData');\n      return gap(code);\n    }\n\n    effects.consume(code);\n    return data;\n  } // Closing fence.\n\n\n  function closingSequence(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return closingSequence;\n    } // Done!\n\n\n    if (size === sizeOpen) {\n      effects.exit('codeTextSequence');\n      effects.exit('codeText');\n      return ok(code);\n    } // More or less accents: mark as data.\n\n\n    token.type = 'codeTextData';\n    return data(code);\n  }\n}\n\nmodule.exports = codeText;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar subtokenize = require('../util/subtokenize.js');\n\nvar factorySpace = require('./factory-space.js'); // No name because it must not be turned off.\n\n\nvar content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent,\n  interruptible: true,\n  lazy: true\n};\nvar continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n}; // Content is transparent: it’s parsed right now. That way, definitions are also\n// parsed right now: before text in paragraphs (specifically, media) are parsed.\n\nfunction resolveContent(events) {\n  subtokenize(events);\n  return events;\n}\n\nfunction tokenizeContent(effects, ok) {\n  var previous;\n  return start;\n\n  function start(code) {\n    effects.enter('content');\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    });\n    return data(code);\n  }\n\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    } // Data.\n\n\n    effects.consume(code);\n    return data;\n  }\n\n  function contentEnd(code) {\n    effects.exit('chunkContent');\n    effects.exit('content');\n    return ok(code);\n  }\n\n  function contentContinue(code) {\n    effects.consume(code);\n    effects.exit('chunkContent');\n    previous = previous.next = effects.enter('chunkContent', {\n      contentType: 'content',\n      previous: previous\n    });\n    return data;\n  }\n}\n\nfunction tokenizeContinuation(effects, ok, nok) {\n  var self = this;\n  return startLookahead;\n\n  function startLookahead(code) {\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, prefixed, 'linePrefix');\n  }\n\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    if (self.parser.constructs.disable.null.indexOf('codeIndented') > -1 || prefixSize(self.events, 'linePrefix') < 4) {\n      return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\n    }\n\n    return ok(code);\n  }\n}\n\nmodule.exports = content;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar normalizeIdentifier = require('../util/normalize-identifier.js');\n\nvar factoryDestination = require('./factory-destination.js');\n\nvar factoryLabel = require('./factory-label.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar factoryWhitespace = require('./factory-whitespace.js');\n\nvar factoryTitle = require('./factory-title.js');\n\nvar definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\nvar titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n};\n\nfunction tokenizeDefinition(effects, ok, nok) {\n  var self = this;\n  var identifier;\n  return start;\n\n  function start(code) {\n    effects.enter('definition');\n    return factoryLabel.call(self, effects, labelAfter, nok, 'definitionLabel', 'definitionLabelMarker', 'definitionLabelString')(code);\n  }\n\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n\n    if (code === 58) {\n      effects.enter('definitionMarker');\n      effects.consume(code);\n      effects.exit('definitionMarker'); // Note: blank lines can’t exist in content.\n\n      return factoryWhitespace(effects, factoryDestination(effects, effects.attempt(titleConstruct, factorySpace(effects, after, 'whitespace'), factorySpace(effects, after, 'whitespace')), nok, 'definitionDestination', 'definitionDestinationLiteral', 'definitionDestinationLiteralMarker', 'definitionDestinationRaw', 'definitionDestinationString'));\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition');\n\n      if (self.parser.defined.indexOf(identifier) < 0) {\n        self.parser.defined.push(identifier);\n      }\n\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nfunction tokenizeTitle(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, before)(code) : nok(code);\n  }\n\n  function before(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, factorySpace(effects, after, 'whitespace'), nok, 'definitionTitle', 'definitionTitleMarker', 'definitionTitleString')(code);\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}\n\nmodule.exports = definition;","'use strict';\n\nvar asciiControl = require('../character/ascii-control.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js'); // eslint-disable-next-line max-params\n\n\nfunction destinationFactory(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) {\n  var limit = max || Infinity;\n  var balance = 0;\n  return start;\n\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type);\n      effects.enter(literalType);\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      return destinationEnclosedBefore;\n    }\n\n    if (asciiControl(code) || code === 41) {\n      return nok(code);\n    }\n\n    effects.enter(type);\n    effects.enter(rawType);\n    effects.enter(stringType);\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return destinationRaw(code);\n  }\n\n  function destinationEnclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      effects.exit(literalType);\n      effects.exit(type);\n      return ok;\n    }\n\n    effects.enter(stringType);\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return destinationEnclosed(code);\n  }\n\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString');\n      effects.exit(stringType);\n      return destinationEnclosedBefore(code);\n    }\n\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    effects.consume(code);\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed;\n  }\n\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code);\n      return destinationEnclosed;\n    }\n\n    return destinationEnclosed(code);\n  }\n\n  function destinationRaw(code) {\n    if (code === 40) {\n      if (++balance > limit) return nok(code);\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    if (code === 41) {\n      if (!balance--) {\n        effects.exit('chunkString');\n        effects.exit(stringType);\n        effects.exit(rawType);\n        effects.exit(type);\n        return ok(code);\n      }\n\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      if (balance) return nok(code);\n      effects.exit('chunkString');\n      effects.exit(stringType);\n      effects.exit(rawType);\n      effects.exit(type);\n      return ok(code);\n    }\n\n    if (asciiControl(code)) return nok(code);\n    effects.consume(code);\n    return code === 92 ? destinationRawEscape : destinationRaw;\n  }\n\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    return destinationRaw(code);\n  }\n}\n\nmodule.exports = destinationFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownSpace = require('../character/markdown-space.js'); // eslint-disable-next-line max-params\n\n\nfunction labelFactory(effects, ok, nok, type, markerType, stringType) {\n  var self = this;\n  var size = 0;\n  var data;\n  return start;\n\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    effects.enter(stringType);\n    return atBreak;\n  }\n\n  function atBreak(code) {\n    if (code === null || code === 91 || code === 93 && !data ||\n    /* c8 ignore next */\n    code === 94 &&\n    /* c8 ignore next */\n    !size &&\n    /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs || size > 999) {\n      return nok(code);\n    }\n\n    if (code === 93) {\n      effects.exit(stringType);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return atBreak;\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return label(code);\n  }\n\n  function label(code) {\n    if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {\n      effects.exit('chunkString');\n      return atBreak(code);\n    }\n\n    effects.consume(code);\n    data = data || !markdownSpace(code);\n    return code === 92 ? labelEscape : label;\n  }\n\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return label;\n    }\n\n    return label(code);\n  }\n}\n\nmodule.exports = labelFactory;","'use strict';\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nfunction spaceFactory(effects, ok, type, max) {\n  var limit = max ? max - 1 : Infinity;\n  var size = 0;\n  return start;\n\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n\n    return ok(code);\n  }\n\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n\n    effects.exit(type);\n    return ok(code);\n  }\n}\n\nmodule.exports = spaceFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('./factory-space.js');\n\nfunction titleFactory(effects, ok, nok, type, markerType, stringType) {\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    marker = code === 40 ? 41 : code;\n    return atFirstTitleBreak;\n  }\n\n  function atFirstTitleBreak(code) {\n    if (code === marker) {\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    effects.enter(stringType);\n    return atTitleBreak(code);\n  }\n\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType);\n      return atFirstTitleBreak(marker);\n    }\n\n    if (code === null) {\n      return nok(code);\n    } // Note: blank lines can’t exist in content.\n\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return factorySpace(effects, atTitleBreak, 'linePrefix');\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return title(code);\n  }\n\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString');\n      return atTitleBreak(code);\n    }\n\n    effects.consume(code);\n    return code === 92 ? titleEscape : title;\n  }\n\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code);\n      return title;\n    }\n\n    return title(code);\n  }\n}\n\nmodule.exports = titleFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nfunction whitespaceFactory(effects, ok) {\n  var seen;\n  return start;\n\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      seen = true;\n      return start;\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, start, seen ? 'linePrefix' : 'lineSuffix')(code);\n    }\n\n    return ok(code);\n  }\n}\n\nmodule.exports = whitespaceFactory;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('hardBreakEscape');\n    effects.enter('escapeMarker');\n    effects.consume(code);\n    return open;\n  }\n\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker');\n      effects.exit('hardBreakEscape');\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = hardBreakEscape;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n};\n\nfunction resolveHeadingAtx(events, context) {\n  var contentEnd = events.length - 2;\n  var contentStart = 3;\n  var content;\n  var text; // Prefix whitespace, part of the opening.\n\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2;\n  } // Suffix whitespace, part of the closing.\n\n\n  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === 'whitespace') {\n    contentEnd -= 2;\n  }\n\n  if (events[contentEnd][1].type === 'atxHeadingSequence' && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === 'whitespace')) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;\n  }\n\n  if (contentEnd > contentStart) {\n    content = {\n      type: 'atxHeadingText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    };\n    text = {\n      type: 'chunkText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      contentType: 'text'\n    };\n    chunkedSplice(events, contentStart, contentEnd - contentStart + 1, [['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]]);\n  }\n\n  return events;\n}\n\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  var self = this;\n  var size = 0;\n  return start;\n\n  function start(code) {\n    effects.enter('atxHeading');\n    effects.enter('atxHeadingSequence');\n    return fenceOpenInside(code);\n  }\n\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return fenceOpenInside;\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence');\n      return self.interrupt ? ok(code) : headingBreak(code);\n    }\n\n    return nok(code);\n  }\n\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence');\n      return sequence(code);\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading');\n      return ok(code);\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code);\n    }\n\n    effects.enter('atxHeadingText');\n    return data(code);\n  }\n\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequence;\n    }\n\n    effects.exit('atxHeadingSequence');\n    return headingBreak(code);\n  }\n\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText');\n      return headingBreak(code);\n    }\n\n    effects.consume(code);\n    return data;\n  }\n}\n\nmodule.exports = headingAtx;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nvar htmlBlockNames = require('../constant/html-block-names.js');\n\nvar htmlRawNames = require('../constant/html-raw-names.js');\n\nvar partialBlankLine = require('./partial-blank-line.js');\n\nvar htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n};\nvar nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n};\n\nfunction resolveToHtmlFlow(events) {\n  var index = events.length;\n\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break;\n    }\n  }\n\n  if (index > 1 && events[index - 2][1].type === 'linePrefix') {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start; // Add the prefix start to the HTML line token.\n\n    events[index + 1][1].start = events[index - 2][1].start; // Remove the line prefix.\n\n    events.splice(index - 2, 2);\n  }\n\n  return events;\n}\n\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  var self = this;\n  var kind;\n  var startTag;\n  var buffer;\n  var index;\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('htmlFlow');\n    effects.enter('htmlFlowData');\n    effects.consume(code);\n    return open;\n  }\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationStart;\n    }\n\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      kind = 3; // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      buffer = fromCharCode(code);\n      startTag = true;\n      return tagName;\n    }\n\n    return nok(code);\n  }\n\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code);\n      kind = 2;\n      return commentOpenInside;\n    }\n\n    if (code === 91) {\n      effects.consume(code);\n      kind = 5;\n      buffer = 'CDATA[';\n      index = 0;\n      return cdataOpenInside;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      kind = 4;\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    return nok(code);\n  }\n\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    return nok(code);\n  }\n\n  function cdataOpenInside(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === buffer.length ? self.interrupt ? ok : continuation : cdataOpenInside;\n    }\n\n    return nok(code);\n  }\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      buffer = fromCharCode(code);\n      return tagName;\n    }\n\n    return nok(code);\n  }\n\n  function tagName(code) {\n    if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      if (code !== 47 && startTag && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {\n        kind = 1;\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n\n      if (htmlBlockNames.indexOf(buffer.toLowerCase()) > -1) {\n        kind = 6;\n\n        if (code === 47) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n\n      kind = 7; // Do not support complete HTML when interrupting.\n\n      return self.interrupt ? nok(code) : startTag ? completeAttributeNameBefore(code) : completeClosingTagAfter(code);\n    }\n\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += fromCharCode(code);\n      return tagName;\n    }\n\n    return nok(code);\n  }\n\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return self.interrupt ? ok : continuation;\n    }\n\n    return nok(code);\n  }\n\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n\n    return completeEnd(code);\n  }\n\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n\n    return completeEnd(code);\n  }\n\n  function completeAttributeName(code) {\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n\n    return completeAttributeNameAfter(code);\n  }\n\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n\n    return completeAttributeNameBefore(code);\n  }\n\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return completeAttributeValueQuoted;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n\n    marker = undefined;\n    return completeAttributeValueUnquoted(code);\n  }\n\n  function completeAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return completeAttributeValueQuotedAfter;\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    effects.consume(code);\n    return completeAttributeValueQuoted;\n  }\n\n  function completeAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\n      return completeAttributeNameAfter(code);\n    }\n\n    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n\n    return nok(code);\n  }\n\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n\n    return nok(code);\n  }\n\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n\n    return code === null || markdownLineEnding(code) ? continuation(code) : nok(code);\n  }\n\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n\n    if (code === 60 && kind === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n\n    if (code === 62 && kind === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    if (code === 63 && kind === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    if (code === 93 && kind === 5) {\n      effects.consume(code);\n      return continuationCharacterDataInside;\n    }\n\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(nextBlankConstruct, continuationClose, continuationAtLineEnding)(code);\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code);\n    }\n\n    effects.consume(code);\n    return continuation;\n  }\n\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData');\n    return htmlContinueStart(code);\n  }\n\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return htmlContinueStart;\n    }\n\n    effects.enter('htmlFlowData');\n    return continuation(code);\n  }\n\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code);\n      buffer += fromCharCode(code);\n      return continuationRawEndTag;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    return continuation(code);\n  }\n\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData');\n      return done(code);\n    }\n\n    effects.consume(code);\n    return continuationClose;\n  }\n\n  function done(code) {\n    effects.exit('htmlFlow');\n    return ok(code);\n  }\n}\n\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.exit('htmlFlowData');\n    effects.enter('lineEndingBlank');\n    effects.consume(code);\n    effects.exit('lineEndingBlank');\n    return effects.attempt(partialBlankLine, ok, nok);\n  }\n}\n\nmodule.exports = htmlFlow;","'use strict';\n\nvar asciiAlpha = require('../character/ascii-alpha.js');\n\nvar asciiAlphanumeric = require('../character/ascii-alphanumeric.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n};\n\nfunction tokenizeHtmlText(effects, ok, nok) {\n  var self = this;\n  var marker;\n  var buffer;\n  var index;\n  var returnState;\n  return start;\n\n  function start(code) {\n    effects.enter('htmlText');\n    effects.enter('htmlTextData');\n    effects.consume(code);\n    return open;\n  }\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n\n    return nok(code);\n  }\n\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpen;\n    }\n\n    if (code === 91) {\n      effects.consume(code);\n      buffer = 'CDATA[';\n      index = 0;\n      return cdataOpen;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n\n    return nok(code);\n  }\n\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentStart;\n    }\n\n    return nok(code);\n  }\n\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code);\n    }\n\n    if (code === 45) {\n      effects.consume(code);\n      return commentStartDash;\n    }\n\n    return comment(code);\n  }\n\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code);\n    }\n\n    return comment(code);\n  }\n\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return comment;\n  }\n\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return end;\n    }\n\n    return comment(code);\n  }\n\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === buffer.length ? cdata : cdataOpen;\n    }\n\n    return nok(code);\n  }\n\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return cdata;\n  }\n\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n\n    return cdata(code);\n  }\n\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n\n    return cdata(code);\n  }\n\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return declaration;\n  }\n\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return instruction;\n  }\n\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n\n    return nok(code);\n  }\n\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n\n    return tagCloseBetween(code);\n  }\n\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n\n    return end(code);\n  }\n\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    return nok(code);\n  }\n\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n\n    return end(code);\n  }\n\n  function tagOpenAttributeName(code) {\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n\n    return tagOpenAttributeNameAfter(code);\n  }\n\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n\n    return tagOpenBetween(code);\n  }\n\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n\n    effects.consume(code);\n    marker = undefined;\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return tagOpenAttributeValueQuotedAfter;\n    }\n\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    return nok(code);\n  }\n\n  function tagOpenAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  } // We can’t have blank lines in content, so no need to worry about empty\n  // tokens.\n\n\n  function atLineEnding(code) {\n    effects.exit('htmlTextData');\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, afterPrefix, 'linePrefix', self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4);\n  }\n\n  function afterPrefix(code) {\n    effects.enter('htmlTextData');\n    return returnState(code);\n  }\n\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code);\n      effects.exit('htmlTextData');\n      effects.exit('htmlText');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = htmlText;","'use strict';\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar chunkedPush = require('../util/chunked-push.js');\n\nvar chunkedSplice = require('../util/chunked-splice.js');\n\nvar normalizeIdentifier = require('../util/normalize-identifier.js');\n\nvar resolveAll = require('../util/resolve-all.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar factoryDestination = require('./factory-destination.js');\n\nvar factoryLabel = require('./factory-label.js');\n\nvar factoryTitle = require('./factory-title.js');\n\nvar factoryWhitespace = require('./factory-whitespace.js');\n\nvar labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n};\nvar resourceConstruct = {\n  tokenize: tokenizeResource\n};\nvar fullReferenceConstruct = {\n  tokenize: tokenizeFullReference\n};\nvar collapsedReferenceConstruct = {\n  tokenize: tokenizeCollapsedReference\n};\n\nfunction resolveAllLabelEnd(events) {\n  var index = -1;\n  var token;\n\n  while (++index < events.length) {\n    token = events[index][1];\n\n    if (!token._used && (token.type === 'labelImage' || token.type === 'labelLink' || token.type === 'labelEnd')) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2);\n      token.type = 'data';\n      index++;\n    }\n  }\n\n  return events;\n}\n\nfunction resolveToLabelEnd(events, context) {\n  var index = events.length;\n  var offset = 0;\n  var group;\n  var label;\n  var text;\n  var token;\n  var open;\n  var close;\n  var media; // Find an opening.\n\n  while (index--) {\n    token = events[index][1];\n\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (token.type === 'link' || token.type === 'labelLink' && token._inactive) {\n        break;\n      } // Mark other link openings as inactive, as we can’t have links in\n      // links.\n\n\n      if (events[index][0] === 'enter' && token.type === 'labelLink') {\n        token._inactive = true;\n      }\n    } else if (close) {\n      if (events[index][0] === 'enter' && (token.type === 'labelImage' || token.type === 'labelLink') && !token._balanced) {\n        open = index;\n\n        if (token.type !== 'labelLink') {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index;\n    }\n  }\n\n  group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: shallow(events[open][1].start),\n    end: shallow(events[events.length - 1][1].end)\n  };\n  label = {\n    type: 'label',\n    start: shallow(events[open][1].start),\n    end: shallow(events[close][1].end)\n  };\n  text = {\n    type: 'labelText',\n    start: shallow(events[open + offset + 2][1].end),\n    end: shallow(events[close - 2][1].start)\n  };\n  media = [['enter', group, context], ['enter', label, context]]; // Opening marker.\n\n  media = chunkedPush(media, events.slice(open + 1, open + offset + 3)); // Text open.\n\n  media = chunkedPush(media, [['enter', text, context]]); // Between.\n\n  media = chunkedPush(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context)); // Text close, marker close, label close.\n\n  media = chunkedPush(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]); // Reference, resource, or so.\n\n  media = chunkedPush(media, events.slice(close + 1)); // Media close.\n\n  media = chunkedPush(media, [['exit', group, context]]);\n  chunkedSplice(events, open, events.length, media);\n  return events;\n}\n\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  var self = this;\n  var index = self.events.length;\n  var labelStart;\n  var defined; // Find an opening.\n\n  while (index--) {\n    if ((self.events[index][1].type === 'labelImage' || self.events[index][1].type === 'labelLink') && !self.events[index][1]._balanced) {\n      labelStart = self.events[index][1];\n      break;\n    }\n  }\n\n  return start;\n\n  function start(code) {\n    if (!labelStart) {\n      return nok(code);\n    } // It’s a balanced bracket, but contains a link.\n\n\n    if (labelStart._inactive) return balanced(code);\n    defined = self.parser.defined.indexOf(normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    }))) > -1;\n    effects.enter('labelEnd');\n    effects.enter('labelMarker');\n    effects.consume(code);\n    effects.exit('labelMarker');\n    effects.exit('labelEnd');\n    return afterLabelEnd;\n  }\n\n  function afterLabelEnd(code) {\n    // Resource: `[asd](fgh)`.\n    if (code === 40) {\n      return effects.attempt(resourceConstruct, ok, defined ? ok : balanced)(code);\n    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?\n\n\n    if (code === 91) {\n      return effects.attempt(fullReferenceConstruct, ok, defined ? effects.attempt(collapsedReferenceConstruct, ok, balanced) : balanced)(code);\n    } // Shortcut reference: `[asd]`?\n\n\n    return defined ? ok(code) : balanced(code);\n  }\n\n  function balanced(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\n\nfunction tokenizeResource(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('resource');\n    effects.enter('resourceMarker');\n    effects.consume(code);\n    effects.exit('resourceMarker');\n    return factoryWhitespace(effects, open);\n  }\n\n  function open(code) {\n    if (code === 41) {\n      return end(code);\n    }\n\n    return factoryDestination(effects, destinationAfter, nok, 'resourceDestination', 'resourceDestinationLiteral', 'resourceDestinationLiteralMarker', 'resourceDestinationRaw', 'resourceDestinationString', 3)(code);\n  }\n\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, between)(code) : end(code);\n  }\n\n  function between(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, factoryWhitespace(effects, end), nok, 'resourceTitle', 'resourceTitleMarker', 'resourceTitleString')(code);\n    }\n\n    return end(code);\n  }\n\n  function end(code) {\n    if (code === 41) {\n      effects.enter('resourceMarker');\n      effects.consume(code);\n      effects.exit('resourceMarker');\n      effects.exit('resource');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nfunction tokenizeFullReference(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    return factoryLabel.call(self, effects, afterLabel, nok, 'reference', 'referenceMarker', 'referenceString')(code);\n  }\n\n  function afterLabel(code) {\n    return self.parser.defined.indexOf(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) < 0 ? nok(code) : ok(code);\n  }\n}\n\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('reference');\n    effects.enter('referenceMarker');\n    effects.consume(code);\n    effects.exit('referenceMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (code === 93) {\n      effects.enter('referenceMarker');\n      effects.consume(code);\n      effects.exit('referenceMarker');\n      effects.exit('reference');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = labelEnd;","'use strict';\n\nvar labelEnd = require('./label-end.js');\n\nvar labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n};\n\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    effects.enter('labelImage');\n    effects.enter('labelImageMarker');\n    effects.consume(code);\n    effects.exit('labelImageMarker');\n    return open;\n  }\n\n  function open(code) {\n    if (code === 91) {\n      effects.enter('labelMarker');\n      effects.consume(code);\n      effects.exit('labelMarker');\n      effects.exit('labelImage');\n      return after;\n    }\n\n    return nok(code);\n  }\n\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 &&\n    /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs ?\n    /* c8 ignore next */\n    nok(code) : ok(code);\n  }\n}\n\nmodule.exports = labelStartImage;","'use strict';\n\nvar labelEnd = require('./label-end.js');\n\nvar labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n};\n\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  var self = this;\n  return start;\n\n  function start(code) {\n    effects.enter('labelLink');\n    effects.enter('labelMarker');\n    effects.consume(code);\n    effects.exit('labelMarker');\n    effects.exit('labelLink');\n    return after;\n  }\n\n  function after(code) {\n    /* c8 ignore next */\n    return code === 94 &&\n    /* c8 ignore next */\n    '_hiddenFootnoteSupport' in self.parser.constructs ?\n    /* c8 ignore next */\n    nok(code) : ok(code);\n  }\n}\n\nmodule.exports = labelStartLink;","'use strict';\n\nvar factorySpace = require('./factory-space.js');\n\nvar lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\n\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n\n  function start(code) {\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, ok, 'linePrefix');\n  }\n}\n\nmodule.exports = lineEnding;","'use strict';\n\nvar asciiDigit = require('../character/ascii-digit.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar prefixSize = require('../util/prefix-size.js');\n\nvar sizeChunks = require('../util/size-chunks.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar partialBlankLine = require('./partial-blank-line.js');\n\nvar thematicBreak = require('./thematic-break.js');\n\nvar list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n};\nvar listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n};\nvar indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n};\n\nfunction tokenizeListStart(effects, ok, nok) {\n  var self = this;\n  var initialSize = prefixSize(self.events, 'linePrefix');\n  var size = 0;\n  return start;\n\n  function start(code) {\n    var kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? 'listUnordered' : 'listOrdered');\n\n    if (kind === 'listUnordered' ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind;\n        effects.enter(kind, {\n          _container: true\n        });\n      }\n\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix');\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix');\n        effects.enter('listItemValue');\n        return inside(code);\n      }\n    }\n\n    return nok(code);\n  }\n\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\n    }\n\n    if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {\n      effects.exit('listItemValue');\n      return atMarker(code);\n    }\n\n    return nok(code);\n  }\n\n  function atMarker(code) {\n    effects.enter('listItemMarker');\n    effects.consume(code);\n    effects.exit('listItemMarker');\n    self.containerState.marker = self.containerState.marker || code;\n    return effects.check(partialBlankLine, // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\n  }\n\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter('listItemPrefixWhitespace');\n      effects.consume(code);\n      effects.exit('listItemPrefixWhitespace');\n      return endOfPrefix;\n    }\n\n    return nok(code);\n  }\n\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + sizeChunks(self.sliceStream(effects.exit('listItemPrefix')));\n    return ok(code);\n  }\n}\n\nfunction tokenizeListContinuation(effects, ok, nok) {\n  var self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(partialBlankLine, onBlank, notBlank);\n\n  function onBlank(code) {\n    self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine; // We have a blank line.\n    // Still, try to consume at most the items size.\n\n    return factorySpace(effects, ok, 'listItemIndent', self.containerState.size + 1)(code);\n  }\n\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;\n      return notInCurrentItem(code);\n    }\n\n    self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\n  }\n\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true; // As we’re closing flow, we’re no longer interrupting.\n\n    self.interrupt = undefined;\n    return factorySpace(effects, effects.attempt(list, ok, nok), 'linePrefix', self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4)(code);\n  }\n}\n\nfunction tokenizeIndent(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'listItemIndent', self.containerState.size + 1);\n\n  function afterPrefix(code) {\n    return prefixSize(self.events, 'listItemIndent') === self.containerState.size ? ok(code) : nok(code);\n  }\n}\n\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\n\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  var self = this;\n  return factorySpace(effects, afterPrefix, 'listItemPrefixWhitespace', self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ? undefined : 4 + 1);\n\n  function afterPrefix(code) {\n    return markdownSpace(code) || !prefixSize(self.events, 'listItemPrefixWhitespace') ? nok(code) : ok(code);\n  }\n}\n\nmodule.exports = list;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar partialBlankLine = {\n  tokenize: tokenizePartialBlankLine,\n  partial: true\n};\n\nfunction tokenizePartialBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix');\n\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}\n\nmodule.exports = partialBlankLine;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar shallow = require('../util/shallow.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n};\n\nfunction resolveToSetextUnderline(events, context) {\n  var index = events.length;\n  var content;\n  var text;\n  var definition;\n  var heading; // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index;\n        break;\n      }\n\n      if (events[index][1].type === 'paragraph') {\n        text = index;\n      }\n    } // Exit\n    else {\n        if (events[index][1].type === 'content') {\n          // Remove the content end (if needed we’ll add it later)\n          events.splice(index, 1);\n        }\n\n        if (!definition && events[index][1].type === 'definition') {\n          definition = index;\n        }\n      }\n  }\n\n  heading = {\n    type: 'setextHeading',\n    start: shallow(events[text][1].start),\n    end: shallow(events[events.length - 1][1].end)\n  }; // Change the paragraph to setext heading text.\n\n  events[text][1].type = 'setextHeadingText'; // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context]);\n    events.splice(definition + 1, 0, ['exit', events[content][1], context]);\n    events[content][1].end = shallow(events[definition][1].end);\n  } else {\n    events[content][1] = heading;\n  } // Add the heading exit at the end.\n\n\n  events.push(['exit', heading, context]);\n  return events;\n}\n\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  var self = this;\n  var index = self.events.length;\n  var marker;\n  var paragraph; // Find an opening.\n\n  while (index--) {\n    // Skip enter/exit of line ending, line prefix, and content.\n    // We can now either have a definition or a paragraph.\n    if (self.events[index][1].type !== 'lineEnding' && self.events[index][1].type !== 'linePrefix' && self.events[index][1].type !== 'content') {\n      paragraph = self.events[index][1].type === 'paragraph';\n      break;\n    }\n  }\n\n  return start;\n\n  function start(code) {\n    if (!self.lazy && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine');\n      effects.enter('setextHeadingLineSequence');\n      marker = code;\n      return closingSequence(code);\n    }\n\n    return nok(code);\n  }\n\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return closingSequence;\n    }\n\n    effects.exit('setextHeadingLineSequence');\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code);\n  }\n\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine');\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = setextUnderline;","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nvar factorySpace = require('./factory-space.js');\n\nvar thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\n\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  var size = 0;\n  var marker;\n  return start;\n\n  function start(code) {\n    effects.enter('thematicBreak');\n    marker = code;\n    return atBreak(code);\n  }\n\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence');\n      return sequence(code);\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code);\n    }\n\n    if (size < 3 || code !== null && !markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    effects.exit('thematicBreak');\n    return ok(code);\n  }\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n\n    effects.exit('thematicBreakSequence');\n    return atBreak(code);\n  }\n}\n\nmodule.exports = thematicBreak;","'use strict';\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nfunction chunkedPush(list, items) {\n  if (list.length) {\n    chunkedSplice(list, list.length, 0, items);\n    return list;\n  }\n\n  return items;\n}\n\nmodule.exports = chunkedPush;","'use strict';\n\nvar splice = require('../constant/splice.js'); // causes a stack overflow in V8 when trying to insert 100k items for instance.\n\n\nfunction chunkedSplice(list, start, remove, items) {\n  var end = list.length;\n  var chunkStart = 0;\n  var parameters; // Make start between zero and `end` (included).\n\n  if (start < 0) {\n    start = -start > end ? 0 : end + start;\n  } else {\n    start = start > end ? end : start;\n  }\n\n  remove = remove > 0 ? remove : 0; // No need to chunk the items if there’s only a couple (10k) items.\n\n  if (items.length < 10000) {\n    parameters = Array.from(items);\n    parameters.unshift(start, remove);\n    splice.apply(list, parameters);\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) splice.apply(list, [start, remove]); // Insert the items in chunks to not cause stack overflows.\n\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000);\n      parameters.unshift(start, 0);\n      splice.apply(list, parameters);\n      chunkStart += 10000;\n      start += 10000;\n    }\n  }\n}\n\nmodule.exports = chunkedSplice;","'use strict';\n\nvar markdownLineEndingOrSpace = require('../character/markdown-line-ending-or-space.js');\n\nvar unicodePunctuation = require('../character/unicode-punctuation.js');\n\nvar unicodeWhitespace = require('../character/unicode-whitespace.js'); // Classify whether a character is unicode whitespace, unicode punctuation, or\n// anything else.\n// Used for attention (emphasis, strong), whose sequences can open or close\n// based on the class of surrounding characters.\n\n\nfunction classifyCharacter(code) {\n  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}\n\nmodule.exports = classifyCharacter;","'use strict';\n\nvar hasOwnProperty = require('../constant/has-own-property.js');\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nvar miniflat = require('./miniflat.js');\n\nfunction combineExtensions(extensions) {\n  var all = {};\n  var index = -1;\n\n  while (++index < extensions.length) {\n    extension(all, extensions[index]);\n  }\n\n  return all;\n}\n\nfunction extension(all, extension) {\n  var hook;\n  var left;\n  var right;\n  var code;\n\n  for (hook in extension) {\n    left = hasOwnProperty.call(all, hook) ? all[hook] : all[hook] = {};\n    right = extension[hook];\n\n    for (code in right) {\n      left[code] = constructs(miniflat(right[code]), hasOwnProperty.call(left, code) ? left[code] : []);\n    }\n  }\n}\n\nfunction constructs(list, existing) {\n  var index = -1;\n  var before = [];\n\n  while (++index < list.length) {\n    ;\n    (list[index].add === 'after' ? existing : before).push(list[index]);\n  }\n\n  chunkedSplice(existing, 0, 0, before);\n  return existing;\n}\n\nmodule.exports = combineExtensions;","'use strict';\n\nvar assign = require('../constant/assign.js');\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar chunkedPush = require('./chunked-push.js');\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nvar miniflat = require('./miniflat.js');\n\nvar resolveAll = require('./resolve-all.js');\n\nvar serializeChunks = require('./serialize-chunks.js');\n\nvar shallow = require('./shallow.js');\n\nvar sliceChunks = require('./slice-chunks.js'); // Create a tokenizer.\n// Tokenizers deal with one type of data (e.g., containers, flow, text).\n// The parser is the object dealing with it all.\n// `initialize` works like other constructs, except that only its `tokenize`\n// function is used, in which case it doesn’t receive an `ok` or `nok`.\n// `from` can be given to set the point before the first character, although\n// when further lines are indented, they must be set with `defineSkip`.\n\n\nfunction createTokenizer(parser, initialize, from) {\n  var point = from ? shallow(from) : {\n    line: 1,\n    column: 1,\n    offset: 0\n  };\n  var columnStart = {};\n  var resolveAllConstructs = [];\n  var chunks = [];\n  var stack = [];\n  var effects = {\n    consume: consume,\n    enter: enter,\n    exit: exit,\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    }),\n    lazy: constructFactory(onsuccessfulcheck, {\n      lazy: true\n    })\n  }; // State and tools for resolving and serializing.\n\n  var context = {\n    previous: null,\n    events: [],\n    parser: parser,\n    sliceStream: sliceStream,\n    sliceSerialize: sliceSerialize,\n    now: now,\n    defineSkip: skip,\n    write: write\n  }; // The state function.\n\n  var state = initialize.tokenize.call(context, effects); // Track which character we expect to be consumed, to catch bugs.\n\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize);\n  } // Store where we are in the input stream.\n\n\n  point._index = 0;\n  point._bufferIndex = -1;\n  return context;\n\n  function write(slice) {\n    chunks = chunkedPush(chunks, slice);\n    main(); // Exit if we’re not done, resolve might change stuff.\n\n    if (chunks[chunks.length - 1] !== null) {\n      return [];\n    }\n\n    addResult(initialize, 0); // Otherwise, resolve, and exit.\n\n    context.events = resolveAll(resolveAllConstructs, context.events, context);\n    return context.events;\n  } //\n  // Tools.\n  //\n\n\n  function sliceSerialize(token) {\n    return serializeChunks(sliceStream(token));\n  }\n\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n\n  function now() {\n    return shallow(point);\n  }\n\n  function skip(value) {\n    columnStart[value.line] = value.column;\n    accountForPotentialSkip();\n  } //\n  // State management.\n  //\n  // Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n  // `consume`).\n  // Here is where we walk through the chunks, which either include strings of\n  // several characters, or numerical character codes.\n  // The reason to do this in a loop instead of a call is so the stack can\n  // drain.\n\n\n  function main() {\n    var chunkIndex;\n    var chunk;\n\n    while (point._index < chunks.length) {\n      chunk = chunks[point._index]; // If we’re in a buffer chunk, loop through it.\n\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index;\n\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\n        }\n\n        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {\n          go(chunk.charCodeAt(point._bufferIndex));\n        }\n      } else {\n        go(chunk);\n      }\n    }\n  } // Deal with one code.\n\n\n  function go(code) {\n    state = state(code);\n  } // Move a character forward.\n\n\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++;\n      point.column = 1;\n      point.offset += code === -3 ? 2 : 1;\n      accountForPotentialSkip();\n    } else if (code !== -1) {\n      point.column++;\n      point.offset++;\n    } // Not in a string chunk.\n\n\n    if (point._bufferIndex < 0) {\n      point._index++;\n    } else {\n      point._bufferIndex++; // At end of string chunk.\n\n      if (point._bufferIndex === chunks[point._index].length) {\n        point._bufferIndex = -1;\n        point._index++;\n      }\n    } // Expose the previous character.\n\n\n    context.previous = code; // Mark as consumed.\n  } // Start a token.\n\n\n  function enter(type, fields) {\n    var token = fields || {};\n    token.type = type;\n    token.start = now();\n    context.events.push(['enter', token, context]);\n    stack.push(token);\n    return token;\n  } // Stop a token.\n\n\n  function exit(type) {\n    var token = stack.pop();\n    token.end = now();\n    context.events.push(['exit', token, context]);\n    return token;\n  } // Use results.\n\n\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  } // Discard results.\n\n\n  function onsuccessfulcheck(construct, info) {\n    info.restore();\n  } // Factory to attempt/check/interrupt.\n\n\n  function constructFactory(onreturn, fields) {\n    return hook; // Handle either an object mapping codes to constructs, a list of\n    // constructs, or a single construct.\n\n    function hook(constructs, returnState, bogusState) {\n      var listOfConstructs;\n      var constructIndex;\n      var currentConstruct;\n      var info;\n      return constructs.tokenize || 'length' in constructs ? handleListOfConstructs(miniflat(constructs)) : handleMapOfConstructs;\n\n      function handleMapOfConstructs(code) {\n        if (code in constructs || null in constructs) {\n          return handleListOfConstructs(constructs.null ?\n          /* c8 ignore next */\n          miniflat(constructs[code]).concat(miniflat(constructs.null)) : constructs[code])(code);\n        }\n\n        return bogusState(code);\n      }\n\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        return handleConstruct(list[constructIndex]);\n      }\n\n      function handleConstruct(construct) {\n        return start;\n\n        function start(code) {\n          // To do: not nede to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store();\n          currentConstruct = construct;\n\n          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n\n          if (construct.name && context.parser.constructs.disable.null.indexOf(construct.name) > -1) {\n            return nok();\n          }\n\n          return construct.tokenize.call(fields ? assign({}, context, fields) : context, effects, ok, nok)(code);\n        }\n      }\n\n      function ok(code) {\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n\n      function nok(code) {\n        info.restore();\n\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n\n        return bogusState;\n      }\n    }\n  }\n\n  function addResult(construct, from) {\n    if (construct.resolveAll && resolveAllConstructs.indexOf(construct) < 0) {\n      resolveAllConstructs.push(construct);\n    }\n\n    if (construct.resolve) {\n      chunkedSplice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\n    }\n  }\n\n  function store() {\n    var startPoint = now();\n    var startPrevious = context.previous;\n    var startCurrentConstruct = context.currentConstruct;\n    var startEventsIndex = context.events.length;\n    var startStack = Array.from(stack);\n    return {\n      restore: restore,\n      from: startEventsIndex\n    };\n\n    function restore() {\n      point = startPoint;\n      context.previous = startPrevious;\n      context.currentConstruct = startCurrentConstruct;\n      context.events.length = startEventsIndex;\n      stack = startStack;\n      accountForPotentialSkip();\n    }\n  }\n\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line];\n      point.offset += columnStart[point.line] - 1;\n    }\n  }\n}\n\nmodule.exports = createTokenizer;","'use strict';\n\nfunction miniflat(value) {\n  return value === null || value === undefined ? [] : 'length' in value ? value : [value];\n}\n\nmodule.exports = miniflat;","'use strict'; // chunks (replacement characters, tabs, or line endings).\n\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n  return point;\n}\n\nmodule.exports = movePoint;","'use strict';\n\nfunction normalizeIdentifier(value) {\n  return value // Collapse Markdown whitespace.\n  .replace(/[\\t\\n\\r ]+/g, ' ') // Trim.\n  .replace(/^ | $/g, '') // Some characters are considered “uppercase”, but if their lowercase\n  // counterpart is uppercased will result in a different uppercase\n  // character.\n  // Hence, to get that form, we perform both lower- and uppercase.\n  // Upper case makes sure keys will not interact with default prototypal\n  // methods: no object method is uppercase.\n  .toLowerCase().toUpperCase();\n}\n\nmodule.exports = normalizeIdentifier;","'use strict';\n\nvar sizeChunks = require('./size-chunks.js');\n\nfunction prefixSize(events, type) {\n  var tail = events[events.length - 1];\n  if (!tail || tail[1].type !== type) return 0;\n  return sizeChunks(tail[2].sliceStream(tail[1]));\n}\n\nmodule.exports = prefixSize;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nfunction regexCheck(regex) {\n  return check;\n\n  function check(code) {\n    return regex.test(fromCharCode(code));\n  }\n}\n\nmodule.exports = regexCheck;","'use strict';\n\nfunction resolveAll(constructs, events, context) {\n  var called = [];\n  var index = -1;\n  var resolve;\n\n  while (++index < constructs.length) {\n    resolve = constructs[index].resolveAll;\n\n    if (resolve && called.indexOf(resolve) < 0) {\n      events = resolve(events, context);\n      called.push(resolve);\n    }\n  }\n\n  return events;\n}\n\nmodule.exports = resolveAll;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nfunction safeFromInt(value, base) {\n  var code = parseInt(value, base);\n\n  if ( // C0 except for HT, LF, FF, CR, space\n  code < 9 || code === 11 || code > 13 && code < 32 || // Control character (DEL) of the basic block and C1 controls.\n  code > 126 && code < 160 || // Lone high surrogates and low surrogates.\n  code > 55295 && code < 57344 || // Noncharacters.\n  code > 64975 && code < 65008 || (code & 65535) === 65535 || (code & 65535) === 65534 || // Out of range\n  code > 1114111) {\n    return \"\\uFFFD\";\n  }\n\n  return fromCharCode(code);\n}\n\nmodule.exports = safeFromInt;","'use strict';\n\nvar fromCharCode = require('../constant/from-char-code.js');\n\nfunction serializeChunks(chunks) {\n  var index = -1;\n  var result = [];\n  var chunk;\n  var value;\n  var atTab;\n\n  while (++index < chunks.length) {\n    chunk = chunks[index];\n\n    if (typeof chunk === 'string') {\n      value = chunk;\n    } else if (chunk === -5) {\n      value = '\\r';\n    } else if (chunk === -4) {\n      value = '\\n';\n    } else if (chunk === -3) {\n      value = '\\r' + '\\n';\n    } else if (chunk === -2) {\n      value = '\\t';\n    } else if (chunk === -1) {\n      if (atTab) continue;\n      value = ' ';\n    } else {\n      // Currently only replacement character.\n      value = fromCharCode(chunk);\n    }\n\n    atTab = chunk === -2;\n    result.push(value);\n  }\n\n  return result.join('');\n}\n\nmodule.exports = serializeChunks;","'use strict';\n\nvar assign = require('../constant/assign.js');\n\nfunction shallow(object) {\n  return assign({}, object);\n}\n\nmodule.exports = shallow;","'use strict'; // Counts tabs based on their expanded size, and CR+LF as one character.\n\nfunction sizeChunks(chunks) {\n  var index = -1;\n  var size = 0;\n\n  while (++index < chunks.length) {\n    size += typeof chunks[index] === 'string' ? chunks[index].length : 1;\n  }\n\n  return size;\n}\n\nmodule.exports = sizeChunks;","'use strict';\n\nfunction sliceChunks(chunks, token) {\n  var startIndex = token.start._index;\n  var startBufferIndex = token.start._bufferIndex;\n  var endIndex = token.end._index;\n  var endBufferIndex = token.end._bufferIndex;\n  var view;\n\n  if (startIndex === endIndex) {\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n\n    if (startBufferIndex > -1) {\n      view[0] = view[0].slice(startBufferIndex);\n    }\n\n    if (endBufferIndex > 0) {\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n\n  return view;\n}\n\nmodule.exports = sliceChunks;","'use strict';\n\nvar assign = require('../constant/assign.js');\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nvar shallow = require('./shallow.js');\n\nfunction subtokenize(events) {\n  var jumps = {};\n  var index = -1;\n  var event;\n  var lineIndex;\n  var otherIndex;\n  var otherEvent;\n  var parameters;\n  var subevents;\n  var more;\n\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\n    }\n\n    event = events[index]; // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n\n    if (index && event[1].type === 'chunkFlow' && events[index - 1][1].type === 'listItemPrefix') {\n      subevents = event[1]._tokenizer.events;\n      otherIndex = 0;\n\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === 'lineEndingBlank') {\n        otherIndex += 2;\n      }\n\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === 'content') {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break;\n          }\n\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1].isInFirstContentOfListItem = true;\n            otherIndex++;\n          }\n        }\n      }\n    } // Enter.\n\n\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        assign(jumps, subcontent(events, index));\n        index = jumps[index];\n        more = true;\n      }\n    } // Exit.\n    else if (event[1]._container || event[1]._movePreviousLineEndings) {\n        otherIndex = index;\n        lineIndex = undefined;\n\n        while (otherIndex--) {\n          otherEvent = events[otherIndex];\n\n          if (otherEvent[1].type === 'lineEnding' || otherEvent[1].type === 'lineEndingBlank') {\n            if (otherEvent[0] === 'enter') {\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank';\n              }\n\n              otherEvent[1].type = 'lineEnding';\n              lineIndex = otherIndex;\n            }\n          } else {\n            break;\n          }\n        }\n\n        if (lineIndex) {\n          // Fix position.\n          event[1].end = shallow(events[lineIndex][1].start); // Switch container exit w/ line endings.\n\n          parameters = events.slice(lineIndex, index);\n          parameters.unshift(event);\n          chunkedSplice(events, lineIndex, index - lineIndex + 1, parameters);\n        }\n      }\n  }\n\n  return !more;\n}\n\nfunction subcontent(events, eventIndex) {\n  var token = events[eventIndex][1];\n  var context = events[eventIndex][2];\n  var startPosition = eventIndex - 1;\n  var startPositions = [];\n  var tokenizer = token._tokenizer || context.parser[token.contentType](token.start);\n  var childEvents = tokenizer.events;\n  var jumps = [];\n  var gaps = {};\n  var stream;\n  var previous;\n  var index;\n  var entered;\n  var end;\n  var adjust; // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n\n  while (token) {\n    // Find the position of the event for this token.\n    while (events[++startPosition][1] !== token) {// Empty.\n    }\n\n    startPositions.push(startPosition);\n\n    if (!token._tokenizer) {\n      stream = context.sliceStream(token);\n\n      if (!token.next) {\n        stream.push(null);\n      }\n\n      if (previous) {\n        tokenizer.defineSkip(token.start);\n      }\n\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n\n      tokenizer.write(stream);\n\n      if (token.isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined;\n      }\n    } // Unravel the next token.\n\n\n    previous = token;\n    token = token.next;\n  } // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n\n\n  token = previous;\n  index = childEvents.length;\n\n  while (index--) {\n    // Make sure we’ve at least seen something (final eol is part of the last\n    // token).\n    if (childEvents[index][0] === 'enter') {\n      entered = true;\n    } else if ( // Find a void token that includes a break.\n    entered && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {\n      add(childEvents.slice(index + 1, end)); // Help GC.\n\n      token._tokenizer = token.next = undefined;\n      token = token.previous;\n      end = index + 1;\n    }\n  } // Help GC.\n\n\n  tokenizer.events = token._tokenizer = token.next = undefined; // Do head:\n\n  add(childEvents.slice(0, end));\n  index = -1;\n  adjust = 0;\n\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];\n    adjust += jumps[index][1] - jumps[index][0] - 1;\n  }\n\n  return gaps;\n\n  function add(slice) {\n    var start = startPositions.pop();\n    jumps.unshift([start, start + slice.length - 1]);\n    chunkedSplice(events, start, 2, slice);\n  }\n}\n\nmodule.exports = subtokenize;","'use strict';\n/* eslint-env browser */\n\nvar el;\nvar semicolon = 59; //  ';'\n\nmodule.exports = decodeEntity;\n\nfunction decodeEntity(characters) {\n  var entity = '&' + characters + ';';\n  var char;\n  el = el || document.createElement('i');\n  el.innerHTML = entity;\n  char = el.textContent; // Some entities do not require the closing semicolon (`&not` - for instance),\n  // which leads to situations where parsing the assumed entity of &notit; will\n  // result in the string `¬it;`.  When we encounter a trailing semicolon after\n  // parsing and the entity to decode was not a semicolon (`&semi;`), we can\n  // assume that the matching was incomplete\n\n  if (char.charCodeAt(char.length - 1) === semicolon && characters !== 'semi') {\n    return false;\n  } // If the decoded string is equal to the input, the entity was not valid\n\n\n  return char === entity ? false : char;\n}","'use strict';\n\nvar React = require('react');\n\nvar xtend = require('xtend');\n\nvar ReactIs = require('react-is');\n\nfunction astToReact(node, options) {\n  var parent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n  var renderer = options.renderers[node.type]; // Nodes created by plugins do not have positional info, in which case we set\n  // an object that matches the positon interface.\n\n  if (!node.position) {\n    node.position = {\n      start: {\n        line: null,\n        column: null,\n        offset: null\n      },\n      end: {\n        line: null,\n        column: null,\n        offset: null\n      }\n    };\n  }\n\n  var pos = node.position.start;\n  var key = [node.type, pos.line, pos.column, index].join('-');\n\n  if (!ReactIs.isValidElementType(renderer)) {\n    throw new Error(\"Renderer for type `\".concat(node.type, \"` not defined or is not renderable\"));\n  }\n\n  var nodeProps = getNodeProps(node, key, options, renderer, parent, index);\n  return React.createElement(renderer, nodeProps, nodeProps.children || resolveChildren() || undefined);\n\n  function resolveChildren() {\n    return node.children && node.children.map(function (childNode, i) {\n      return astToReact(childNode, options, {\n        node: node,\n        props: nodeProps\n      }, i);\n    });\n  }\n} // eslint-disable-next-line max-params, complexity\n\n\nfunction getNodeProps(node, key, opts, renderer, parent, index) {\n  var props = {\n    key: key\n  };\n  var isSimpleRenderer = typeof renderer === 'string' || renderer === React.Fragment; // `sourcePos` is true if the user wants source information (line/column info from markdown source)\n\n  if (opts.sourcePos && node.position) {\n    props['data-sourcepos'] = flattenPosition(node.position);\n  }\n\n  if (opts.rawSourcePos && !isSimpleRenderer) {\n    props.sourcePosition = node.position;\n  } // If `includeNodeIndex` is true, pass node index info to all non-tag renderers\n\n\n  if (opts.includeNodeIndex && parent.node && parent.node.children && !isSimpleRenderer) {\n    props.index = parent.node.children.indexOf(node);\n    props.parentChildCount = parent.node.children.length;\n  }\n\n  var ref = node.identifier !== null && node.identifier !== undefined ?\n  /* istanbul ignore next - plugins could inject an undefined reference. */\n  opts.definitions[node.identifier.toUpperCase()] || {} : null;\n\n  switch (node.type) {\n    case 'root':\n      assignDefined(props, {\n        className: opts.className\n      });\n      break;\n\n    case 'text':\n      props.nodeKey = key;\n      props.children = node.value;\n      break;\n\n    case 'heading':\n      props.level = node.depth;\n      break;\n\n    case 'list':\n      props.start = node.start;\n      props.ordered = node.ordered;\n      props.spread = node.spread;\n      props.depth = node.depth;\n      break;\n\n    case 'listItem':\n      props.checked = node.checked;\n      props.spread = node.spread;\n      props.ordered = node.ordered;\n      props.index = node.index;\n      props.children = getListItemChildren(node, parent).map(function (childNode, i) {\n        return astToReact(childNode, opts, {\n          node: node,\n          props: props\n        }, i);\n      });\n      break;\n\n    case 'definition':\n      assignDefined(props, {\n        identifier: node.identifier,\n        title: node.title,\n        url: node.url\n      });\n      break;\n\n    case 'code':\n      assignDefined(props, {\n        language: node.lang && node.lang.split(/\\s/, 1)[0]\n      });\n      break;\n\n    case 'inlineCode':\n      props.children = node.value;\n      props.inline = true;\n      break;\n\n    case 'link':\n      assignDefined(props, {\n        title: node.title || undefined,\n        target: typeof opts.linkTarget === 'function' ? opts.linkTarget(node.url, node.children, node.title) : opts.linkTarget,\n        href: opts.transformLinkUri ? opts.transformLinkUri(node.url, node.children, node.title) : node.url\n      });\n      break;\n\n    case 'image':\n      assignDefined(props, {\n        src: opts.transformImageUri ? opts.transformImageUri(node.url, node.children, node.title, node.alt) : node.url,\n        alt: node.alt || '',\n        title: node.title || undefined\n      });\n      break;\n\n    case 'linkReference':\n      assignDefined(props, xtend(ref, {\n        href: opts.transformLinkUri ? opts.transformLinkUri(ref.href) : ref.href\n      }));\n      break;\n\n    case 'imageReference':\n      assignDefined(props, {\n        src: opts.transformImageUri && ref.href ? opts.transformImageUri(ref.href, node.children, ref.title, node.alt) : ref.href,\n        alt: node.alt || '',\n        title: ref.title || undefined\n      });\n      break;\n\n    case 'table':\n    case 'tableHead':\n    case 'tableBody':\n      props.columnAlignment = node.align;\n      break;\n\n    case 'tableRow':\n      props.isHeader = parent.node.type === 'tableHead';\n      props.columnAlignment = parent.props.columnAlignment;\n      break;\n\n    case 'tableCell':\n      assignDefined(props, {\n        isHeader: parent.props.isHeader,\n        align: parent.props.columnAlignment[index]\n      });\n      break;\n\n    case 'virtualHtml':\n      props.tag = node.tag;\n      break;\n\n    case 'html':\n      // @todo find a better way than this\n      props.isBlock = node.position.start.line !== node.position.end.line;\n      props.allowDangerousHtml = opts.allowDangerousHtml;\n      props.escapeHtml = opts.escapeHtml;\n      props.skipHtml = opts.skipHtml;\n      break;\n\n    case 'parsedHtml':\n      {\n        var parsedChildren;\n\n        if (node.children) {\n          parsedChildren = node.children.map(function (child, i) {\n            return astToReact(child, opts, {\n              node: node,\n              props: props\n            }, i);\n          });\n        }\n\n        props.allowDangerousHtml = opts.allowDangerousHtml;\n        props.escapeHtml = opts.escapeHtml;\n        props.skipHtml = opts.skipHtml;\n        props.element = node.element ? mergeNodeChildren(node, parsedChildren) : null;\n        break;\n      }\n\n    default:\n      assignDefined(props, xtend(node, {\n        type: undefined,\n        position: undefined,\n        children: undefined\n      }));\n  }\n\n  if (!isSimpleRenderer && node.value) {\n    props.value = node.value;\n  }\n\n  if (!isSimpleRenderer) {\n    props.node = node;\n  }\n\n  return props;\n}\n\nfunction assignDefined(target, attrs) {\n  for (var key in attrs) {\n    if (typeof attrs[key] !== 'undefined') {\n      target[key] = attrs[key];\n    }\n  }\n}\n\nfunction mergeNodeChildren(node, parsedChildren) {\n  var el = node.element;\n\n  if (Array.isArray(el)) {\n    /* istanbul ignore next - `div` fallback for old React. */\n    var Fragment = React.Fragment || 'div';\n    return React.createElement(Fragment, null, el);\n  }\n\n  if (el.props.children || parsedChildren) {\n    var children = React.Children.toArray(el.props.children).concat(parsedChildren);\n    return React.cloneElement(el, null, children);\n  }\n\n  return React.cloneElement(el, null);\n}\n\nfunction flattenPosition(pos) {\n  return [pos.start.line, ':', pos.start.column, '-', pos.end.line, ':', pos.end.column].map(String).join('');\n}\n\nfunction getListItemChildren(node, parent) {\n  /* istanbul ignore next - list items are always in a list, but best to be sure. */\n  var loose = parent && parent.node ? listLoose(parent.node) : listItemLoose(node);\n  return loose ? node.children : unwrapParagraphs(node);\n}\n\nfunction unwrapParagraphs(node) {\n  return node.children.reduce(function (array, child) {\n    return array.concat(child.type === 'paragraph' ? child.children : [child]);\n  }, []);\n}\n\nfunction listLoose(node) {\n  var children = node.children;\n  var loose = node.spread;\n  var index = -1;\n\n  while (!loose && ++index < children.length) {\n    loose = listItemLoose(children[index]);\n  }\n\n  return loose;\n}\n\nfunction listItemLoose(node) {\n  var spread = node.spread;\n  /* istanbul ignore next - spread is present from remark-parse, but maybe plugins don’t set it. */\n\n  return spread === undefined || spread === null ? node.children.length > 1 : spread;\n}\n\nmodule.exports = astToReact;","'use strict';\n\nvar visit = require('unist-util-visit');\n\nmodule.exports = function getDefinitions(tree) {\n  var definitions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  visit(tree, 'definition', function (node) {\n    var identifier = node.identifier.toUpperCase();\n    if (identifier in definitions) return;\n    definitions[identifier] = {\n      href: node.url,\n      title: node.title\n    };\n  });\n  return definitions;\n};","\"use strict\";\n\nvar visit = require('unist-util-visit');\n\nvar splice = [].splice;\n\nexports.ofType = function (types, mode) {\n  return ifNotMatch(allow, mode);\n\n  function allow(node, index, parent) {\n    return !types.includes(node.type);\n  }\n};\n\nexports.ifNotMatch = ifNotMatch;\n\nfunction ifNotMatch(allow, mode) {\n  return transform;\n\n  function transform(tree) {\n    visit(tree, filter);\n    return tree;\n  } // eslint-disable-next-line consistent-return\n\n\n  function filter(node, index, parent) {\n    if (parent && !allow(node, index, parent)) {\n      var parameters = [index, 1];\n\n      if (mode === 'unwrap' && node.children) {\n        parameters = parameters.concat(node.children);\n      }\n\n      splice.apply(parent.children, parameters);\n      return index;\n    }\n  }\n}","\"use strict\";\n/**\n * Naive, simple plugin to match inline nodes without attributes\n * This allows say <strong>foo</strong>, but not <strong class=\"very\">foo</strong>\n * For proper HTML support, you'll want a different plugin\n **/\n\nvar visit = require('unist-util-visit');\n\nvar type = 'virtualHtml';\nvar selfClosingRe = /^<(area|base|br|col|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)\\s*\\/?>$/i;\nvar simpleTagRe = /^<(\\/?)([a-z]+)\\s*>$/;\n\nmodule.exports = function (tree) {\n  var open;\n  var currentParent;\n  visit(tree, 'html', function (node, index, parent) {\n    if (currentParent !== parent) {\n      open = [];\n      currentParent = parent;\n    }\n\n    var selfClosing = getSelfClosing(node);\n\n    if (selfClosing) {\n      parent.children.splice(index, 1, {\n        type: type,\n        tag: selfClosing,\n        position: node.position\n      });\n      return true;\n    }\n\n    var current = getSimpleTag(node, parent);\n\n    if (!current) {\n      return true;\n    }\n\n    var matching = findAndPull(open, current.tag);\n\n    if (matching) {\n      parent.children.splice(index, 0, virtual(current, matching, parent));\n    } else if (!current.opening) {\n      open.push(current);\n    }\n\n    return true;\n  }, true // Iterate in reverse\n  );\n  return tree;\n};\n\nfunction findAndPull(open, matchingTag) {\n  var i = open.length;\n\n  while (i--) {\n    if (open[i].tag === matchingTag) {\n      return open.splice(i, 1)[0];\n    }\n  }\n\n  return false;\n}\n\nfunction getSimpleTag(node, parent) {\n  var match = node.value.match(simpleTagRe);\n  return match ? {\n    tag: match[2],\n    opening: !match[1],\n    node: node\n  } : false;\n}\n\nfunction getSelfClosing(node) {\n  var match = node.value.match(selfClosingRe);\n  return match ? match[1] : false;\n}\n\nfunction virtual(fromNode, toNode, parent) {\n  var fromIndex = parent.children.indexOf(fromNode.node);\n  var toIndex = parent.children.indexOf(toNode.node);\n  var extracted = parent.children.splice(fromIndex, toIndex - fromIndex + 1);\n  var children = extracted.slice(1, -1);\n  return {\n    type: type,\n    children: children,\n    tag: fromNode.tag,\n    position: {\n      start: fromNode.node.position.start,\n      end: toNode.node.position.end,\n      indent: []\n    }\n  };\n}","'use strict';\n\nvar xtend = require('xtend');\n\nvar unified = require('unified');\n\nvar parse = require('remark-parse');\n\nvar PropTypes = require('prop-types');\n\nvar addListMetadata = require('mdast-add-list-metadata');\n\nvar naiveHtml = require('./plugins/naive-html');\n\nvar disallowNode = require('./plugins/disallow-node');\n\nvar astToReact = require('./ast-to-react');\n\nvar wrapTableRows = require('./wrap-table-rows');\n\nvar getDefinitions = require('./get-definitions');\n\nvar uriTransformer = require('./uri-transformer');\n\nvar defaultRenderers = require('./renderers');\n\nvar symbols = require('./symbols');\n\nvar allTypes = Object.keys(defaultRenderers);\n\nvar ReactMarkdown = function ReactMarkdown(props) {\n  // To do in next major: remove `source`.\n  var src = props.source || props.children || '';\n\n  if (props.allowedTypes && props.disallowedTypes) {\n    throw new Error('Only one of `allowedTypes` and `disallowedTypes` should be defined');\n  }\n\n  var renderers = xtend(defaultRenderers, props.renderers);\n  var processor = unified().use(parse).use(props.plugins || []); // eslint-disable-next-line no-sync\n\n  var tree = processor.runSync(processor.parse(src));\n  var renderProps = xtend(props, {\n    renderers: renderers,\n    definitions: getDefinitions(tree)\n  });\n  determineAstToReactTransforms(props).forEach(function (transform) {\n    tree = transform(tree, renderProps);\n  });\n  return tree;\n};\n\nfunction determineAstToReactTransforms(props) {\n  var transforms = [wrapTableRows, addListMetadata()];\n  var disallowedTypes = props.disallowedTypes;\n\n  if (props.allowedTypes) {\n    disallowedTypes = allTypes.filter(function (type) {\n      return type !== 'root' && props.allowedTypes.indexOf(type) === -1;\n    });\n  }\n\n  var removalMethod = props.unwrapDisallowed ? 'unwrap' : 'remove';\n\n  if (disallowedTypes && disallowedTypes.length > 0) {\n    transforms.push(disallowNode.ofType(disallowedTypes, removalMethod));\n  }\n\n  if (props.allowNode) {\n    transforms.push(disallowNode.ifNotMatch(props.allowNode, removalMethod));\n  } // To do in next major: remove `escapeHtml`.\n\n\n  var renderHtml = (props.allowDangerousHtml || props.escapeHtml === false) && !props.skipHtml;\n  var hasHtmlParser = (props.astPlugins || []).some(function (transform) {\n    return transform.identity === symbols.HtmlParser;\n  });\n\n  if (renderHtml && !hasHtmlParser) {\n    transforms.push(naiveHtml);\n  }\n\n  if (props.astPlugins) {\n    transforms = transforms.concat(props.astPlugins);\n  } // Add the final transform to turn everything into React.\n\n\n  transforms.push(astToReact);\n  return transforms;\n}\n\nReactMarkdown.defaultProps = {\n  transformLinkUri: uriTransformer\n};\nReactMarkdown.propTypes = {\n  className: PropTypes.string,\n  source: PropTypes.string,\n  children: PropTypes.string,\n  sourcePos: PropTypes.bool,\n  rawSourcePos: PropTypes.bool,\n  escapeHtml: PropTypes.bool,\n  allowDangerousHtml: PropTypes.bool,\n  skipHtml: PropTypes.bool,\n  allowNode: PropTypes.func,\n  allowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  disallowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n  linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  transformImageUri: PropTypes.func,\n  astPlugins: PropTypes.arrayOf(PropTypes.func),\n  unwrapDisallowed: PropTypes.bool,\n  renderers: PropTypes.object,\n  plugins: PropTypes.array\n};\nReactMarkdown.types = allTypes;\nReactMarkdown.renderers = defaultRenderers;\nReactMarkdown.uriTransformer = uriTransformer;\nmodule.exports = ReactMarkdown;","/* eslint-disable react/prop-types, react/no-multi-comp */\n'use strict';\n\nvar xtend = require('xtend');\n\nvar React = require('react');\n/* istanbul ignore next - Don’t crash on old React. */\n\n\nvar supportsStringRender = parseInt((React.version || '16').slice(0, 2), 10) >= 16;\nvar createElement = React.createElement;\nmodule.exports = {\n  break: 'br',\n  paragraph: 'p',\n  emphasis: 'em',\n  strong: 'strong',\n  thematicBreak: 'hr',\n  blockquote: 'blockquote',\n  delete: 'del',\n  link: 'a',\n  image: 'img',\n  linkReference: 'a',\n  imageReference: 'img',\n  table: SimpleRenderer.bind(null, 'table'),\n  tableHead: SimpleRenderer.bind(null, 'thead'),\n  tableBody: SimpleRenderer.bind(null, 'tbody'),\n  tableRow: SimpleRenderer.bind(null, 'tr'),\n  tableCell: TableCell,\n  root: Root,\n  text: TextRenderer,\n  list: List,\n  listItem: ListItem,\n  definition: NullRenderer,\n  heading: Heading,\n  inlineCode: InlineCode,\n  code: CodeBlock,\n  html: Html,\n  virtualHtml: VirtualHtml,\n  parsedHtml: ParsedHtml\n};\n\nfunction TextRenderer(props) {\n  /* istanbul ignore next - a text node w/o a value could be injected by plugins */\n  var children = props.children || '';\n  /* istanbul ignore next - `span` is a fallback for old React. */\n\n  return supportsStringRender ? children : createElement('span', null, children);\n}\n\nfunction Root(props) {\n  var className = props.className;\n  var root = !className && React.Fragment || 'div';\n  return createElement(root, className ? {\n    className: className\n  } : null, props.children);\n}\n\nfunction SimpleRenderer(tag, props) {\n  return createElement(tag, getCoreProps(props), props.children);\n}\n\nfunction TableCell(props) {\n  var style = props.align ? {\n    textAlign: props.align\n  } : undefined;\n  var coreProps = getCoreProps(props);\n  return createElement(props.isHeader ? 'th' : 'td', style ? xtend({\n    style: style\n  }, coreProps) : coreProps, props.children);\n}\n\nfunction Heading(props) {\n  return createElement(\"h\".concat(props.level), getCoreProps(props), props.children);\n}\n\nfunction List(props) {\n  var attrs = getCoreProps(props);\n\n  if (props.start !== null && props.start !== 1 && props.start !== undefined) {\n    attrs.start = props.start.toString();\n  }\n\n  return createElement(props.ordered ? 'ol' : 'ul', attrs, props.children);\n}\n\nfunction ListItem(props) {\n  var checkbox = null;\n\n  if (props.checked !== null && props.checked !== undefined) {\n    var checked = props.checked;\n    checkbox = createElement('input', {\n      type: 'checkbox',\n      checked: checked,\n      readOnly: true\n    });\n  }\n\n  return createElement('li', getCoreProps(props), checkbox, props.children);\n}\n\nfunction CodeBlock(props) {\n  var className = props.language && \"language-\".concat(props.language);\n  var code = createElement('code', className ? {\n    className: className\n  } : null, props.value);\n  return createElement('pre', getCoreProps(props), code);\n}\n\nfunction InlineCode(props) {\n  return createElement('code', getCoreProps(props), props.children);\n}\n\nfunction Html(props) {\n  if (props.skipHtml) {\n    return null;\n  }\n\n  var dangerous = props.allowDangerousHtml || props.escapeHtml === false;\n  var tag = props.isBlock ? 'div' : 'span';\n\n  if (!dangerous) {\n    /* istanbul ignore next - `tag` is a fallback for old React. */\n    return createElement(React.Fragment || tag, null, props.value);\n  }\n\n  var nodeProps = {\n    dangerouslySetInnerHTML: {\n      __html: props.value\n    }\n  };\n  return createElement(tag, nodeProps);\n}\n\nfunction ParsedHtml(props) {\n  /* To do: `React.cloneElement` is slow, is it really needed? */\n  return props['data-sourcepos'] ? React.cloneElement(props.element, {\n    'data-sourcepos': props['data-sourcepos']\n  }) : props.element;\n}\n\nfunction VirtualHtml(props) {\n  return createElement(props.tag, getCoreProps(props), props.children);\n}\n\nfunction NullRenderer() {\n  return null;\n}\n\nfunction getCoreProps(props) {\n  var source = props['data-sourcepos'];\n  /* istanbul ignore next - nodes from plugins w/o position */\n\n  return source ? {\n    'data-sourcepos': source\n  } : {};\n}","\"use strict\";\n\nvar HtmlParser = '__RMD_HTML_PARSER__';\n/* istanbul ignore next - Fallback for `Symbol`. */\n\nexports.HtmlParser = typeof Symbol === 'undefined' ? HtmlParser : Symbol(HtmlParser);","\"use strict\";\n\nvar protocols = ['http', 'https', 'mailto', 'tel'];\n\nmodule.exports = function uriTransformer(uri) {\n  var url = (uri || '').trim();\n  var first = url.charAt(0);\n\n  if (first === '#' || first === '/') {\n    return url;\n  }\n\n  var colon = url.indexOf(':');\n\n  if (colon === -1) {\n    return url;\n  }\n\n  var length = protocols.length;\n  var index = -1;\n\n  while (++index < length) {\n    var protocol = protocols[index];\n\n    if (colon === protocol.length && url.slice(0, protocol.length).toLowerCase() === protocol) {\n      return url;\n    }\n  }\n\n  index = url.indexOf('?');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  }\n\n  index = url.indexOf('#');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  } // eslint-disable-next-line no-script-url\n\n\n  return 'javascript:void(0)';\n};","'use strict';\n\nvar visit = require('unist-util-visit');\n\nmodule.exports = function (node) {\n  visit(node, 'table', wrap);\n  return node;\n};\n\nfunction wrap(table) {\n  var children = table.children;\n  table.children = [{\n    type: 'tableHead',\n    align: table.align,\n    children: [children[0]],\n    position: children[0].position\n  }];\n\n  if (children.length > 1) {\n    table.children.push({\n      type: 'tableBody',\n      align: table.align,\n      children: children.slice(1),\n      position: {\n        start: children[1].position.start,\n        end: children[children.length - 1].position.end\n      }\n    });\n  }\n}","'use strict';\n\nmodule.exports = parse;\n\nvar fromMarkdown = require('mdast-util-from-markdown');\n\nfunction parse(options) {\n  var self = this;\n  this.Parser = parse;\n\n  function parse(doc) {\n    return fromMarkdown(doc, Object.assign({}, self.data('settings'), options, {\n      // Note: these options are not in the readme.\n      // The goal is for them to be set by plugins on `data` instead of being\n      // passed by users.\n      extensions: self.data('micromarkExtensions') || [],\n      mdastExtensions: self.data('fromMarkdownExtensions') || []\n    }));\n  }\n}","'use strict';\n\nvar bail = require('bail');\n\nvar buffer = require('is-buffer');\n\nvar extend = require('extend');\n\nvar plain = require('is-plain-obj');\n\nvar trough = require('trough');\n\nvar vfile = require('vfile'); // Expose a frozen processor.\n\n\nmodule.exports = unified().freeze();\nvar slice = [].slice;\nvar own = {}.hasOwnProperty; // Process pipeline.\n\nvar pipeline = trough().use(pipelineParse).use(pipelineRun).use(pipelineStringify);\n\nfunction pipelineParse(p, ctx) {\n  ctx.tree = p.parse(ctx.file);\n}\n\nfunction pipelineRun(p, ctx, next) {\n  p.run(ctx.tree, ctx.file, done);\n\n  function done(error, tree, file) {\n    if (error) {\n      next(error);\n    } else {\n      ctx.tree = tree;\n      ctx.file = file;\n      next();\n    }\n  }\n}\n\nfunction pipelineStringify(p, ctx) {\n  var result = p.stringify(ctx.tree, ctx.file);\n\n  if (result === undefined || result === null) {// Empty.\n  } else if (typeof result === 'string' || buffer(result)) {\n    ctx.file.contents = result;\n  } else {\n    ctx.file.result = result;\n  }\n} // Function to create the first processor.\n\n\nfunction unified() {\n  var attachers = [];\n  var transformers = trough();\n  var namespace = {};\n  var freezeIndex = -1;\n  var frozen; // Data management.\n\n  processor.data = data; // Lock.\n\n  processor.freeze = freeze; // Plugins.\n\n  processor.attachers = attachers;\n  processor.use = use; // API.\n\n  processor.parse = parse;\n  processor.stringify = stringify;\n  processor.run = run;\n  processor.runSync = runSync;\n  processor.process = process;\n  processor.processSync = processSync; // Expose.\n\n  return processor; // Create a new processor based on the processor in the current scope.\n\n  function processor() {\n    var destination = unified();\n    var index = -1;\n\n    while (++index < attachers.length) {\n      destination.use.apply(null, attachers[index]);\n    }\n\n    destination.data(extend(true, {}, namespace));\n    return destination;\n  } // Freeze: used to signal a processor that has finished configuration.\n  //\n  // For example, take unified itself: it’s frozen.\n  // Plugins should not be added to it.\n  // Rather, it should be extended, by invoking it, before modifying it.\n  //\n  // In essence, always invoke this when exporting a processor.\n\n\n  function freeze() {\n    var values;\n    var transformer;\n\n    if (frozen) {\n      return processor;\n    }\n\n    while (++freezeIndex < attachers.length) {\n      values = attachers[freezeIndex];\n\n      if (values[1] === false) {\n        continue;\n      }\n\n      if (values[1] === true) {\n        values[1] = undefined;\n      }\n\n      transformer = values[0].apply(processor, values.slice(1));\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer);\n      }\n    }\n\n    frozen = true;\n    freezeIndex = Infinity;\n    return processor;\n  } // Data management.\n  // Getter / setter for processor-specific informtion.\n\n\n  function data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen);\n        namespace[key] = value;\n        return processor;\n      } // Get `key`.\n\n\n      return own.call(namespace, key) && namespace[key] || null;\n    } // Set space.\n\n\n    if (key) {\n      assertUnfrozen('data', frozen);\n      namespace = key;\n      return processor;\n    } // Get space.\n\n\n    return namespace;\n  } // Plugin management.\n  //\n  // Pass it:\n  // *   an attacher and options,\n  // *   a preset,\n  // *   a list of presets, attachers, and arguments (list of attachers and\n  //     options).\n\n\n  function use(value) {\n    var settings;\n    assertUnfrozen('use', frozen);\n\n    if (value === null || value === undefined) {// Empty.\n    } else if (typeof value === 'function') {\n      addPlugin.apply(null, arguments);\n    } else if (typeof value === 'object') {\n      if ('length' in value) {\n        addList(value);\n      } else {\n        addPreset(value);\n      }\n    } else {\n      throw new Error('Expected usable value, not `' + value + '`');\n    }\n\n    if (settings) {\n      namespace.settings = extend(namespace.settings || {}, settings);\n    }\n\n    return processor;\n\n    function addPreset(result) {\n      addList(result.plugins);\n\n      if (result.settings) {\n        settings = extend(settings || {}, result.settings);\n      }\n    }\n\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value);\n      } else if (typeof value === 'object') {\n        if ('length' in value) {\n          addPlugin.apply(null, value);\n        } else {\n          addPreset(value);\n        }\n      } else {\n        throw new Error('Expected usable value, not `' + value + '`');\n      }\n    }\n\n    function addList(plugins) {\n      var index = -1;\n\n      if (plugins === null || plugins === undefined) {// Empty.\n      } else if (typeof plugins === 'object' && 'length' in plugins) {\n        while (++index < plugins.length) {\n          add(plugins[index]);\n        }\n      } else {\n        throw new Error('Expected a list of plugins, not `' + plugins + '`');\n      }\n    }\n\n    function addPlugin(plugin, value) {\n      var entry = find(plugin);\n\n      if (entry) {\n        if (plain(entry[1]) && plain(value)) {\n          value = extend(true, entry[1], value);\n        }\n\n        entry[1] = value;\n      } else {\n        attachers.push(slice.call(arguments));\n      }\n    }\n  }\n\n  function find(plugin) {\n    var index = -1;\n\n    while (++index < attachers.length) {\n      if (attachers[index][0] === plugin) {\n        return attachers[index];\n      }\n    }\n  } // Parse a file (in string or vfile representation) into a unist node using\n  // the `Parser` on the processor.\n\n\n  function parse(doc) {\n    var file = vfile(doc);\n    var Parser;\n    freeze();\n    Parser = processor.Parser;\n    assertParser('parse', Parser);\n\n    if (newable(Parser, 'parse')) {\n      return new Parser(String(file), file).parse();\n    }\n\n    return Parser(String(file), file); // eslint-disable-line new-cap\n  } // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), async.\n\n\n  function run(node, file, cb) {\n    assertNode(node);\n    freeze();\n\n    if (!cb && typeof file === 'function') {\n      cb = file;\n      file = null;\n    }\n\n    if (!cb) {\n      return new Promise(executor);\n    }\n\n    executor(null, cb);\n\n    function executor(resolve, reject) {\n      transformers.run(node, vfile(file), done);\n\n      function done(error, tree, file) {\n        tree = tree || node;\n\n        if (error) {\n          reject(error);\n        } else if (resolve) {\n          resolve(tree);\n        } else {\n          cb(null, tree, file);\n        }\n      }\n    }\n  } // Run transforms on a unist node representation of a file (in string or\n  // vfile representation), sync.\n\n\n  function runSync(node, file) {\n    var result;\n    var complete;\n    run(node, file, done);\n    assertDone('runSync', 'run', complete);\n    return result;\n\n    function done(error, tree) {\n      complete = true;\n      result = tree;\n      bail(error);\n    }\n  } // Stringify a unist node representation of a file (in string or vfile\n  // representation) into a string using the `Compiler` on the processor.\n\n\n  function stringify(node, doc) {\n    var file = vfile(doc);\n    var Compiler;\n    freeze();\n    Compiler = processor.Compiler;\n    assertCompiler('stringify', Compiler);\n    assertNode(node);\n\n    if (newable(Compiler, 'compile')) {\n      return new Compiler(node, file).compile();\n    }\n\n    return Compiler(node, file); // eslint-disable-line new-cap\n  } // Parse a file (in string or vfile representation) into a unist node using\n  // the `Parser` on the processor, then run transforms on that node, and\n  // compile the resulting node using the `Compiler` on the processor, and\n  // store that result on the vfile.\n\n\n  function process(doc, cb) {\n    freeze();\n    assertParser('process', processor.Parser);\n    assertCompiler('process', processor.Compiler);\n\n    if (!cb) {\n      return new Promise(executor);\n    }\n\n    executor(null, cb);\n\n    function executor(resolve, reject) {\n      var file = vfile(doc);\n      pipeline.run(processor, {\n        file: file\n      }, done);\n\n      function done(error) {\n        if (error) {\n          reject(error);\n        } else if (resolve) {\n          resolve(file);\n        } else {\n          cb(null, file);\n        }\n      }\n    }\n  } // Process the given document (in string or vfile representation), sync.\n\n\n  function processSync(doc) {\n    var file;\n    var complete;\n    freeze();\n    assertParser('processSync', processor.Parser);\n    assertCompiler('processSync', processor.Compiler);\n    file = vfile(doc);\n    process(file, done);\n    assertDone('processSync', 'process', complete);\n    return file;\n\n    function done(error) {\n      complete = true;\n      bail(error);\n    }\n  }\n} // Check if `value` is a constructor.\n\n\nfunction newable(value, name) {\n  return typeof value === 'function' && value.prototype && ( // A function with keys in its prototype is probably a constructor.\n  // Classes’ prototype methods are not enumerable, so we check if some value\n  // exists in the prototype.\n  keys(value.prototype) || name in value.prototype);\n} // Check if `value` is an object with keys.\n\n\nfunction keys(value) {\n  var key;\n\n  for (key in value) {\n    return true;\n  }\n\n  return false;\n} // Assert a parser is available.\n\n\nfunction assertParser(name, Parser) {\n  if (typeof Parser !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Parser`');\n  }\n} // Assert a compiler is available.\n\n\nfunction assertCompiler(name, Compiler) {\n  if (typeof Compiler !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Compiler`');\n  }\n} // Assert the processor is not frozen.\n\n\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error('Cannot invoke `' + name + '` on a frozen processor.\\nCreate a new processor first, by invoking it: use `processor()` instead of `processor`.');\n  }\n} // Assert `node` is a unist node.\n\n\nfunction assertNode(node) {\n  if (!node || typeof node.type !== 'string') {\n    throw new Error('Expected node, got `' + node + '`');\n  }\n} // Assert that `complete` is `true`.\n\n\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error('`' + name + '` finished async. Use `' + asyncName + '` instead');\n  }\n}","'use strict';\n\nvar syntax = require('micromark-extension-gfm');\n\nvar fromMarkdown = require('mdast-util-gfm/from-markdown');\n\nvar toMarkdown = require('mdast-util-gfm/to-markdown');\n\nvar warningIssued;\nmodule.exports = gfm;\n\nfunction gfm(options) {\n  var data = this.data();\n  /* istanbul ignore next - old remark. */\n\n  if (!warningIssued && (this.Parser && this.Parser.prototype && this.Parser.prototype.blockTokenizers || this.Compiler && this.Compiler.prototype && this.Compiler.prototype.visitors)) {\n    warningIssued = true;\n    console.warn('[remark-gfm] Warning: please upgrade to remark 13 to use this plugin');\n  }\n\n  add('micromarkExtensions', syntax(options));\n  add('fromMarkdownExtensions', fromMarkdown);\n  add('toMarkdownExtensions', toMarkdown(options));\n\n  function add(field, value) {\n    /* istanbul ignore if - other extensions. */\n    if (data[field]) data[field].push(value);else data[field] = [value];\n  }\n}","/*!\n * repeat-string <https://github.com/jonschlinkert/repeat-string>\n *\n * Copyright (c) 2014-2015, Jon Schlinkert.\n * Licensed under the MIT License.\n */\n'use strict';\n/**\n * Results cache\n */\n\nvar res = '';\nvar cache;\n/**\n * Expose `repeat`\n */\n\nmodule.exports = repeat;\n/**\n * Repeat the given `string` the specified `number`\n * of times.\n *\n * **Example:**\n *\n * ```js\n * var repeat = require('repeat-string');\n * repeat('A', 5);\n * //=> AAAAA\n * ```\n *\n * @param {String} `string` The string to repeat\n * @param {Number} `number` The number of times to repeat the string\n * @return {String} Repeated string\n * @api public\n */\n\nfunction repeat(str, num) {\n  if (typeof str !== 'string') {\n    throw new TypeError('expected a string');\n  } // cover common, quick use cases\n\n\n  if (num === 1) return str;\n  if (num === 2) return str + str;\n  var max = str.length * num;\n\n  if (cache !== str || typeof cache === 'undefined') {\n    cache = str;\n    res = '';\n  } else if (res.length >= max) {\n    return res.substr(0, max);\n  }\n\n  while (max > res.length && num > 1) {\n    if (num & 1) {\n      res += str;\n    }\n\n    num >>= 1;\n    str += str;\n  }\n\n  res += str;\n  res = res.substr(0, max);\n  return res;\n}","'use strict';\n\nvar wrap = require('./wrap.js');\n\nmodule.exports = trough;\ntrough.wrap = wrap;\nvar slice = [].slice; // Create new middleware.\n\nfunction trough() {\n  var fns = [];\n  var middleware = {};\n  middleware.run = run;\n  middleware.use = use;\n  return middleware; // Run `fns`.  Last argument must be a completion handler.\n\n  function run() {\n    var index = -1;\n    var input = slice.call(arguments, 0, -1);\n    var done = arguments[arguments.length - 1];\n\n    if (typeof done !== 'function') {\n      throw new Error('Expected function as last argument, not ' + done);\n    }\n\n    next.apply(null, [null].concat(input)); // Run the next `fn`, if any.\n\n    function next(err) {\n      var fn = fns[++index];\n      var params = slice.call(arguments, 0);\n      var values = params.slice(1);\n      var length = input.length;\n      var pos = -1;\n\n      if (err) {\n        done(err);\n        return;\n      } // Copy non-nully input into values.\n\n\n      while (++pos < length) {\n        if (values[pos] === null || values[pos] === undefined) {\n          values[pos] = input[pos];\n        }\n      }\n\n      input = values; // Next or done.\n\n      if (fn) {\n        wrap(fn, next).apply(null, input);\n      } else {\n        done.apply(null, [null].concat(input));\n      }\n    }\n  } // Add `fn` to the list.\n\n\n  function use(fn) {\n    if (typeof fn !== 'function') {\n      throw new Error('Expected `fn` to be a function, not ' + fn);\n    }\n\n    fns.push(fn);\n    return middleware;\n  }\n}","'use strict';\n\nvar slice = [].slice;\nmodule.exports = wrap; // Wrap `fn`.\n// Can be sync or async; return a promise, receive a completion handler, return\n// new values and errors.\n\nfunction wrap(fn, callback) {\n  var invoked;\n  return wrapped;\n\n  function wrapped() {\n    var params = slice.call(arguments, 0);\n    var callback = fn.length > params.length;\n    var result;\n\n    if (callback) {\n      params.push(done);\n    }\n\n    try {\n      result = fn.apply(null, params);\n    } catch (error) {\n      // Well, this is quite the pickle.\n      // `fn` received a callback and invoked it (thus continuing the pipeline),\n      // but later also threw an error.\n      // We’re not about to restart the pipeline again, so the only thing left\n      // to do is to throw the thing instead.\n      if (callback && invoked) {\n        throw error;\n      }\n\n      return done(error);\n    }\n\n    if (!callback) {\n      if (result && typeof result.then === 'function') {\n        result.then(then, done);\n      } else if (result instanceof Error) {\n        done(result);\n      } else {\n        then(result);\n      }\n    }\n  } // Invoke `next`, only once.\n\n\n  function done() {\n    if (!invoked) {\n      invoked = true;\n      callback.apply(null, arguments);\n    }\n  } // Invoke `done` with one value.\n  // Tracks if an error is passed, too.\n\n\n  function then(value) {\n    done(null, value);\n  }\n}","'use strict';\n\nmodule.exports = convert;\n\nfunction convert(test) {\n  if (test == null) {\n    return ok;\n  }\n\n  if (typeof test === 'string') {\n    return typeFactory(test);\n  }\n\n  if (typeof test === 'object') {\n    return 'length' in test ? anyFactory(test) : allFactory(test);\n  }\n\n  if (typeof test === 'function') {\n    return test;\n  }\n\n  throw new Error('Expected function, string, or object as test');\n} // Utility assert each property in `test` is represented in `node`, and each\n// values are strictly equal.\n\n\nfunction allFactory(test) {\n  return all;\n\n  function all(node) {\n    var key;\n\n    for (key in test) {\n      if (node[key] !== test[key]) return false;\n    }\n\n    return true;\n  }\n}\n\nfunction anyFactory(tests) {\n  var checks = [];\n  var index = -1;\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index]);\n  }\n\n  return any;\n\n  function any() {\n    var index = -1;\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, arguments)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n} // Utility to convert a string into a function which checks a given node’s type\n// for said string.\n\n\nfunction typeFactory(test) {\n  return type;\n\n  function type(node) {\n    return Boolean(node && node.type === test);\n  }\n} // Utility to return true.\n\n\nfunction ok() {\n  return true;\n}","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = stringify;\n\nfunction stringify(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return '';\n  } // Node.\n\n\n  if (own.call(value, 'position') || own.call(value, 'type')) {\n    return position(value.position);\n  } // Position.\n\n\n  if (own.call(value, 'start') || own.call(value, 'end')) {\n    return position(value);\n  } // Point.\n\n\n  if (own.call(value, 'line') || own.call(value, 'column')) {\n    return point(value);\n  } // ?\n\n\n  return '';\n}\n\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {};\n  }\n\n  return index(point.line) + ':' + index(point.column);\n}\n\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {};\n  }\n\n  return point(pos.start) + '-' + point(pos.end);\n}\n\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1;\n}","module.exports = identity;\n\nfunction identity(d) {\n  return d;\n}","'use strict';\n\nmodule.exports = visitParents;\n\nvar convert = require('unist-util-is/convert');\n\nvar color = require('./color');\n\nvar CONTINUE = true;\nvar SKIP = 'skip';\nvar EXIT = false;\nvisitParents.CONTINUE = CONTINUE;\nvisitParents.SKIP = SKIP;\nvisitParents.EXIT = EXIT;\n\nfunction visitParents(tree, test, visitor, reverse) {\n  var step;\n  var is;\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n\n  is = convert(test);\n  step = reverse ? -1 : 1;\n  factory(tree, null, [])();\n\n  function factory(node, index, parents) {\n    var value = typeof node === 'object' && node !== null ? node : {};\n    var name;\n\n    if (typeof value.type === 'string') {\n      name = typeof value.tagName === 'string' ? value.tagName : typeof value.name === 'string' ? value.name : undefined;\n      visit.displayName = 'node (' + color(value.type + (name ? '<' + name + '>' : '')) + ')';\n    }\n\n    return visit;\n\n    function visit() {\n      var grandparents = parents.concat(node);\n      var result = [];\n      var subresult;\n      var offset;\n\n      if (!test || is(node, index, parents[parents.length - 1] || null)) {\n        result = toResult(visitor(node, parents));\n\n        if (result[0] === EXIT) {\n          return result;\n        }\n      }\n\n      if (node.children && result[0] !== SKIP) {\n        offset = (reverse ? node.children.length : -1) + step;\n\n        while (offset > -1 && offset < node.children.length) {\n          subresult = factory(node.children[offset], offset, grandparents)();\n\n          if (subresult[0] === EXIT) {\n            return subresult;\n          }\n\n          offset = typeof subresult[1] === 'number' ? subresult[1] : offset + step;\n        }\n      }\n\n      return result;\n    }\n  }\n}\n\nfunction toResult(value) {\n  if (value !== null && typeof value === 'object' && 'length' in value) {\n    return value;\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value];\n  }\n\n  return [value];\n}","'use strict';\n\nmodule.exports = visit;\n\nvar visitParents = require('unist-util-visit-parents');\n\nvar CONTINUE = visitParents.CONTINUE;\nvar SKIP = visitParents.SKIP;\nvar EXIT = visitParents.EXIT;\nvisit.CONTINUE = CONTINUE;\nvisit.SKIP = SKIP;\nvisit.EXIT = EXIT;\n\nfunction visit(tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n\n  visitParents(tree, test, overload, reverse);\n\n  function overload(node, parents) {\n    var parent = parents[parents.length - 1];\n    var index = parent ? parent.children.indexOf(node) : null;\n    return visitor(node, index, parent);\n  }\n}","'use strict';\n\nvar stringify = require('unist-util-stringify-position');\n\nmodule.exports = VMessage; // Inherit from `Error#`.\n\nfunction VMessagePrototype() {}\n\nVMessagePrototype.prototype = Error.prototype;\nVMessage.prototype = new VMessagePrototype(); // Message properties.\n\nvar proto = VMessage.prototype;\nproto.file = '';\nproto.name = '';\nproto.reason = '';\nproto.message = '';\nproto.stack = '';\nproto.fatal = null;\nproto.column = null;\nproto.line = null; // Construct a new VMessage.\n//\n// Note: We cannot invoke `Error` on the created context, as that adds readonly\n// `line` and `column` attributes on Safari 9, thus throwing and failing the\n// data.\n\nfunction VMessage(reason, position, origin) {\n  var parts;\n  var range;\n  var location;\n\n  if (typeof position === 'string') {\n    origin = position;\n    position = null;\n  }\n\n  parts = parseOrigin(origin);\n  range = stringify(position) || '1:1';\n  location = {\n    start: {\n      line: null,\n      column: null\n    },\n    end: {\n      line: null,\n      column: null\n    }\n  }; // Node.\n\n  if (position && position.position) {\n    position = position.position;\n  }\n\n  if (position) {\n    // Position.\n    if (position.start) {\n      location = position;\n      position = position.start;\n    } else {\n      // Point.\n      location.start = position;\n    }\n  }\n\n  if (reason.stack) {\n    this.stack = reason.stack;\n    reason = reason.message;\n  }\n\n  this.message = reason;\n  this.name = range;\n  this.reason = reason;\n  this.line = position ? position.line : null;\n  this.column = position ? position.column : null;\n  this.location = location;\n  this.source = parts[0];\n  this.ruleId = parts[1];\n}\n\nfunction parseOrigin(origin) {\n  var result = [null, null];\n  var index;\n\n  if (typeof origin === 'string') {\n    index = origin.indexOf(':');\n\n    if (index === -1) {\n      result[1] = origin;\n    } else {\n      result[0] = origin.slice(0, index);\n      result[1] = origin.slice(index + 1);\n    }\n  }\n\n  return result;\n}","'use strict';\n\nmodule.exports = require('./lib');","'use strict';\n\nvar p = require('./minpath');\n\nvar proc = require('./minproc');\n\nvar buffer = require('is-buffer');\n\nmodule.exports = VFile;\nvar own = {}.hasOwnProperty; // Order of setting (least specific to most), we need this because otherwise\n// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n// stem can be set.\n\nvar order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];\nVFile.prototype.toString = toString; // Access full path (`~/index.min.js`).\n\nObject.defineProperty(VFile.prototype, 'path', {\n  get: getPath,\n  set: setPath\n}); // Access parent path (`~`).\n\nObject.defineProperty(VFile.prototype, 'dirname', {\n  get: getDirname,\n  set: setDirname\n}); // Access basename (`index.min.js`).\n\nObject.defineProperty(VFile.prototype, 'basename', {\n  get: getBasename,\n  set: setBasename\n}); // Access extname (`.js`).\n\nObject.defineProperty(VFile.prototype, 'extname', {\n  get: getExtname,\n  set: setExtname\n}); // Access stem (`index.min`).\n\nObject.defineProperty(VFile.prototype, 'stem', {\n  get: getStem,\n  set: setStem\n}); // Construct a new file.\n\nfunction VFile(options) {\n  var prop;\n  var index;\n\n  if (!options) {\n    options = {};\n  } else if (typeof options === 'string' || buffer(options)) {\n    options = {\n      contents: options\n    };\n  } else if ('message' in options && 'messages' in options) {\n    return options;\n  }\n\n  if (!(this instanceof VFile)) {\n    return new VFile(options);\n  }\n\n  this.data = {};\n  this.messages = [];\n  this.history = [];\n  this.cwd = proc.cwd(); // Set path related properties in the correct order.\n\n  index = -1;\n\n  while (++index < order.length) {\n    prop = order[index];\n\n    if (own.call(options, prop)) {\n      this[prop] = options[prop];\n    }\n  } // Set non-path related properties.\n\n\n  for (prop in options) {\n    if (order.indexOf(prop) < 0) {\n      this[prop] = options[prop];\n    }\n  }\n}\n\nfunction getPath() {\n  return this.history[this.history.length - 1];\n}\n\nfunction setPath(path) {\n  assertNonEmpty(path, 'path');\n\n  if (this.path !== path) {\n    this.history.push(path);\n  }\n}\n\nfunction getDirname() {\n  return typeof this.path === 'string' ? p.dirname(this.path) : undefined;\n}\n\nfunction setDirname(dirname) {\n  assertPath(this.path, 'dirname');\n  this.path = p.join(dirname || '', this.basename);\n}\n\nfunction getBasename() {\n  return typeof this.path === 'string' ? p.basename(this.path) : undefined;\n}\n\nfunction setBasename(basename) {\n  assertNonEmpty(basename, 'basename');\n  assertPart(basename, 'basename');\n  this.path = p.join(this.dirname || '', basename);\n}\n\nfunction getExtname() {\n  return typeof this.path === 'string' ? p.extname(this.path) : undefined;\n}\n\nfunction setExtname(extname) {\n  assertPart(extname, 'extname');\n  assertPath(this.path, 'extname');\n\n  if (extname) {\n    if (extname.charCodeAt(0) !== 46\n    /* `.` */\n    ) {\n        throw new Error('`extname` must start with `.`');\n      }\n\n    if (extname.indexOf('.', 1) > -1) {\n      throw new Error('`extname` cannot contain multiple dots');\n    }\n  }\n\n  this.path = p.join(this.dirname, this.stem + (extname || ''));\n}\n\nfunction getStem() {\n  return typeof this.path === 'string' ? p.basename(this.path, this.extname) : undefined;\n}\n\nfunction setStem(stem) {\n  assertNonEmpty(stem, 'stem');\n  assertPart(stem, 'stem');\n  this.path = p.join(this.dirname || '', stem + (this.extname || ''));\n} // Get the value of the file.\n\n\nfunction toString(encoding) {\n  return (this.contents || '').toString(encoding);\n} // Assert that `part` is not a path (i.e., does not contain `p.sep`).\n\n\nfunction assertPart(part, name) {\n  if (part && part.indexOf(p.sep) > -1) {\n    throw new Error('`' + name + '` cannot be a path: did not expect `' + p.sep + '`');\n  }\n} // Assert that `part` is not empty.\n\n\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty');\n  }\n} // Assert `path` exists.\n\n\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too');\n  }\n}","'use strict';\n\nvar VMessage = require('vfile-message');\n\nvar VFile = require('./core.js');\n\nmodule.exports = VFile;\nVFile.prototype.message = message;\nVFile.prototype.info = info;\nVFile.prototype.fail = fail; // Create a message with `reason` at `position`.\n// When an error is passed in as `reason`, copies the stack.\n\nfunction message(reason, position, origin) {\n  var message = new VMessage(reason, position, origin);\n\n  if (this.path) {\n    message.name = this.path + ':' + message.name;\n    message.file = this.path;\n  }\n\n  message.fatal = false;\n  this.messages.push(message);\n  return message;\n} // Fail: creates a vmessage, associates it with the file, and throws it.\n\n\nfunction fail() {\n  var message = this.message.apply(this, arguments);\n  message.fatal = true;\n  throw message;\n} // Info: creates a vmessage, associates it with the file, and marks the fatality\n// as null.\n\n\nfunction info() {\n  var message = this.message.apply(this, arguments);\n  message.fatal = null;\n  return message;\n}","'use strict'; // A derivative work based on:\n// <https://github.com/browserify/path-browserify>.\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// <https://github.com/nodejs/node/blob/master/lib/path.js>.\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexports.basename = basename;\nexports.dirname = dirname;\nexports.extname = extname;\nexports.join = join;\nexports.sep = '/';\n\nfunction basename(path, ext) {\n  var start = 0;\n  var end = -1;\n  var index;\n  var firstNonSlashEnd;\n  var seenNonSlash;\n  var extIndex;\n\n  if (ext !== undefined && typeof ext !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n\n  assertPath(path);\n  index = path.length;\n\n  if (ext === undefined || !ext.length || ext.length > path.length) {\n    while (index--) {\n      if (path.charCodeAt(index) === 47\n      /* `/` */\n      ) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now.\n          if (seenNonSlash) {\n            start = index + 1;\n            break;\n          }\n        } else if (end < 0) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component.\n        seenNonSlash = true;\n        end = index + 1;\n      }\n    }\n\n    return end < 0 ? '' : path.slice(start, end);\n  }\n\n  if (ext === path) {\n    return '';\n  }\n\n  firstNonSlashEnd = -1;\n  extIndex = ext.length - 1;\n\n  while (index--) {\n    if (path.charCodeAt(index) === 47\n    /* `/` */\n    ) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (seenNonSlash) {\n          start = index + 1;\n          break;\n        }\n      } else {\n      if (firstNonSlashEnd < 0) {\n        // We saw the first non-path separator, remember this index in case\n        // we need it if the extension ends up not matching.\n        seenNonSlash = true;\n        firstNonSlashEnd = index + 1;\n      }\n\n      if (extIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n          if (extIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index;\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extIndex = -1;\n          end = firstNonSlashEnd;\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd;\n  } else if (end < 0) {\n    end = path.length;\n  }\n\n  return path.slice(start, end);\n}\n\nfunction dirname(path) {\n  var end;\n  var unmatchedSlash;\n  var index;\n  assertPath(path);\n\n  if (!path.length) {\n    return '.';\n  }\n\n  end = -1;\n  index = path.length; // Prefix `--` is important to not run on `0`.\n\n  while (--index) {\n    if (path.charCodeAt(index) === 47\n    /* `/` */\n    ) {\n        if (unmatchedSlash) {\n          end = index;\n          break;\n        }\n      } else if (!unmatchedSlash) {\n      // We saw the first non-path separator\n      unmatchedSlash = true;\n    }\n  }\n\n  return end < 0 ? path.charCodeAt(0) === 47\n  /* `/` */\n  ? '/' : '.' : end === 1 && path.charCodeAt(0) === 47\n  /* `/` */\n  ? '//' : path.slice(0, end);\n}\n\nfunction extname(path) {\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1; // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n\n  var preDotState = 0;\n  var unmatchedSlash;\n  var code;\n  var index;\n  assertPath(path);\n  index = path.length;\n\n  while (index--) {\n    code = path.charCodeAt(index);\n\n    if (code === 47\n    /* `/` */\n    ) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (unmatchedSlash) {\n          startPart = index + 1;\n          break;\n        }\n\n        continue;\n      }\n\n    if (end < 0) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension.\n      unmatchedSlash = true;\n      end = index + 1;\n    }\n\n    if (code === 46\n    /* `.` */\n    ) {\n        // If this is our first dot, mark it as the start of our extension.\n        if (startDot < 0) {\n          startDot = index;\n        } else if (preDotState !== 1) {\n          preDotState = 1;\n        }\n      } else if (startDot > -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension.\n      preDotState = -1;\n    }\n  }\n\n  if (startDot < 0 || end < 0 || // We saw a non-dot character immediately before the dot.\n  preDotState === 0 || // The (right-most) trimmed path component is exactly `..`.\n  preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n\n  return path.slice(startDot, end);\n}\n\nfunction join() {\n  var index = -1;\n  var joined;\n\n  while (++index < arguments.length) {\n    assertPath(arguments[index]);\n\n    if (arguments[index]) {\n      joined = joined === undefined ? arguments[index] : joined + '/' + arguments[index];\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined);\n} // Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\n\n\nfunction normalize(path) {\n  var absolute;\n  var value;\n  assertPath(path);\n  absolute = path.charCodeAt(0) === 47;\n  /* `/` */\n  // Normalize the path according to POSIX rules.\n\n  value = normalizeString(path, !absolute);\n\n  if (!value.length && !absolute) {\n    value = '.';\n  }\n\n  if (value.length && path.charCodeAt(path.length - 1) === 47\n  /* / */\n  ) {\n      value += '/';\n    }\n\n  return absolute ? '/' + value : value;\n} // Resolve `.` and `..` elements in a path with directory names.\n\n\nfunction normalizeString(path, allowAboveRoot) {\n  var result = '';\n  var lastSegmentLength = 0;\n  var lastSlash = -1;\n  var dots = 0;\n  var index = -1;\n  var code;\n  var lastSlashIndex;\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.charCodeAt(index);\n    } else if (code === 47\n    /* `/` */\n    ) {\n        break;\n      } else {\n      code = 47;\n      /* `/` */\n    }\n\n    if (code === 47\n    /* `/` */\n    ) {\n        if (lastSlash === index - 1 || dots === 1) {// Empty.\n        } else if (lastSlash !== index - 1 && dots === 2) {\n          if (result.length < 2 || lastSegmentLength !== 2 || result.charCodeAt(result.length - 1) !== 46\n          /* `.` */\n          || result.charCodeAt(result.length - 2) !== 46\n          /* `.` */\n          ) {\n              if (result.length > 2) {\n                lastSlashIndex = result.lastIndexOf('/');\n                /* istanbul ignore else - No clue how to cover it. */\n\n                if (lastSlashIndex !== result.length - 1) {\n                  if (lastSlashIndex < 0) {\n                    result = '';\n                    lastSegmentLength = 0;\n                  } else {\n                    result = result.slice(0, lastSlashIndex);\n                    lastSegmentLength = result.length - 1 - result.lastIndexOf('/');\n                  }\n\n                  lastSlash = index;\n                  dots = 0;\n                  continue;\n                }\n              } else if (result.length) {\n                result = '';\n                lastSegmentLength = 0;\n                lastSlash = index;\n                dots = 0;\n                continue;\n              }\n            }\n\n          if (allowAboveRoot) {\n            result = result.length ? result + '/..' : '..';\n            lastSegmentLength = 2;\n          }\n        } else {\n          if (result.length) {\n            result += '/' + path.slice(lastSlash + 1, index);\n          } else {\n            result = path.slice(lastSlash + 1, index);\n          }\n\n          lastSegmentLength = index - lastSlash - 1;\n        }\n\n        lastSlash = index;\n        dots = 0;\n      } else if (code === 46\n    /* `.` */\n    && dots > -1) {\n      dots++;\n    } else {\n      dots = -1;\n    }\n  }\n\n  return result;\n}\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\n  }\n}","'use strict'; // Somewhat based on:\n// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.\n// But I don’t think one tiny line of code can be copyrighted. 😅\n\nexports.cwd = cwd;\n\nfunction cwd() {\n  return '/';\n}","/* eslint-disable i18next/no-literal-string */\nimport React from 'react';\nimport PropTypes from 'prop-types';\nimport {Helmet} from 'gatsby-plugin-react-i18next';\nimport {useLocation} from '@gatsbyjs/reach-router';\nimport useSiteMetadata from '../../helpers/hooks/useSiteMetaData';\n\n\nfunction SEO({title, ogTitle = null, description, image = null, isArticle = false, lang = 'en'}) {\n    const {pathname} = useLocation();\n    const siteMetadata = useSiteMetadata();\n\n    const {\n        defaultTitle,\n        titleTemplate,\n        defaultDescription,\n        defaultImage,\n        siteUrl,\n    } = siteMetadata;\n\n    const seo = {\n        title: title || defaultTitle,\n        ogTitle: ogTitle || title || defaultTitle,\n        description: description || defaultDescription,\n        image: `${siteUrl}${image || defaultImage}`,\n        url: `${siteUrl}${pathname}`,\n    };\n\n    // Since Twitter also looks for Open Graph (Facebook) tags instead of only its own, we can avoid duplicated tags\n    // See: https://css-tricks.com/essential-meta-tags-social-media/#reconciling-meta-tags\n    return (\n        <Helmet\n            title={seo.title}\n            titleTemplate={titleTemplate}\n        >\n            <html lang={lang} />\n\n            <meta name=\"description\" content={seo.description} />\n            <meta name=\"image\" content={seo.image} />\n\n            {seo.ogTitle && <meta property=\"og:title\" content={seo.ogTitle} />}\n            {seo.description && <meta property=\"og:description\" content={seo.description} />}\n            {seo.image && <meta property=\"og:image\" content={seo.image} />}\n            {seo.url && <meta property=\"og:url\" content={seo.url} />}\n            {seo.image && <meta name=\"twitter:card\" content=\"summary_large_image\" />}\n            {isArticle && <meta property=\"og:type\" content=\"article\" />}\n        </Helmet>\n    );\n}\n\nSEO.defaultProps = {\n    ogTitle: null,\n    description: null,\n    lang: 'en',\n    image: null,\n    isArticle: false,\n};\n\nSEO.propTypes = {\n    title: PropTypes.string.isRequired,\n    ogTitle: PropTypes.string,\n    description: PropTypes.string,\n    lang: PropTypes.string,\n    image: PropTypes.string,\n    isArticle: PropTypes.bool,\n};\n\n\nexport default SEO;\n","import React from 'react';\n\nimport {Trans} from 'gatsby-plugin-react-i18next';\n\nimport Latest from '../../images/learn/filters/latest.svg';\nimport Article from '../../images/learn/filters/article.svg';\nimport Blog from '../../images/learn/filters/blog.svg';\nimport CaseStudy from '../../images/learn/filters/case-study.svg';\nimport Podcast from '../../images/learn/filters/podcast.svg';\nimport Report from '../../images/learn/filters/report.svg';\nimport Webinar from '../../images/learn/filters/webinar.svg';\nimport WhitePaper from '../../images/learn/filters/whitepaper.svg';\n\n\n/*\n * Public Elements\n */\nconst newsletterPost = 'NEWSLETTER_POST';\nconst latestPostTypeFilter = '';\nconst articlePostTypeFilter = 'ARTICLE';\nconst blogPostTypeFilter = 'BLOG';\nconst caseStudyPostTypeFilter = 'CASE_STUDY';\nconst podcastPostTypeFilter = 'PODCAST';\nconst reportPostTypeFilter = 'REPORT';\nconst webinarPostTypeFilter = 'WEBINAR';\nconst whitepaperPostTypeFilter = 'WHITEPAPER';\nconst postTypeFilters = {\n    [latestPostTypeFilter]: {name: <Trans>Latest</Trans>, icon: <Latest />},\n    [articlePostTypeFilter]: {name: <Trans>Article</Trans>, icon: <Article />},\n    [blogPostTypeFilter]: {name: <Trans>Blog</Trans>, icon: <Blog />},\n    [caseStudyPostTypeFilter]: {name: <Trans>Case Study</Trans>, icon: <CaseStudy />},\n    [podcastPostTypeFilter]: {name: <Trans>Podcast</Trans>, icon: <Podcast />},\n    [reportPostTypeFilter]: {name: <Trans>Report</Trans>, icon: <Report />},\n    [webinarPostTypeFilter]: {name: <Trans>Webinar</Trans>, icon: <Webinar />},\n    [whitepaperPostTypeFilter]: {name: <Trans>Whitepaper</Trans>, icon: <WhitePaper />},\n};\nconst orderedFilters = [\n    latestPostTypeFilter,\n    articlePostTypeFilter,\n    blogPostTypeFilter,\n    caseStudyPostTypeFilter,\n\n    // TODO: enable these filters when there are posts of this type\n    // podcastPostTypeFilter,\n    // reportPostTypeFilter,\n    // webinarPostTypeFilter,\n    // whitepaperPostTypeFilter,\n];\n\nconst blogFiltersSchema = {\n    /* eslint-disable i18next/no-literal-string */\n    type: {\n        type: 'string',\n        operator: 'equals',\n        name: <Trans>Type</Trans>,\n    },\n    /* eslint-enable i18next/no-literal-string */\n};\n\n\n/*\n * Exports\n */\nexport {\n    blogFiltersSchema,\n    newsletterPost,\n    latestPostTypeFilter,\n    articlePostTypeFilter,\n    blogPostTypeFilter,\n    caseStudyPostTypeFilter,\n    podcastPostTypeFilter,\n    reportPostTypeFilter,\n    webinarPostTypeFilter,\n    whitepaperPostTypeFilter,\n    postTypeFilters,\n    orderedFilters,\n};\n","import {useStaticQuery, graphql} from 'gatsby';\n\nconst useSiteMetadata = () => {\n    const {site} = useStaticQuery(graphql`\n        query {\n            site {\n                siteMetadata {\n                    defaultTitle: title\n                    titleTemplate\n                    defaultDescription: description\n                    defaultImage: image\n                    author\n                    siteUrl\n                }\n            }\n        }\n    `);\n    return site.siteMetadata;\n};\n\nexport default useSiteMetadata;\n","import React from 'react';\nimport PropTypes from 'prop-types';\nimport {GatsbyImage, getImage} from 'gatsby-plugin-image';\n\nimport styled from '@emotion/styled';\nimport ReactMarkdown from 'react-markdown';\nimport gfm from 'remark-gfm';\n\nimport {H1, H2, H3, H4, H5, H6, Link, P, Figcaption} from './Typography';\nimport {colors, fontWeights} from '../../styles/theme';\n\n\n/*\n * Constants\n */\nconst headingElementsMatch = {\n    1: H1,\n    2: H2,\n    3: H3,\n    4: H4,\n    5: H5,\n    6: H6,\n};\nconst plugins = [\n    [gfm, {singleQuote: false}],\n];\n/* eslint-disable no-unused-vars */\n/* eslint-disable react/prop-types */\nconst renderers = images => ({\n    link: ({node, children, ...props}) => <Link {...props} target=\"_blank\">{children}</Link>,\n    paragraph: ({node, children, ...props}) => <P {...props}>{children}</P>,\n    heading: ({node, level, children, ...props}) => {\n        const Element = headingElementsMatch[level];\n        return <Element {...props}>{children}</Element>;\n    },\n    image: ({node, children, src, alt, title, ...props}) => {\n        // TODO: fix div inside paragraph validation error\n        // Iterate the available images on this post, to find the one that matches the source we are looking for\n        for (let i = 0; i < images.length; i++) {\n            if (src.includes(images[i].name)) {\n                return (\n                    <figure>\n                        <GatsbyImage\n                            as=\"span\"\n                            image={getImage(images[i].childImageSharp)}\n                            alt={alt}\n                            {...props}\n                        />\n                        {title && <Figcaption>{title}</Figcaption>}\n                    </figure>\n                );\n            }\n        }\n\n        return null;\n    },\n});\n/* eslint-enable react/prop-types */\n/* eslint-enable no-unused-vars */\n\n\n/*\n * Private Elements\n */\nconst StyledMarkdown2React = styled.div`\n    ${Link} {\n        color: ${colors.darkPurple};\n        font-weight: ${fontWeights.medium};\n    }\n\n    ${H1},\n    ${H2},\n    ${H3},\n    ${H4},\n    ${H5},\n    ${H6} {\n        font-weight: ${fontWeights.medium};\n        margin-bottom: 15px;\n    }\n\n    ${H1} {\n        margin-top: 60px;\n        font-size: 36px;\n        line-height: 46px;\n    }\n\n    ${H2} {\n        margin-top: 50px;\n        font-size: 30px;\n        line-height: 40px;\n    }\n\n    ${H3} {\n        margin-top: 40px;\n    }\n\n    ${H4} {\n        margin-top: 30px;\n    }\n\n    ${H5} {\n        margin-top: 20px;\n    }\n\n    ${H6} {\n        margin-top: 10px;\n        margin-bottom: 15px;\n    }\n\n    ${P} {\n        margin-bottom: 32px;\n        line-height: 26px;\n    }\n\n    ol,\n    ul {\n        margin-bottom: 32px;\n\n        li {\n            margin-bottom: 15px;\n            line-height: 26px;\n        }\n    }\n\n    blockquote {\n        position: relative;\n        padding-left: 15px;\n        margin-left: 5px;\n\n        &::before {\n            position: absolute;\n            content: '';\n            left: 0;\n            top: 0;\n            height: 100%;\n            width: 2px;\n            background: linear-gradient(to bottom, ${colors.darkPurple}, ${colors.black});\n        }\n\n        * {\n            color: ${colors.darkPurple};\n            font-size: 21px;\n            line-height: 28px;\n        }\n    }\n\n    strong {\n        font-weight: 600;\n    }\n`;\n\n\n/*\n * Public Elements\n */\nconst Markdown2React = ({content, contentImages}) => (\n    <StyledMarkdown2React>\n        <ReactMarkdown plugins={plugins} renderers={renderers(contentImages)} allowDangerousHtml>\n            {content}\n        </ReactMarkdown>\n    </StyledMarkdown2React>\n);\n\nMarkdown2React.propTypes = {\n    content: PropTypes.string.isRequired,\n    contentImages: PropTypes.arrayOf(PropTypes.object.isRequired).isRequired,\n};\n\n\n/*\n * Exports\n */\nexport default Markdown2React;\n","import React from 'react';\nimport PropTypes from 'prop-types';\n\nimport styled from '@emotion/styled';\nimport {useTranslation} from 'gatsby-plugin-react-i18next';\n\nimport {h5BaseStyle} from './Typography';\nimport FacebookLogo from '../../images/social-media/facebook.svg';\nimport LinkedinLogo from '../../images/social-media/linkedin.svg';\nimport TwitterLogo from '../../images/social-media/twitter.svg';\nimport {colors} from '../../styles/theme';\n\n\n/*\n * Private Elements\n */\nconst StyledShareContainer = styled.div`\n    ${h5BaseStyle};\n\n    margin: 15px 0;\n\n    ul {\n        padding: 0;\n    }\n\n    li {\n        display: inline-block;\n    }\n    li + li {\n        margin-left: 30px;\n    }\n\n    svg {\n        &:hover {\n            * {\n              fill: ${colors.darkGrey};\n            }\n        }\n    }\n`;\n\n\n/*\n * Public Elements\n */\nconst ShareContentButtons = ({displayText, shareUrl, shareText}) => {\n    const {t} = useTranslation();\n\n    const facebookShare = `https://www.facebook.com/sharer.php?u=${shareUrl}`;\n    const linkedinShare = `https://www.linkedin.com/sharing/share-offsite/?url=${shareUrl}`;\n    const twitterShare = `https://twitter.com/intent/tweet?url=${shareUrl}&text=${shareText}&via=switchpayments`;\n\n    return (\n        <StyledShareContainer className=\"share\">\n            <div>{displayText}</div>\n            <ul>\n                <li>\n                    <a href={facebookShare} title={t('Share on Facebook')} target=\"_blank\" rel=\"noreferrer\">\n                        <FacebookLogo />\n                    </a>\n                </li>\n                <li>\n                    <a href={linkedinShare} title={t('Share on LinkedIn')} target=\"_blank\" rel=\"noreferrer\">\n                        <LinkedinLogo />\n                    </a>\n                </li>\n                <li>\n                    <a href={twitterShare} title={t('Share on Twitter')} target=\"_blank\" rel=\"noreferrer\">\n                        <TwitterLogo />\n                    </a>\n                </li>\n            </ul>\n        </StyledShareContainer>\n    );\n};\n\nShareContentButtons.propTypes = {\n    displayText: PropTypes.string.isRequired,\n    shareUrl: PropTypes.string.isRequired,\n    shareText: PropTypes.string,\n};\n\nShareContentButtons.defaultProps = {\n    shareText: '',\n};\n\n\n/*\n * Exports\n */\nexport default ShareContentButtons;\n","import React from 'react';\nimport PropTypes from 'prop-types';\n\nimport styled from '@emotion/styled';\n\nimport {breakpoints, ContentContainer, fonts} from '../../../styles/theme';\n\n\n/*\n * Private Elements\n */\nconst StyledBlogPostWrapper = styled(ContentContainer)`\n    padding: 0 25px;\n    position: relative;\n    font-family: ${fonts.sansSerif};\n\n    .extra-info {\n        position: relative;\n    }\n\n    @media (min-width: ${breakpoints.md}) {\n        padding-left: 65px;\n        padding-right: 65px;\n\n        .extra-info {\n            padding-right: 1.5rem;\n        }\n    }\n`;\n\n\n/*\n * Public Elements\n */\nconst BlogPostWrapper = ({extraInfo = null, className = '', children}) => (\n    <StyledBlogPostWrapper className={className}>\n        <div className=\"row no-gutters\">\n            <div className=\"col-12 col-md-2 order-2 order-md-1\">\n                {extraInfo && (\n                    <div className=\"extra-info h-100\">\n                        {extraInfo}\n                    </div>\n                )}\n            </div>\n            <article className=\"col-12 col-md-8 order-1 order-md-2\">\n                {children}\n            </article>\n        </div>\n    </StyledBlogPostWrapper>\n);\n\nBlogPostWrapper.propTypes = {\n    extraInfo: PropTypes.node,\n    className: PropTypes.string,\n    children: PropTypes.node.isRequired,\n};\n\nBlogPostWrapper.defaultProps = {\n    extraInfo: null,\n    className: '',\n};\n\n\n/*\n * Exports\n */\nexport default BlogPostWrapper;\n","/** @jsx jsx */\nimport React from 'react';\nimport PropTypes from 'prop-types';\n\nimport {css, jsx} from '@emotion/react';\nimport styled from '@emotion/styled';\nimport {Trans} from 'gatsby-plugin-react-i18next';\nimport {getImage} from 'gatsby-plugin-image';\nimport {BgImage} from 'gbimage-bridge';\n\nimport {breakpoints, colors, fonts, fontWeights} from '../../../styles/theme';\nimport {CTALink, H1, H5, heroBaseStyle} from '../../common/Typography';\nimport {caseStudyPostTypeFilter, postTypeFilters} from '../../../helpers/constants/learn';\nimport DownloadIcon from '../../../images/download.svg';\n\n\n/*\n * Private Elements\n */\nconst StyledBlogPostHero = styled.div`\n    padding-top: 70px;\n    margin-bottom: 35px;\n    min-height: 300px;\n    max-height: 800px;\n\n    display: grid;\n    grid-template-columns: 25px 1fr 25px;\n    grid-template-rows: 20vh 50px 1fr;\n  \n    .hero-content {\n        grid-column: 1 / 3;\n        grid-row: 2 / -1;\n        background-color: ${colors.white};\n        z-index: 1;\n        padding: 35px 25px;\n        display: flex;\n        flex-direction: column;\n        justify-content: space-between;\n\n        svg {\n            * {\n                stroke: ${colors.darkPurple};\n            }\n        }\n\n        .top {\n            display: flex;\n            flex-direction: row;\n            justify-content: space-between;\n            color: ${colors.darkPurple};\n            font-family: ${fonts.monospace};\n            font-weight: ${fontWeights.semiBold};\n            font-size: 12px;\n            line-height: 16px;\n            margin-bottom: 35px;\n\n            .category {\n                display: flex;\n                align-items: center;\n\n                svg {\n                    margin-right: 5px;\n                }\n\n                p {\n                    display: flex;\n                    align-items: center;\n                    margin: 0;\n                    font-size: 12px;\n                    line-height: 22px;\n                }\n            }\n        }\n\n        ${H5} {\n            margin: 0;\n        }\n\n        .download-link {\n            margin-top: 0.5rem;\n\n            svg {\n                margin-left: 10px;\n            }\n        }\n    }\n\n    @media (min-width: ${breakpoints.md}) {\n        padding-top: 110px;\n        height: 85vh;\n        min-height: 500px;\n        max-height: 800px;\n        grid-template-columns: 20% 1fr 45%;\n        grid-template-rows: 1fr 80%;\n\n        .hero-content {\n            padding: 45px 55px 55px max(calc(((100vw - 1400px) / 2) + 115px), 115px);\n            border-top-right-radius: 5px;\n        }\n    }\n    \n  @media (min-width: ${breakpoints.xl}) {\n      .hero-content {\n          ${H1} {\n              ${heroBaseStyle};\n          }\n      }\n  }\n`;\n\nconst backgroundImageStyles = css`\n    grid-column: 2 / -1;\n    grid-row: 1 / 3;\n\n    &::before,\n    &::after {\n        border-radius: 5px;\n    }\n`;\n\n\n/*\n * Public Elements\n */\nconst BlogPostHero = ({post}) => {\n    const downloadLink = post.type === caseStudyPostTypeFilter ? (\n        <CTALink\n            className=\"download-link\"\n            to={post.extra[0].file.localFile.publicURL}\n            gaLabel={`Case Study - ${post.title}`}\n            download\n        >\n            <Trans>Download Case Study</Trans>\n            <DownloadIcon />\n        </CTALink>\n    ) : null;\n\n    return (\n        <StyledBlogPostHero>\n            <BgImage css={backgroundImageStyles} image={getImage(post.feature_image.localFile)} />\n\n            <div className=\"hero-content\">\n                <div className=\"top\">\n                    <div className=\"category\">\n                        {postTypeFilters[post.type].icon}\n                        <p>{postTypeFilters[post.type].name}</p>\n                    </div>\n                    <div className=\"labels\">{post.blog_tags[0]?.tag}</div>\n                </div>\n                <H1>{post.title}</H1>\n                <H5>{post.sub_title}</H5>\n\n                {downloadLink}\n            </div>\n        </StyledBlogPostHero>\n    );\n};\n\nBlogPostHero.propTypes = {\n    post: PropTypes.object.isRequired,\n};\n\n\n/*\n * Exports\n */\nexport default BlogPostHero;\n","/** @jsx jsx */\nimport React, {useContext} from 'react';\nimport PropTypes from 'prop-types';\nimport {graphql} from 'gatsby';\nimport {getSrc} from 'gatsby-plugin-image';\n\nimport {css, jsx} from '@emotion/react';\nimport styled from '@emotion/styled';\nimport {Trans, useTranslation} from 'gatsby-plugin-react-i18next';\n\nimport {ContrastContext} from '../helpers/context';\nimport {EmbeddedPodcast, EmbeddedVideo, EndOfPageCTA} from '../components/common/Clickables';\nimport Markdown2React from '../components/common/Markdown2React';\nimport SEO from '../components/common/SEO';\nimport ShareContentButtons from '../components/common/ShareContentButtons';\nimport {H2, H5, H5Mono, P2} from '../components/common/Typography';\nimport BlogPostWrapper from '../components/learn/blog-post/BlogPostWrapper';\nimport BlogPostHero from '../components/learn/blog-post/Hero';\nimport {caseStudyPostTypeFilter, podcastPostTypeFilter, webinarPostTypeFilter} from '../helpers/constants/learn';\nimport useSiteMetadata from '../helpers/hooks/useSiteMetaData';\nimport GeometricPatternBackground from '../images/geometric-pattern-bg.png';\nimport {breakpoints, colors, ContentContainer, fontWeights} from '../styles/theme';\n\n\n/*\n * Constants\n */\nconst embeddedContentElement = {\n    [webinarPostTypeFilter]: EmbeddedVideo,\n    [podcastPostTypeFilter]: EmbeddedPodcast,\n};\n\n\n/*\n * Private Elements\n */\nconst StyledExtraInfo = styled.div`\n    display: flex;\n    flex-direction: column;\n\n    .section {\n        margin-bottom: 10px;\n\n        .content {\n            font-weight: ${fontWeights.semiBold};\n        }\n    }\n\n    .share {\n        margin-top: 20px;\n    }\n\n    @media (min-width: ${breakpoints.md}) {\n        position: absolute;\n        bottom: 40px;\n        left: 0;\n\n        .section {\n            margin-bottom: 30px;\n        }\n\n        .share {\n            margin-top: 50px;\n        }\n    }\n`;\n\nconst ExtraInfo = ({post, pageUrl}) => {\n    const {t} = useTranslation();\n\n    return (\n        <StyledExtraInfo>\n            <div className=\"section\">\n                <P2><Trans>Written by</Trans></P2>\n                <P2 className=\"content\">{post.blog_post_author.name}</P2>\n            </div>\n            <div className=\"section\">\n                <P2><Trans>Date</Trans></P2>\n                <P2 className=\"content\">{post.publish_date}</P2>\n            </div>\n            <ShareContentButtons\n                displayText={t('Share this Article')}\n                shareUrl={pageUrl}\n                shareText={post.title}\n            />\n        </StyledExtraInfo>\n    );\n};\n\nExtraInfo.propTypes = {\n    post: PropTypes.object.isRequired,\n    pageUrl: PropTypes.string.isRequired,\n};\n\nconst BlogPostBody = styled.div`\n    .blog-post-description {\n        margin: 80px 0;\n    }\n\n    .blog-post-content {\n        margin-bottom: 80px;\n\n        .embedded-element {\n            margin-top: 50px;\n        }\n    }\n\n    @media (min-width: ${breakpoints.md}) {\n        .blog-post-content {\n            padding-left: 30px;\n        }\n    }\n\n    @media (min-width: ${breakpoints.lg}) {\n        .blog-post-content {\n            padding-left: 50px;\n        }\n    }\n`;\n\n\nconst ContactSalesCTAStyles = css`\n    margin-top: 50px;\n\n    ${ContentContainer} {\n        .cta {\n            margin-bottom: 0;\n\n            ${H2} {\n                margin-bottom: 20px;\n\n                .thin {\n                    font-weight: ${fontWeights.semiLight};\n                }\n            }\n        }\n    }\n\n    .cta-bottom-background {\n        background-color: ${colors.transparent};\n    } \n`;\n\n\nconst BlogPostBackground = styled.div`\n    padding-bottom: 50px;\n    background: linear-gradient(330deg, rgba(255, 255, 255, 0.55) 0%, ${colors.white} 796px),\n                right bottom/auto 800px url(${GeometricPatternBackground});\n    background-size: contain;\n`;\n\n\n/*\n * Public Elements\n */\nconst BlogPostPage = ({data, location}) => {\n    const setContrast = useContext(ContrastContext);\n    setContrast(true);\n    const {t} = useTranslation();\n\n    // Build this page URL to share\n    const pageUrl = useSiteMetadata().siteUrl + location.pathname;\n\n    const post = data.strapiBlogPost;\n    const EmbeddedElement = embeddedContentElement[post.type];\n\n    const extraInfo = <ExtraInfo post={post} pageUrl={pageUrl} />;\n    const postDescription = post.description ? <H5 className=\"blog-post-description\">{post.description}</H5> : null;\n    const embeddedElement = EmbeddedElement ? <EmbeddedElement iframeSource={post.extra[0].link} /> : null;\n\n    const endOfPageCTA = post.type === caseStudyPostTypeFilter ? (\n        <EndOfPageCTA link=\"/about/contact-sales\" linkText={t('Contact Sales')} cssStyles={ContactSalesCTAStyles}>\n            <H2>\n                <Trans>\n                    <span className=\"thin\">Do you think Switch can help</span>\n                    {' '}\n                    your business\n                    {' '}\n                    <span className=\"thin\">too?</span>\n                </Trans>\n            </H2>\n            <H5Mono><Trans>Our team is here to help you integrate.</Trans></H5Mono>\n        </EndOfPageCTA>\n    ) : null;\n\n    return (\n        <>\n            <SEO\n                title={post.title}\n                ogTitle={`${post.title} - Switch`}\n                description={post.description}\n                image={getSrc(post.feature_image.localFile)}\n                isArticle\n            />\n\n            <BlogPostHero post={post} />\n\n            <BlogPostBackground>\n                <BlogPostWrapper extraInfo={extraInfo}>\n                    <BlogPostBody>\n                        {postDescription}\n\n                        <div className=\"blog-post-content\">\n                            <Markdown2React content={post.content} contentImages={post.content_images} />\n\n                            {embeddedElement}\n                        </div>\n                    </BlogPostBody>\n                </BlogPostWrapper>\n\n                {endOfPageCTA}\n            </BlogPostBackground>\n        </>\n    );\n};\n\nBlogPostPage.propTypes = {\n    data: PropTypes.object.isRequired,\n    location: PropTypes.object.isRequired,\n};\n\n\n/*\n * Exports\n */\nexport default BlogPostPage;\nexport const query = graphql`\n    query($postId: String!) {\n        strapiBlogPost(strapiId: { eq: $postId }) {\n            id: strapiId\n            title\n            sub_title\n            description\n            content\n            publish_date(formatString: \"DD MMMM YYYY\")\n            type\n            blog_tags {\n                tag\n            }\n            blog_post_author {\n                name\n            }\n            feature_image {\n                localFile {\n                    childImageSharp {\n                        gatsbyImageData(\n                            placeholder: BLURRED\n                            width: 1000\n                        )\n                    }\n                }\n            }\n            extra {\n                link\n                file {\n                    localFile {\n                        publicURL\n                    }\n                }\n            }\n            content_images: childrenFile {\n                name\n                childImageSharp {\n                    gatsbyImageData(\n                        placeholder: BLURRED\n                        width: 1000\n                    )\n                }\n            }\n        }\n    }\n`;\n","var React = require('react');\n\nfunction Download (props) {\n    return React.createElement(\"svg\",props,React.createElement(\"g\",{\"style\":{\"stroke\":\"#fff\",\"strokeWidth\":\"1.5\",\"fill\":\"none\",\"fillRule\":\"evenodd\",\"strokeLinecap\":\"round\",\"strokeLinejoin\":\"round\"},\"transform\":\"translate(3 3)\"},[React.createElement(\"path\",{\"d\":\"m18 12v4c0 1.1045695-.8954305 2-2 2h-14c-1.1045695 0-2-.8954305-2-2v-4\",\"key\":0}),React.createElement(\"path\",{\"d\":\"m4 7 5 5 5-5\",\"key\":1}),React.createElement(\"path\",{\"d\":\"m9 12v-12\",\"key\":2})]));\n}\n\nDownload.defaultProps = {\"height\":\"24\",\"viewBox\":\"0 0 24 24\",\"width\":\"24\"};\n\nmodule.exports = Download;\n\nDownload.default = Download;\n","var React = require('react');\n\nfunction Article (props) {\n    return React.createElement(\"svg\",props,React.createElement(\"g\",{\"style\":{\"fill\":\"none\",\"fillRule\":\"evenodd\",\"strokeLinecap\":\"round\",\"strokeLinejoin\":\"round\",\"stroke\":\"#fff\",\"strokeWidth\":\"1.5\"}},[React.createElement(\"path\",{\"d\":\"m7.5 7.25h10\",\"key\":0}),React.createElement(\"path\",{\"d\":\"m8 11.25h5\",\"key\":1}),React.createElement(\"path\",{\"d\":\"m5 2h15v20h-15z\",\"transform\":\"matrix(1 0 0 -1 0 24)\",\"key\":2})]));\n}\n\nArticle.defaultProps = {\"height\":\"24\",\"viewBox\":\"0 0 24 24\",\"width\":\"24\"};\n\nmodule.exports = Article;\n\nArticle.default = Article;\n","var React = require('react');\n\nfunction Blog (props) {\n    return React.createElement(\"svg\",props,React.createElement(\"g\",{\"style\":{\"fill\":\"none\",\"fillRule\":\"evenodd\",\"strokeLinecap\":\"round\",\"strokeLinejoin\":\"round\",\"stroke\":\"#fff\",\"strokeWidth\":\"1.5\"}},[React.createElement(\"path\",{\"d\":\"m3 2h18v11h-18z\",\"transform\":\"matrix(1 0 0 -1 0 15)\",\"key\":0}),React.createElement(\"path\",{\"d\":\"m3.409091 22h11\",\"key\":1}),React.createElement(\"path\",{\"d\":\"m3.136364 17.5h14.545454\",\"key\":2})]));\n}\n\nBlog.defaultProps = {\"height\":\"24\",\"viewBox\":\"0 0 24 24\",\"width\":\"24\"};\n\nmodule.exports = Blog;\n\nBlog.default = Blog;\n","var React = require('react');\n\nfunction CaseStudy (props) {\n    return React.createElement(\"svg\",props,React.createElement(\"g\",{\"style\":{\"fill\":\"none\",\"fillRule\":\"evenodd\",\"strokeLinecap\":\"round\",\"strokeLinejoin\":\"round\",\"stroke\":\"#fff\",\"strokeWidth\":\"1.5\"}},[React.createElement(\"path\",{\"d\":\"m16 10.8952v6h-11v-14.8952h5.9054286\",\"key\":0}),React.createElement(\"path\",{\"d\":\"m16.141274 16.595722 4.499513 5.362311\",\"key\":1}),React.createElement(\"circle\",{\"cx\":\"13.408564\",\"cy\":\"12.408564\",\"r\":\"5\",\"transform\":\"matrix(.93969262 .34202014 -.34202014 .93969262 5.052614 -3.837671)\",\"key\":2})]));\n}\n\nCaseStudy.defaultProps = {\"height\":\"24\",\"viewBox\":\"0 0 24 24\",\"width\":\"24\"};\n\nmodule.exports = CaseStudy;\n\nCaseStudy.default = CaseStudy;\n","var React = require('react');\n\nfunction Latest (props) {\n    return React.createElement(\"svg\",props,React.createElement(\"g\",{\"style\":{\"fill\":\"none\",\"fillRule\":\"evenodd\",\"strokeLinecap\":\"round\",\"strokeLinejoin\":\"round\",\"stroke\":\"#fff\",\"strokeWidth\":\"1.5\"}},[React.createElement(\"circle\",{\"cx\":\"12\",\"cy\":\"12\",\"r\":\"10\",\"key\":0}),React.createElement(\"path\",{\"d\":\"m11.5 13.5v-7.5\",\"key\":1}),React.createElement(\"path\",{\"d\":\"m12 13.5 4.583333-1.5\",\"key\":2})]));\n}\n\nLatest.defaultProps = {\"height\":\"24\",\"viewBox\":\"0 0 24 24\",\"width\":\"24\"};\n\nmodule.exports = Latest;\n\nLatest.default = Latest;\n","var React = require('react');\n\nfunction Podcast (props) {\n    return React.createElement(\"svg\",props,React.createElement(\"g\",{\"style\":{\"fill\":\"none\",\"fillRule\":\"evenodd\",\"strokeLinecap\":\"round\",\"strokeLinejoin\":\"round\",\"stroke\":\"#fff\",\"strokeWidth\":\"1.5\"}},[React.createElement(\"path\",{\"d\":\"m2 5h20v14h-20z\",\"transform\":\"matrix(-1 0 0 1 24 0)\",\"key\":0}),React.createElement(\"path\",{\"d\":\"m12.5 9 2.5 5h-5z\",\"transform\":\"matrix(0 1 -1 0 24 -1)\",\"key\":1})]));\n}\n\nPodcast.defaultProps = {\"height\":\"24\",\"viewBox\":\"0 0 24 24\",\"width\":\"24\"};\n\nmodule.exports = Podcast;\n\nPodcast.default = Podcast;\n","var React = require('react');\n\nfunction Report (props) {\n    return React.createElement(\"svg\",props,React.createElement(\"g\",{\"style\":{\"fill\":\"none\",\"fillRule\":\"evenodd\",\"strokeLinecap\":\"round\",\"strokeLinejoin\":\"round\",\"stroke\":\"#fff\",\"strokeWidth\":\"1.5\"}},[React.createElement(\"path\",{\"d\":\"m2.5 4.5h16v11h-16z\",\"transform\":\"matrix(0 1 1 0 .5 -.5)\",\"key\":0}),React.createElement(\"path\",{\"d\":\"m9 22h11v-16h-4m-7 16v-4\",\"key\":1})]));\n}\n\nReport.defaultProps = {\"height\":\"24\",\"viewBox\":\"0 0 24 24\",\"width\":\"24\"};\n\nmodule.exports = Report;\n\nReport.default = Report;\n","var React = require('react');\n\nfunction Webinar (props) {\n    return React.createElement(\"svg\",props,React.createElement(\"g\",{\"style\":{\"fill\":\"none\",\"fillRule\":\"evenodd\",\"strokeLinecap\":\"round\",\"strokeLinejoin\":\"round\",\"stroke\":\"#fff\",\"strokeWidth\":\"1.5\"}},[React.createElement(\"path\",{\"d\":\"m2 5h20v11h-20z\",\"transform\":\"matrix(-1 0 0 1 24 0)\",\"key\":0}),React.createElement(\"path\",{\"d\":\"m4.5 19.5h15\",\"key\":1})]));\n}\n\nWebinar.defaultProps = {\"height\":\"24\",\"viewBox\":\"0 0 24 24\",\"width\":\"24\"};\n\nmodule.exports = Webinar;\n\nWebinar.default = Webinar;\n","var React = require('react');\n\nfunction Whitepaper (props) {\n    return React.createElement(\"svg\",props,React.createElement(\"g\",{\"style\":{\"fill\":\"none\",\"fillRule\":\"evenodd\",\"strokeLinecap\":\"round\",\"strokeLinejoin\":\"round\",\"stroke\":\"#fff\",\"strokeWidth\":\"1.5\"}},[React.createElement(\"path\",{\"d\":\"m5 2h15v13.3844222l-7 6.6155778h-8z\",\"transform\":\"matrix(1 0 0 -1 0 24)\",\"key\":0}),React.createElement(\"path\",{\"d\":\"m12 2v7.07472868h7.3739088\",\"key\":1})]));\n}\n\nWhitepaper.defaultProps = {\"height\":\"24\",\"viewBox\":\"0 0 24 24\",\"width\":\"24\"};\n\nmodule.exports = Whitepaper;\n\nWhitepaper.default = Whitepaper;\n","export default __webpack_public_path__ + \"static/geometric-pattern-bg-6719d160374d5b4c8e751921b76516bd.png\";"],"sourceRoot":""}