{"version":3,"sources":["webpack:///./node_modules/vfile/lib/minproc.browser.js","webpack:///./node_modules/micromark/dist/initialize/text.js","webpack:///./node_modules/micromark/dist/util/move-point.js","webpack:///./node_modules/micromark/dist/tokenize/code-text.js","webpack:///./node_modules/unist-util-stringify-position/index.js","webpack:///./node_modules/micromark/dist/parse.js","webpack:///./node_modules/micromark/dist/constant/splice.js","webpack:///./node_modules/micromark/dist/initialize/content.js","webpack:///./node_modules/micromark/dist/tokenize/factory-whitespace.js","webpack:///./node_modules/micromark/dist/postprocess.js","webpack:///./node_modules/micromark/dist/util/slice-chunks.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/image.js","webpack:///./node_modules/micromark/dist/character/markdown-space.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/all.js","webpack:///./node_modules/micromark/dist/tokenize/thematic-break.js","webpack:///./node_modules/micromark/dist/tokenize/html-text.js","webpack:///./node_modules/micromark/dist/tokenize/character-reference.js","webpack:///./node_modules/micromark/dist/tokenize/list.js","webpack:///./node_modules/micromark/dist/util/create-tokenizer.js","webpack:///./node_modules/extend/index.js","webpack:///./node_modules/react-markdown/src/react-markdown.js","webpack:///./node_modules/property-information/html.js","webpack:///./node_modules/micromark/dist/tokenize/label-start-image.js","webpack:///./node_modules/micromark/dist/character/ascii-atext.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/footnote.js","webpack:///./node_modules/micromark/dist/character/ascii-control.js","webpack:///./node_modules/micromark/dist/tokenize/factory-title.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/revert.js","webpack:///./node_modules/micromark/dist/tokenize/autolink.js","webpack:///./node_modules/react-markdown/src/ast-to-react.js","webpack:///./node_modules/unist-util-position/index.js","webpack:///./node_modules/micromark/dist/util/normalize-identifier.js","webpack:///./node_modules/micromark/dist/character/unicode-punctuation.js","webpack:///./node_modules/style-to-object/index.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/html.js","webpack:///./node_modules/micromark/dist/tokenize/heading-atx.js","webpack:///./node_modules/property-information/lib/util/create.js","webpack:///./node_modules/micromark/dist/character/markdown-line-ending.js","webpack:///./node_modules/trough/wrap.js","webpack:///./node_modules/micromark/dist/constant/from-char-code.js","webpack:///./node_modules/react-markdown/src/rehype-filter.js","webpack:///./node_modules/vfile/index.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/heading.js","webpack:///./node_modules/property-information/find.js","webpack:///./node_modules/micromark/dist/util/serialize-chunks.js","webpack:///./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/color.browser.js","webpack:///./node_modules/property-information/lib/util/types.js","webpack:///./node_modules/bail/index.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/root.js","webpack:///./node_modules/micromark/dist/util/chunked-push.js","webpack:///./node_modules/micromark/dist/tokenize/definition.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/delete.js","webpack:///./node_modules/property-information/svg.js","webpack:///./node_modules/micromark/dist/tokenize/label-start-link.js","webpack:///./node_modules/micromark/dist/util/resolve-all.js","webpack:///./node_modules/micromark/dist/tokenize/setext-underline.js","webpack:///./node_modules/micromark/dist/constant/html-raw-names.js","webpack:///./node_modules/micromark/dist/tokenize/html-flow.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/table.js","webpack:///./node_modules/micromark/dist/initialize/flow.js","webpack:///./node_modules/mdast-util-from-markdown/index.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-definitions/index.js","webpack:///./node_modules/inline-style-parser/index.js","webpack:///./node_modules/micromark/dist/constant/unicode-punctuation-regex.js","webpack:///./node_modules/micromark/dist/util/subtokenize.js","webpack:///./node_modules/micromark/dist/tokenize/code-indented.js","webpack:///./node_modules/micromark/dist/constant/assign.js","webpack:///./node_modules/micromark/dist/character/ascii-alphanumeric.js","webpack:///./node_modules/micromark/dist/util/prefix-size.js","webpack:///./node_modules/micromark/dist/tokenize/label-end.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/index.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","webpack:///./node_modules/vfile/lib/index.js","webpack:///./node_modules/micromark/dist/tokenize/code-fenced.js","webpack:///./node_modules/micromark/dist/character/markdown-line-ending-or-space.js","webpack:///./node_modules/micromark/dist/character/ascii-hex-digit.js","webpack:///./node_modules/micromark/dist/constant/html-block-names.js","webpack:///./node_modules/react-markdown/src/uri-transformer.js","webpack:///./node_modules/property-information/lib/html.js","webpack:///./node_modules/micromark/dist/constructs.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","webpack:///./node_modules/micromark/dist/util/shallow.js","webpack:///./node_modules/micromark/dist/constant/has-own-property.js","webpack:///./node_modules/space-separated-tokens/index.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/break.js","webpack:///./node_modules/xtend/immutable.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/wrap.js","webpack:///./node_modules/micromark/dist/tokenize/character-escape.js","webpack:///./node_modules/property-information/lib/util/info.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","webpack:///./node_modules/micromark/dist/tokenize/partial-blank-line.js","webpack:///./node_modules/unist-util-generated/index.js","webpack:///./node_modules/micromark/dist/util/chunked-splice.js","webpack:///./node_modules/parse-entities/decode-entity.browser.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/list.js","webpack:///./node_modules/mdast-util-from-markdown/node_modules/mdast-util-to-string/index.js","webpack:///./node_modules/react-markdown/node_modules/react-is/cjs/react-is.production.min.js","webpack:///./node_modules/react-markdown/node_modules/is-plain-obj/index.js","webpack:///./node_modules/micromark/dist/initialize/document.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/link.js","webpack:///./node_modules/micromark/dist/util/safe-from-int.js","webpack:///./node_modules/react-markdown/node_modules/unified/index.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/index.js","webpack:///./node_modules/unist-util-is/convert.js","webpack:///./node_modules/unist-util-visit/index.js","webpack:///./node_modules/vfile-message/index.js","webpack:///./node_modules/property-information/normalize.js","webpack:///./node_modules/property-information/lib/aria.js","webpack:///./node_modules/vfile/node_modules/is-buffer/index.js","webpack:///./node_modules/micromark/dist/tokenize/attention.js","webpack:///./node_modules/property-information/lib/util/schema.js","webpack:///./node_modules/property-information/lib/xmlns.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/footer.js","webpack:///./node_modules/property-information/lib/xlink.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/strong.js","webpack:///./node_modules/remark-rehype/node_modules/unist-builder/index.js","webpack:///./node_modules/property-information/lib/xml.js","webpack:///./node_modules/remark-rehype/index.js","webpack:///./node_modules/micromark/dist/tokenize/line-ending.js","webpack:///./node_modules/micromark/dist/util/classify-character.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/list-item.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/text.js","webpack:///./node_modules/micromark/dist/tokenize/hard-break-escape.js","webpack:///./node_modules/micromark/dist/tokenize/factory-destination.js","webpack:///./node_modules/micromark/dist/character/ascii-alpha.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","webpack:///./node_modules/micromark/dist/util/size-chunks.js","webpack:///./node_modules/micromark/dist/tokenize/block-quote.js","webpack:///./node_modules/micromark/dist/tokenize/factory-label.js","webpack:///./node_modules/micromark/dist/character/ascii-digit.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/one.js","webpack:///./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js","webpack:///./node_modules/micromark/dist/preprocess.js","webpack:///./node_modules/micromark/dist/util/combine-extensions.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/code.js","webpack:///./node_modules/micromark/dist/util/miniflat.js","webpack:///./node_modules/micromark/dist/character/ascii-punctuation.js","webpack:///./node_modules/property-information/lib/util/defined-info.js","webpack:///./node_modules/micromark/dist/tokenize/content.js","webpack:///./node_modules/react-markdown/node_modules/react-is/index.js","webpack:///./node_modules/micromark/dist/util/regex-check.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/index.js","webpack:///./node_modules/vfile/lib/core.js","webpack:///./node_modules/micromark/dist/character/unicode-whitespace.js","webpack:///./node_modules/vfile/lib/minpath.browser.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","webpack:///./node_modules/react-markdown/node_modules/remark-parse/index.js","webpack:///./node_modules/property-information/lib/util/case-sensitive-transform.js","webpack:///./node_modules/comma-separated-tokens/index.js","webpack:///./node_modules/react-markdown/node_modules/is-buffer/index.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","webpack:///./node_modules/mdast-util-from-markdown/dist/index.js","webpack:///./node_modules/mdurl/encode.js","webpack:///./node_modules/trough/index.js","webpack:///./node_modules/property-information/lib/util/case-insensitive-transform.js","webpack:///./node_modules/micromark/dist/tokenize/factory-space.js","webpack:///./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","webpack:///./node_modules/property-information/lib/util/merge.js","webpack:///./node_modules/property-information/lib/svg.js"],"names":["exports","cwd","Object","defineProperty","value","assign","shallow","text","initializeFactory","string","resolver","resolveAll","createResolver","field","tokenize","effects","self","this","constructs","parser","attempt","start","notText","code","atBreak","enter","consume","data","exit","list","index","length","previous","call","resolveAllLineSuffixes","undefined","extraResolver","events","context","type","end","splice","chunks","chunk","bufferIndex","size","tabs","token","eventIndex","sliceStream","charCodeAt","line","column","offset","_index","_bufferIndex","module","point","markdownLineEnding","codeText","name","ok","nok","sizeOpen","openingSequence","gap","closingSequence","resolve","tailExitIndex","headEnterIndex","own","hasOwnProperty","position","pos","content","document","flow","combineExtensions","createTokenizer","miniflat","options","defined","concat","extensions","create","initializer","from","factorySpace","contentStart","contentInitial","lineStart","contentType","next","markdownSpace","seen","subtokenize","view","startIndex","startBufferIndex","endIndex","endBufferIndex","slice","push","normalize","h","node","props","src","url","alt","title","parent","result","head","nodes","children","values","one","replace","thematicBreak","marker","sequence","asciiAlpha","asciiAlphanumeric","markdownLineEndingOrSpace","htmlText","buffer","returnState","open","declarationOpen","tagCloseStart","instruction","tagOpen","commentOpen","cdataOpen","declaration","commentStart","commentStartDash","comment","commentClose","atLineEnding","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","afterPrefix","disable","null","indexOf","decodeEntity","asciiDigit","asciiHexDigit","_interopDefaultLegacy","e","default","decodeEntity__default","characterReference","max","test","numeric","sliceSerialize","prefixSize","sizeChunks","partialBlankLine","initialSize","kind","containerState","_container","check","atMarker","interrupt","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","continuation","_closeFlow","furtherBlankLines","notInCurrentItem","indentConstruct","partial","chunkedPush","chunkedSplice","serializeChunks","sliceChunks","initialize","columnStart","resolveAllConstructs","stack","accountForPotentialSkip","fields","now","pop","constructFactory","construct","info","addResult","onsuccessfulcheck","lazy","defineSkip","write","main","state","chunkIndex","go","restore","onreturn","bogusState","listOfConstructs","constructIndex","currentConstruct","handleListOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","Array","store","resolveTo","hasOwn","prototype","toStr","toString","gOPD","getOwnPropertyDescriptor","isArray","arr","isPlainObject","obj","key","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","enumerable","configurable","newValue","writable","getProperty","extend","copy","copyIsArray","clone","arguments","i","deep","React","unified","parse","remarkRehype","PropTypes","html","filter","uriTransformer","childrenToReact","hastChildrenToReact","ReactMarkdown","deprecated","renderers","to","id","astPlugins","allowDangerousHtml","escapeHtml","source","allowNode","allowedTypes","disallowedTypes","includeNodeIndex","deprecation","console","warn","processor","use","remarkPlugins","plugins","rehypePlugins","hastNode","runSync","TypeError","createElement","Fragment","schema","listDepth","className","defaultProps","transformLinkUri","propTypes","allowElement","func","allowedElements","arrayOf","disallowedElements","unwrapDisallowed","bool","oneOfType","object","sourcePos","rawSourcePos","skipHtml","includeElementIndex","linkTarget","transformImageUri","components","merge","xlink","xml","xmlns","aria","labelStartImage","after","asciiAtext","regexCheck","footnoteById","footnoteOrder","identifier","String","footnoteReference","markerType","stringType","atFirstTitleBreak","atTitleBreak","titleEscape","contents","tail","subtype","referenceType","suffix","label","u","all","unshift","asciiControl","autolink","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","ReactIs","svg","find","hastToReact","spaces","commas","style","toReact","tableElements","Set","child","childIndex","has","tagName","property","parentSchema","properties","space","addProperty","component","basic","isValidElementType","join","href","inline","level","parseInt","charAt","input","getInputElement","checked","Boolean","getElementsBeforeCount","ordered","depth","align","textAlign","isHeader","map","d","sourcePosition","siblingCount","count","prop","ctx","commaSeparated","stringify","v","k","styleReplacer","_","parseStyle","attribute","$1","toUpperCase","factory","displayName","isNaN","toLowerCase","unicodePunctuationRegex","unicodePunctuation","iterator","output","declarations","hasIterator","len","dangerous","augment","headingAtx","fenceOpenInside","headingBreak","contentEnd","Schema","DefinedInfo","definition","mustUseProperty","attributes","transform","normal","fn","callback","invoked","params","done","apply","error","then","Error","fromCharCode","visit","tree","onelement","remove","includes","parameters","Info","Type","valid","dash","camelcase","datasetToProperty","cap","kebab","datasetToAttribute","$0","atTab","powers","increment","Math","pow","boolean","booleanish","overloadedBoolean","number","spaceSeparated","commaOrSpaceSeparated","err","wrap","items","normalizeIdentifier","factoryDestination","factoryLabel","factoryWhitespace","factoryTitle","labelAfter","titleConstruct","before","labelStartLink","called","setextUnderline","paragraph","closingSequenceEnd","heading","htmlBlockNames","htmlRawNames","htmlFlow","startTag","declarationStart","continuationDeclarationInside","commentOpenInside","cdataOpenInside","basicSelfClosing","completeAttributeNameBefore","completeClosingTagAfter","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCharacterDataInside","continuationAtLineEnding","nextBlankConstruct","htmlContinueStart","continuationRawEndTag","concrete","row","out","cell","rows","alignLength","initial","flowInitial","afterConstruct","cache","normalise","getterFactory","gather","COMMENT_REGEX","NEWLINE_REGEX","WHITESPACE_REGEX","PROPERTY_REGEX","COLON_REGEX","VALUE_REGEX","SEMICOLON_REGEX","TRIM_REGEX","trim","str","lineno","updatePosition","lines","match","lastIndexOf","Position","whitespace","errorsList","msg","reason","filename","silent","re","m","exec","comments","rules","c","val","ret","decl","decls","subcontent","stream","entered","adjust","startPosition","startPositions","tokenizer","_tokenizer","childEvents","jumps","gaps","isInFirstContentOfListItem","_gfmTasklistFirstContentOfListItem","add","event","lineIndex","otherIndex","otherEvent","subevents","more","_movePreviousLineEndings","codeIndented","indentedContentConstruct","labelEnd","labelStart","_balanced","_inactive","balanced","afterLabelEnd","resourceConstruct","fullReferenceConstruct","collapsedReferenceConstruct","group","close","media","insideSpan","_used","destinationAfter","between","afterLabel","settings","allowDangerousHTML","deprecationWarningIssued","definitions","handlers","unknownHandler","passThrough","left","right","hName","hProperties","hChildren","generated","foot","footer","def","revert","VMessage","VFile","message","origin","path","file","fatal","messages","fail","codeFenced","closingFenceConstruct","initialPrefix","sequenceOpen","infoOpen","openAfter","infoAfter","meta","contentContinue","protocols","uri","first","colon","protocol","types","caseInsensitiveTransform","acceptcharset","classname","htmlfor","httpequiv","abbr","accept","acceptCharset","accessKey","action","allow","allowFullScreen","allowPaymentRequest","allowUserMedia","as","async","autoCapitalize","autoComplete","autoFocus","autoPlay","capture","charSet","cite","cols","colSpan","contentEditable","controls","controlsList","coords","crossOrigin","dateTime","decoding","defer","dir","dirName","disabled","download","draggable","encType","enterKeyHint","form","formAction","formEncType","formMethod","formNoValidate","formTarget","headers","height","hidden","high","hrefLang","htmlFor","httpEquiv","imageSizes","imageSrcSet","inputMode","integrity","is","isMap","itemId","itemProp","itemRef","itemScope","itemType","lang","language","loading","loop","low","manifest","maxLength","method","min","minLength","multiple","muted","nonce","noModule","noValidate","onAbort","onAfterPrint","onAuxClick","onBeforePrint","onBeforeUnload","onBlur","onCancel","onCanPlay","onCanPlayThrough","onChange","onClick","onClose","onContextMenu","onCopy","onCueChange","onCut","onDblClick","onDrag","onDragEnd","onDragEnter","onDragExit","onDragLeave","onDragOver","onDragStart","onDrop","onDurationChange","onEmptied","onEnded","onError","onFocus","onFormData","onHashChange","onInput","onInvalid","onKeyDown","onKeyPress","onKeyUp","onLanguageChange","onLoad","onLoadedData","onLoadedMetadata","onLoadEnd","onLoadStart","onMessage","onMessageError","onMouseDown","onMouseEnter","onMouseLeave","onMouseMove","onMouseOut","onMouseOver","onMouseUp","onOffline","onOnline","onPageHide","onPageShow","onPaste","onPause","onPlay","onPlaying","onPopState","onProgress","onRateChange","onRejectionHandled","onReset","onResize","onScroll","onSecurityPolicyViolation","onSeeked","onSeeking","onSelect","onSlotChange","onStalled","onStorage","onSubmit","onSuspend","onTimeUpdate","onToggle","onUnhandledRejection","onUnload","onVolumeChange","onWaiting","onWheel","optimum","pattern","ping","placeholder","playsInline","poster","preload","readOnly","referrerPolicy","rel","required","reversed","rowSpan","sandbox","scope","scoped","seamless","selected","shape","sizes","slot","span","spellCheck","srcDoc","srcLang","srcSet","step","tabIndex","translate","typeMustMatch","useMap","width","aLink","archive","axis","background","bgColor","border","borderColor","bottomMargin","cellPadding","cellSpacing","char","charOff","classId","clear","codeBase","codeType","color","compact","declare","face","frame","frameBorder","hSpace","leftMargin","link","longDesc","lowSrc","marginHeight","marginWidth","noResize","noHref","noShade","noWrap","profile","prompt","rev","rightMargin","scheme","scrolling","standby","summary","topMargin","valueType","version","vAlign","vLink","vSpace","allowTransparency","autoCorrect","autoSave","disablePictureInPicture","disableRemotePlayback","prefix","results","security","unselectable","text$1","attention","blockQuote","characterEscape","hardBreakEscape","lineEnding","42","43","45","48","49","50","51","52","53","54","55","56","57","62","91","32","35","60","61","95","96","126","38","92","33","93","split","whiteSpace","loose","asciiPunctuation","proto","chunkStart","el","characters","entity","innerHTML","textContent","b","f","g","l","n","p","q","r","w","Symbol","for","x","y","a","t","$$typeof","z","A","B","C","D","E","F","G","H","I","ContextConsumer","ContextProvider","Element","ForwardRef","Lazy","Memo","Portal","Profiler","StrictMode","Suspense","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isFragment","isLazy","isMemo","isPortal","isProfiler","isStrictMode","isSuspense","typeOf","getPrototypeOf","inspectResult","childFlow","childToken","continued","inspectConstruct","subcontinued","inspectStart","inspectContinue","inspectLess","flowContinue","inspectDone","interruptible","containerConstruct","inspectFlowEnd","lazyFlowConstruct","inspectLazy","flowEnd","documentContinue","documentContinued","flowStart","containerContinue","exitContainers","continueFlow","documentAfterPeek","base","bail","plain","trough","vfile","frozen","attachers","transformers","namespace","freezeIndex","assertUnfrozen","freeze","addPlugin","addList","addPreset","plugin","entry","doc","Parser","assertParser","newable","Compiler","assertCompiler","assertNode","compile","run","complete","assertDone","process","processSync","destination","transformer","Infinity","cb","Promise","executor","reject","pipeline","keys","asyncName","ignore","blockquote","break","delete","emphasis","footnote","imageReference","image","inlineCode","linkReference","listItem","root","strong","table","toml","yaml","footnoteDefinition","convert","typeFactory","tests","checks","anyFactory","allFactory","visitParents","CONTINUE","SKIP","EXIT","visitor","reverse","parents","VMessagePrototype","parts","range","location","parseOrigin","ruleId","ariaActiveDescendant","ariaAtomic","ariaAutoComplete","ariaBusy","ariaChecked","ariaColCount","ariaColIndex","ariaColSpan","ariaControls","ariaCurrent","ariaDescribedBy","ariaDetails","ariaDisabled","ariaDropEffect","ariaErrorMessage","ariaExpanded","ariaFlowTo","ariaGrabbed","ariaHasPopup","ariaHidden","ariaInvalid","ariaKeyShortcuts","ariaLabel","ariaLabelledBy","ariaLevel","ariaLive","ariaModal","ariaMultiLine","ariaMultiSelectable","ariaOrientation","ariaOwns","ariaPlaceholder","ariaPosInSet","ariaPressed","ariaReadOnly","ariaRelevant","ariaRequired","ariaRoleDescription","ariaRowCount","ariaRowIndex","ariaRowSpan","ariaSelected","ariaSetSize","ariaSort","ariaValueMax","ariaValueMin","ariaValueNow","ariaValueText","role","isBuffer","classifyCharacter","movePoint","_open","_close","nextEvents","xmlnsxlink","xmlnsXLink","backReference","listItems","xLinkActuate","xLinkArcRole","xLinkHref","xLinkRole","xLinkShow","xLinkTitle","xLinkType","xmlLang","xmlBase","xmlSpace","mdast2hast","bridge","mutate","unicodeWhitespace","spread","listItemLoose","listLoose","wrapped","literalType","literalMarkerType","rawType","limit","balance","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","labelEscape","returnNode","unknown","subresult","grandparents","toResult","search","atCarriageReturn","encoding","endPosition","lastIndex","ceil","extension","hook","existing","checksLength","mask","mark","continuationConstruct","prefixed","regex","proc","order","history","assertPart","part","sep","assertNonEmpty","assertPath","get","set","dirname","basename","extname","stem","absolute","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","normalizeString","JSON","ext","firstNonSlashEnd","seenNonSlash","extIndex","unmatchedSlash","startDot","startPart","preDotState","joined","fromMarkdown","mdastExtensions","padLeft","padRight","config","configure","transforms","canContainEols","opener","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","hardBreak","hardBreakTrailing","htmlFlowData","htmlTextData","_spread","listItemValue","getData","setData","listOrdered","listUnordered","reference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","closer","atxHeadingSequence","onexitdata","characterEscapeValue","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","safeFromInt","decode","resume","codeFencedFence","onexithardbreak","fragment","labelText","resource","setextHeadingLineSequence","setextHeadingText","handler","listStart","tokenStack","listStack","prepareList","stringifyPosition","tailIndex","tailEvent","firstBlankLineIndex","containerBalance","listSpread","and","siblings","compiler","postprocess","preprocessor","encodeCache","encode","exclude","keepEscaped","nextCode","defaultChars","ch","getEncodeCache","encodeURIComponent","componentChars","fns","middleware","caseSensitiveTransform","xtend","accentHeight","alignmentBaseline","arabicForm","baselineShift","capHeight","clipPath","clipRule","colorInterpolation","colorInterpolationFilters","colorProfile","colorRendering","dataType","dominantBaseline","enableBackground","fillOpacity","fillRule","floodColor","floodOpacity","fontFamily","fontSize","fontSizeAdjust","fontStretch","fontStyle","fontVariant","fontWeight","glyphName","glyphOrientationHorizontal","glyphOrientationVertical","horizAdvX","horizOriginX","horizOriginY","imageRendering","letterSpacing","lightingColor","markerEnd","markerMid","markerStart","navDown","navDownLeft","navDownRight","navLeft","navNext","navPrev","navRight","navUp","navUpLeft","navUpRight","onActivate","onBegin","onEnd","onFocusIn","onFocusOut","onMouseWheel","onRepeat","onShow","onZoom","overlinePosition","overlineThickness","paintOrder","panose1","pointerEvents","renderingIntent","shapeRendering","stopColor","stopOpacity","strikethroughPosition","strikethroughThickness","strokeDashArray","strokeDashOffset","strokeLineCap","strokeLineJoin","strokeMiterLimit","strokeOpacity","strokeWidth","textAnchor","textDecoration","textRendering","underlinePosition","underlineThickness","unicodeBidi","unicodeRange","unitsPerEm","vAlphabetic","vHanging","vIdeographic","vMathematical","vectorEffect","vertAdvY","vertOriginX","vertOriginY","wordSpacing","writingMode","xHeight","playbackOrder","timelineBegin","about","accumulate","additive","alphabetic","amplitude","ascent","attributeName","attributeType","azimuth","bandwidth","baseFrequency","baseProfile","bbox","begin","bias","by","calcMode","clip","clipPathUnits","contentScriptType","contentStyleType","cursor","cx","cy","defaultAction","descent","diffuseConstant","direction","display","dur","divisor","dx","dy","edgeMode","editable","elevation","exponent","externalResourcesRequired","fill","filterRes","filterUnits","focusable","focusHighlight","format","fr","fx","fy","g1","g2","glyphRef","gradientTransform","gradientUnits","hanging","hatchContentUnits","hatchUnits","ideographic","initialVisibility","in","in2","intercept","k1","k2","k3","k4","kernelMatrix","kernelUnitLength","keyPoints","keySplines","keyTimes","kerning","lengthAdjust","limitingConeAngle","local","markerHeight","markerUnits","markerWidth","maskContentUnits","maskUnits","mathematical","mediaCharacterEncoding","mediaContentEncodings","mediaSize","mediaTime","mode","numOctaves","observer","opacity","operator","orient","orientation","overflow","overlay","pathLength","patternContentUnits","patternTransform","patternUnits","phase","pitch","points","pointsAtX","pointsAtY","pointsAtZ","preserveAlpha","preserveAspectRatio","primitiveUnits","propagate","radius","refX","refY","repeatCount","repeatDur","requiredExtensions","requiredFeatures","requiredFonts","requiredFormats","restart","rotate","rx","ry","scale","seed","side","slope","snapshotTime","specularConstant","specularExponent","spreadMethod","spacing","startOffset","stdDeviation","stemh","stemv","stitchTiles","stroke","surfaceScale","syncBehavior","syncBehaviorDefault","syncMaster","syncTolerance","syncToleranceDefault","systemLanguage","tableValues","targetX","targetY","textLength","transformBehavior","u1","u2","unicode","viewBox","viewTarget","visibility","widths","x1","x2","xChannelSelector","y1","y2","yChannelSelector","zoomAndPan"],"mappings":";6FAIAA,EAAQC,IAER,WACE,MAAO,M,oCCLTC,OAAOC,eAAeH,EAAS,aAAc,CAC3CI,OAAO,IAGT,IAAIC,EAAS,EAAQ,QAEjBC,EAAU,EAAQ,QAElBC,EAAOC,EAAkB,QACzBC,EAASD,EAAkB,UAC3BE,EAAW,CACbC,WAAYC,KAGd,SAASJ,EAAkBK,GACzB,MAAO,CACLC,SAIF,SAAwBC,GACtB,IAAIC,EAAOC,KACPC,EAAaD,KAAKE,OAAOD,WAAWL,GACpCN,EAAOQ,EAAQK,QAAQF,EAAYG,EAAOC,GAC9C,OAAOD,EAEP,SAASA,EAAME,GACb,OAAOC,EAAQD,GAAQhB,EAAKgB,GAAQD,EAAQC,GAG9C,SAASD,EAAQC,GACf,GAAa,OAATA,EAOJ,OAFAR,EAAQU,MAAM,QACdV,EAAQW,QAAQH,GACTI,EANLZ,EAAQW,QAAQH,GASpB,SAASI,EAAKJ,GACZ,OAAIC,EAAQD,IACVR,EAAQa,KAAK,QACNrB,EAAKgB,KAIdR,EAAQW,QAAQH,GACTI,GAGT,SAASH,EAAQD,GACf,IAAIM,EAAOX,EAAWK,GAClBO,GAAS,EAEb,GAAa,OAATP,EACF,OAAO,EAGT,GAAIM,EACF,OAASC,EAAQD,EAAKE,QACpB,IAAKF,EAAKC,GAAOE,UAAYH,EAAKC,GAAOE,SAASC,KAAKjB,EAAMA,EAAKgB,UAChE,OAAO,IA9CfrB,WAAYC,EAAyB,SAAVC,EAAmBqB,OAAyBC,IAsD3E,SAASvB,EAAewB,GACtB,OAEA,SAAwBC,EAAQC,GAC9B,IACIb,EADAK,GAAS,EAIb,OAASA,GAASO,EAAON,aACTI,IAAVV,EACEY,EAAOP,IAAoC,SAA1BO,EAAOP,GAAO,GAAGS,OACpCd,EAAQK,EACRA,KAEQO,EAAOP,IAAoC,SAA1BO,EAAOP,GAAO,GAAGS,OAExCT,IAAUL,EAAQ,IACpBY,EAAOZ,GAAO,GAAGe,IAAMH,EAAOP,EAAQ,GAAG,GAAGU,IAC5CH,EAAOI,OAAOhB,EAAQ,EAAGK,EAAQL,EAAQ,GACzCK,EAAQL,EAAQ,GAGlBA,OAAQU,GAIZ,OAAOC,EAAgBA,EAAcC,EAAQC,GAAWD,GAW5D,SAASH,EAAuBG,EAAQC,GAWtC,IAVA,IACII,EACAf,EACAgB,EACAb,EACAc,EACAC,EACAC,EACAC,EARAC,GAAc,IAUTA,GAAcX,EAAON,QAC5B,IAAKiB,IAAeX,EAAON,QAAyC,eAA/BM,EAAOW,GAAY,GAAGT,OAA6D,SAAnCF,EAAOW,EAAa,GAAG,GAAGT,KAAiB,CAQ9H,IAPAZ,EAAOU,EAAOW,EAAa,GAAG,GAE9BlB,GADAY,EAASJ,EAAQW,YAAYtB,IACdI,OACfa,GAAe,EACfC,EAAO,EACPC,OAAOX,EAEAL,KAGL,GAAqB,iBAFrBa,EAAQD,EAAOZ,IAEgB,CAG7B,IAFAc,EAAcD,EAAMZ,OAEyB,KAAtCY,EAAMO,WAAWN,EAAc,IACpCC,IACAD,IAGF,GAAIA,EAAa,MACjBA,GAAe,OAEZ,IAAe,IAAXD,EACLG,GAAO,EACPD,SACK,IAAe,IAAXF,EAAoB,CAE7Bb,IACA,MAIFe,IACFE,EAAQ,CACNR,KAAMS,IAAeX,EAAON,QAAUe,GAAQD,EAAO,EAAI,aAAe,oBACxExB,MAAO,CACL8B,KAAMxB,EAAKa,IAAIW,KACfC,OAAQzB,EAAKa,IAAIY,OAASP,EAC1BQ,OAAQ1B,EAAKa,IAAIa,OAASR,EAC1BS,OAAQ3B,EAAKN,MAAMiC,OAASxB,EAC5ByB,aAAczB,EAAQc,EAAcjB,EAAKN,MAAMkC,aAAeX,GAEhEJ,IAAKlC,EAAQqB,EAAKa,MAEpBb,EAAKa,IAAMlC,EAAQyC,EAAM1B,OAErBM,EAAKN,MAAMgC,SAAW1B,EAAKa,IAAIa,OACjChD,EAAOsB,EAAMoB,IAEbV,EAAOI,OAAOO,EAAY,EAAG,CAAC,QAASD,EAAOT,GAAU,CAAC,OAAQS,EAAOT,IACxEU,GAAc,IAIlBA,IAIJ,OAAOX,EAGTrC,EAAQU,SAAWA,EACnBV,EAAQS,OAASA,EACjBT,EAAQO,KAAOA,G,oCChLfiD,EAAOxD,QAPP,SAAmByD,EAAOJ,GAIxB,OAHAI,EAAML,QAAUC,EAChBI,EAAMJ,QAAUA,EAChBI,EAAMF,cAAgBF,EACfI,I,oCCJT,IAAIC,EAAqB,EAAQ,QAE7BC,EAAW,CACbC,KAAM,WACN9C,SAwDF,SAA0BC,EAAS8C,EAAIC,GACrC,IACIjB,EACAE,EAFAgB,EAAW,EAGf,OAEA,SAAexC,GAGb,OAFAR,EAAQU,MAAM,YACdV,EAAQU,MAAM,oBACPuC,EAAgBzC,IAGzB,SAASyC,EAAgBzC,GACvB,OAAa,KAATA,GACFR,EAAQW,QAAQH,GAChBwC,IACOC,IAGTjD,EAAQa,KAAK,oBACNqC,EAAI1C,IAGb,SAAS0C,EAAI1C,GAEX,OAAa,OAATA,EACKuC,EAAIvC,GAKA,KAATA,GACFwB,EAAQhC,EAAQU,MAAM,oBACtBoB,EAAO,EACAqB,EAAgB3C,IAIZ,KAATA,GACFR,EAAQU,MAAM,SACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,SACNqC,GAGLP,EAAmBnC,IACrBR,EAAQU,MAAM,cACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,cACNqC,IAITlD,EAAQU,MAAM,gBACPE,EAAKJ,IAId,SAASI,EAAKJ,GACZ,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAemC,EAAmBnC,IACpER,EAAQa,KAAK,gBACNqC,EAAI1C,KAGbR,EAAQW,QAAQH,GACTI,GAIT,SAASuC,EAAgB3C,GAEvB,OAAa,KAATA,GACFR,EAAQW,QAAQH,GAChBsB,IACOqB,GAILrB,IAASkB,GACXhD,EAAQa,KAAK,oBACbb,EAAQa,KAAK,YACNiC,EAAGtC,KAIZwB,EAAMR,KAAO,eACNZ,EAAKJ,MA7Id4C,QAIF,SAAyB9B,GACvB,IAEIP,EACAL,EAHA2C,EAAgB/B,EAAON,OAAS,EAChCsC,EAAiB,EAIrB,KAAwC,eAAnChC,EAAOgC,GAAgB,GAAG9B,MAA4D,UAAnCF,EAAOgC,GAAgB,GAAG9B,MAAwD,eAAlCF,EAAO+B,GAAe,GAAG7B,MAA2D,UAAlCF,EAAO+B,GAAe,GAAG7B,MAGjL,IAFAT,EAAQuC,IAECvC,EAAQsC,GACf,GAA8B,iBAA1B/B,EAAOP,GAAO,GAAGS,KAAyB,CAE5CF,EAAO+B,GAAe,GAAG7B,KAAOF,EAAOgC,GAAgB,GAAG9B,KAAO,kBACjE8B,GAAkB,EAClBD,GAAiB,EACjB,MAMNtC,EAAQuC,EAAiB,EACzBD,IAEA,OAAStC,GAASsC,QACFjC,IAAVV,EACEK,IAAUsC,GAA2C,eAA1B/B,EAAOP,GAAO,GAAGS,OAC9Cd,EAAQK,GAEDA,IAAUsC,GAA2C,eAA1B/B,EAAOP,GAAO,GAAGS,OACrDF,EAAOZ,GAAO,GAAGc,KAAO,eAEpBT,IAAUL,EAAQ,IACpBY,EAAOZ,GAAO,GAAGe,IAAMH,EAAOP,EAAQ,GAAG,GAAGU,IAC5CH,EAAOI,OAAOhB,EAAQ,EAAGK,EAAQL,EAAQ,GACzC2C,GAAiBtC,EAAQL,EAAQ,EACjCK,EAAQL,EAAQ,GAGlBA,OAAQU,GAIZ,OAAOE,GA9CPL,SAiDF,SAAkBT,GAEhB,OAAgB,KAATA,GAA+D,oBAAhDN,KAAKoB,OAAOpB,KAAKoB,OAAON,OAAS,GAAG,GAAGQ,OA6F/DiB,EAAOxD,QAAU2D,G,oCCtJjB,IAAIW,EAAM,GAAGC,eA4Bb,SAASd,EAAMA,GAKb,OAJKA,GAA0B,iBAAVA,IACnBA,EAAQ,IAGH3B,EAAM2B,EAAMN,MAAQ,IAAMrB,EAAM2B,EAAML,QAG/C,SAASoB,EAASC,GAKhB,OAJKA,GAAsB,iBAARA,IACjBA,EAAM,IAGDhB,EAAMgB,EAAIpD,OAAS,IAAMoC,EAAMgB,EAAIjC,KAG5C,SAASV,EAAM1B,GACb,OAAOA,GAA0B,iBAAVA,EAAqBA,EAAQ,EA5CtDoD,EAAOxD,QAEP,SAAmBI,GAEjB,IAAKA,GAA0B,iBAAVA,EACnB,MAAO,GAIT,GAAIkE,EAAIrC,KAAK7B,EAAO,aAAekE,EAAIrC,KAAK7B,EAAO,QACjD,OAAOoE,EAASpE,EAAMoE,UAIxB,GAAIF,EAAIrC,KAAK7B,EAAO,UAAYkE,EAAIrC,KAAK7B,EAAO,OAC9C,OAAOoE,EAASpE,GAIlB,GAAIkE,EAAIrC,KAAK7B,EAAO,SAAWkE,EAAIrC,KAAK7B,EAAO,UAC7C,OAAOqD,EAAMrD,GAIf,MAAO,K,oCCzBT,IAAIsE,EAAU,EAAQ,QAElBC,EAAW,EAAQ,QAEnBC,EAAO,EAAQ,QAEfrE,EAAO,EAAQ,QAEfsE,EAAoB,EAAQ,QAE5BC,EAAkB,EAAQ,QAE1BC,EAAW,EAAQ,QAEnB7D,EAAa,EAAQ,QAwBzBsC,EAAOxD,QAtBP,SAAegF,GACb,IACI7D,EAAS,CACX8D,QAAS,GACT/D,WAAY2D,EAAkB,CAAC3D,GAAYgE,OAAOH,GAHrCC,GAAW,IAG4CG,cACpET,QAASU,EAAOV,GAChBC,SAAUS,EAAOT,GACjBC,KAAMQ,EAAOR,GACbnE,OAAQ2E,EAAO7E,EAAKE,QACpBF,KAAM6E,EAAO7E,EAAKA,OAEpB,OAAOY,EAEP,SAASiE,EAAOC,GACd,OAEA,SAAiBC,GACf,OAAOR,EAAgB3D,EAAQkE,EAAaC,O,oCCjClD,IAAI7C,EAAS,GAAGA,OAChBe,EAAOxD,QAAUyC,G,oCCDjBvC,OAAOC,eAAeH,EAAS,aAAc,CAC3CI,OAAO,IAGT,IAAIsD,EAAqB,EAAQ,QAE7B6B,EAAe,EAAQ,QAEvBzE,EAEJ,SAA2BC,GACzB,IACIiB,EADAwD,EAAezE,EAAQK,QAAQH,KAAKE,OAAOD,WAAWuE,gBAI1D,SAAoClE,GAClC,GAAa,OAATA,EAEF,YADAR,EAAQW,QAAQH,GAOlB,OAHAR,EAAQU,MAAM,cACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,cACN2D,EAAaxE,EAASyE,EAAc,iBAG7C,SAA0BjE,GAExB,OADAR,EAAQU,MAAM,aACPiE,EAAUnE,MAhBnB,OAAOiE,EAmBP,SAASE,EAAUnE,GACjB,IAAIwB,EAAQhC,EAAQU,MAAM,YAAa,CACrCkE,YAAa,OACb3D,SAAUA,IAQZ,OALIA,IACFA,EAAS4D,KAAO7C,GAGlBf,EAAWe,EACJpB,EAAKJ,GAGd,SAASI,EAAKJ,GACZ,OAAa,OAATA,GACFR,EAAQa,KAAK,aACbb,EAAQa,KAAK,kBACbb,EAAQW,QAAQH,IAIdmC,EAAmBnC,IACrBR,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,aACN8D,IAIT3E,EAAQW,QAAQH,GACTI,KAIX3B,EAAQc,SAAWA,G,oCClEnB,IAAI4C,EAAqB,EAAQ,QAE7BmC,EAAgB,EAAQ,QAExBN,EAAe,EAAQ,QAuB3B/B,EAAOxD,QArBP,SAA2Be,EAAS8C,GAClC,IAAIiC,EACJ,OAEA,SAASzE,EAAME,GACb,GAAImC,EAAmBnC,GAKrB,OAJAR,EAAQU,MAAM,cACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,cACbkE,GAAO,EACAzE,EAGT,GAAIwE,EAActE,GAChB,OAAOgE,EAAaxE,EAASM,EAAOyE,EAAO,aAAe,aAAnDP,CAAiEhE,GAG1E,OAAOsC,EAAGtC,M,oCCvBd,IAAIwE,EAAc,EAAQ,QAS1BvC,EAAOxD,QAPP,SAAqBqC,GACnB,MAAQ0D,EAAY1D,KAGpB,OAAOA,I,oCCkBTmB,EAAOxD,QAxBP,SAAqB0C,EAAQK,GAC3B,IAIIiD,EAJAC,EAAalD,EAAM1B,MAAMiC,OACzB4C,EAAmBnD,EAAM1B,MAAMkC,aAC/B4C,EAAWpD,EAAMP,IAAIc,OACrB8C,EAAiBrD,EAAMP,IAAIe,aAiB/B,OAdI0C,IAAeE,EACjBH,EAAO,CAACtD,EAAOuD,GAAYI,MAAMH,EAAkBE,KAEnDJ,EAAOtD,EAAO2D,MAAMJ,EAAYE,GAE5BD,GAAoB,IACtBF,EAAK,GAAKA,EAAK,GAAGK,MAAMH,IAGtBE,EAAiB,GACnBJ,EAAKM,KAAK5D,EAAOyD,GAAUE,MAAM,EAAGD,KAIjCJ,I,oCCrBT,IAAIO,EAAY,EAAQ,QAExB/C,EAAOxD,QAEP,SAAewG,EAAGC,GAChB,IAAIC,EAAQ,CACVC,IAAKJ,EAAUE,EAAKG,KACpBC,IAAKJ,EAAKI,KAGO,OAAfJ,EAAKK,YAAiC3E,IAAfsE,EAAKK,QAC9BJ,EAAMI,MAAQL,EAAKK,OAGrB,OAAON,EAAEC,EAAM,MAAOC,K,oCCVxBlD,EAAOxD,QAJP,SAAuBuB,GACrB,OAAiB,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,I,oCCDvCiC,EAAOxD,QAIP,SAAawG,EAAGO,GACd,IAIIC,EACAC,EALAC,EAAQH,EAAOI,UAAY,GAC3BpF,EAASmF,EAAMnF,OACfqF,EAAS,GACTtF,GAAS,EAIb,OAASA,EAAQC,IACfiF,EAASK,EAAIb,EAAGU,EAAMpF,GAAQiF,MAGxBjF,GAAmC,UAA1BoF,EAAMpF,EAAQ,GAAGS,OACxByE,EAAO5G,QACT4G,EAAO5G,MAAQ4G,EAAO5G,MAAMkH,QAAQ,OAAQ,MAG9CL,EAAOD,EAAOG,UAAYH,EAAOG,SAAS,KAE9BF,EAAK7G,QACf6G,EAAK7G,MAAQ6G,EAAK7G,MAAMkH,QAAQ,OAAQ,MAI5CF,EAASA,EAAOlC,OAAO8B,IAI3B,OAAOI,GA9BT,IAAIC,EAAM,EAAQ,S,oCCFlB,IAAI3D,EAAqB,EAAQ,QAE7BmC,EAAgB,EAAQ,QAExBN,EAAe,EAAQ,QAEvBgC,EAAgB,CAClB3D,KAAM,gBACN9C,SAGF,SAA+BC,EAAS8C,EAAIC,GAC1C,IACI0D,EADA3E,EAAO,EAEX,OAEA,SAAetB,GAGb,OAFAR,EAAQU,MAAM,iBACd+F,EAASjG,EACFC,EAAQD,IAGjB,SAASC,EAAQD,GACf,OAAIA,IAASiG,GACXzG,EAAQU,MAAM,yBACPgG,EAASlG,IAGdsE,EAActE,GACTgE,EAAaxE,EAASS,EAAS,aAA/B+D,CAA6ChE,GAGlDsB,EAAO,GAAc,OAATtB,IAAkBmC,EAAmBnC,GAC5CuC,EAAIvC,IAGbR,EAAQa,KAAK,iBACNiC,EAAGtC,IAGZ,SAASkG,EAASlG,GAChB,OAAIA,IAASiG,GACXzG,EAAQW,QAAQH,GAChBsB,IACO4E,IAGT1G,EAAQa,KAAK,yBACNJ,EAAQD,OAInBiC,EAAOxD,QAAUuH,G,oCCpDjB,IAAIG,EAAa,EAAQ,QAErBC,EAAoB,EAAQ,QAE5BjE,EAAqB,EAAQ,QAE7BkE,EAA4B,EAAQ,QAEpC/B,EAAgB,EAAQ,QAExBN,EAAe,EAAQ,QAEvBsC,EAAW,CACbjE,KAAM,WACN9C,SAGF,SAA0BC,EAAS8C,EAAIC,GACrC,IACI0D,EACAM,EACAhG,EACAiG,EAJA/G,EAAOC,KAKX,OAEA,SAAeM,GAIb,OAHAR,EAAQU,MAAM,YACdV,EAAQU,MAAM,gBACdV,EAAQW,QAAQH,GACTyG,GAGT,SAASA,EAAKzG,GACZ,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACT0G,GAGI,KAAT1G,GACFR,EAAQW,QAAQH,GACT2G,GAGI,KAAT3G,GACFR,EAAQW,QAAQH,GACT4G,GAGLT,EAAWnG,IACbR,EAAQW,QAAQH,GACT6G,GAGFtE,EAAIvC,GAGb,SAAS0G,EAAgB1G,GACvB,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACT8G,GAGI,KAAT9G,GACFR,EAAQW,QAAQH,GAChBuG,EAAS,SACThG,EAAQ,EACDwG,GAGLZ,EAAWnG,IACbR,EAAQW,QAAQH,GACTgH,GAGFzE,EAAIvC,GAGb,SAAS8G,EAAY9G,GACnB,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACTiH,GAGF1E,EAAIvC,GAGb,SAASiH,EAAajH,GACpB,OAAa,OAATA,GAA0B,KAATA,EACZuC,EAAIvC,GAGA,KAATA,GACFR,EAAQW,QAAQH,GACTkH,GAGFC,EAAQnH,GAGjB,SAASkH,EAAiBlH,GACxB,OAAa,OAATA,GAA0B,KAATA,EACZuC,EAAIvC,GAGNmH,EAAQnH,GAGjB,SAASmH,EAAQnH,GACf,OAAa,OAATA,EACKuC,EAAIvC,GAGA,KAATA,GACFR,EAAQW,QAAQH,GACToH,GAGLjF,EAAmBnC,IACrBwG,EAAcW,EACPE,EAAarH,KAGtBR,EAAQW,QAAQH,GACTmH,GAGT,SAASC,EAAapH,GACpB,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACTiB,GAGFkG,EAAQnH,GAGjB,SAAS+G,EAAU/G,GACjB,OAAIA,IAASuG,EAAO5E,WAAWpB,MAC7Bf,EAAQW,QAAQH,GACTO,IAAUgG,EAAO/F,OAAS8G,EAAQP,GAGpCxE,EAAIvC,GAGb,SAASsH,EAAMtH,GACb,OAAa,OAATA,EACKuC,EAAIvC,GAGA,KAATA,GACFR,EAAQW,QAAQH,GACTuH,GAGLpF,EAAmBnC,IACrBwG,EAAcc,EACPD,EAAarH,KAGtBR,EAAQW,QAAQH,GACTsH,GAGT,SAASC,EAAWvH,GAClB,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACTwH,GAGFF,EAAMtH,GAGf,SAASwH,EAASxH,GAChB,OAAa,KAATA,EACKiB,EAAIjB,GAGA,KAATA,GACFR,EAAQW,QAAQH,GACTwH,GAGFF,EAAMtH,GAGf,SAASgH,EAAYhH,GACnB,OAAa,OAATA,GAA0B,KAATA,EACZiB,EAAIjB,GAGTmC,EAAmBnC,IACrBwG,EAAcQ,EACPK,EAAarH,KAGtBR,EAAQW,QAAQH,GACTgH,GAGT,SAASJ,EAAY5G,GACnB,OAAa,OAATA,EACKuC,EAAIvC,GAGA,KAATA,GACFR,EAAQW,QAAQH,GACTyH,GAGLtF,EAAmBnC,IACrBwG,EAAcI,EACPS,EAAarH,KAGtBR,EAAQW,QAAQH,GACT4G,GAGT,SAASa,EAAiBzH,GACxB,OAAgB,KAATA,EAAciB,EAAIjB,GAAQ4G,EAAY5G,GAG/C,SAAS2G,EAAc3G,GACrB,OAAImG,EAAWnG,IACbR,EAAQW,QAAQH,GACT0H,GAGFnF,EAAIvC,GAGb,SAAS0H,EAAS1H,GAChB,OAAa,KAATA,GAAeoG,EAAkBpG,IACnCR,EAAQW,QAAQH,GACT0H,GAGFC,EAAgB3H,GAGzB,SAAS2H,EAAgB3H,GACvB,OAAImC,EAAmBnC,IACrBwG,EAAcmB,EACPN,EAAarH,IAGlBsE,EAActE,IAChBR,EAAQW,QAAQH,GACT2H,GAGF1G,EAAIjB,GAGb,SAAS6G,EAAQ7G,GACf,OAAa,KAATA,GAAeoG,EAAkBpG,IACnCR,EAAQW,QAAQH,GACT6G,GAGI,KAAT7G,GAAwB,KAATA,GAAeqG,EAA0BrG,GACnD4H,EAAe5H,GAGjBuC,EAAIvC,GAGb,SAAS4H,EAAe5H,GACtB,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACTiB,GAGI,KAATjB,GAAwB,KAATA,GAAemG,EAAWnG,IAC3CR,EAAQW,QAAQH,GACT6H,GAGL1F,EAAmBnC,IACrBwG,EAAcoB,EACPP,EAAarH,IAGlBsE,EAActE,IAChBR,EAAQW,QAAQH,GACT4H,GAGF3G,EAAIjB,GAGb,SAAS6H,EAAqB7H,GAC5B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAeoG,EAAkBpG,IAChFR,EAAQW,QAAQH,GACT6H,GAGFC,EAA0B9H,GAGnC,SAAS8H,EAA0B9H,GACjC,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACT+H,GAGL5F,EAAmBnC,IACrBwG,EAAcsB,EACPT,EAAarH,IAGlBsE,EAActE,IAChBR,EAAQW,QAAQH,GACT8H,GAGFF,EAAe5H,GAGxB,SAAS+H,EAA4B/H,GACnC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzDuC,EAAIvC,GAGA,KAATA,GAAwB,KAATA,GACjBR,EAAQW,QAAQH,GAChBiG,EAASjG,EACFgI,GAGL7F,EAAmBnC,IACrBwG,EAAcuB,EACPV,EAAarH,IAGlBsE,EAActE,IAChBR,EAAQW,QAAQH,GACT+H,IAGTvI,EAAQW,QAAQH,GAChBiG,OAASrF,EACFqH,GAGT,SAASD,EAA4BhI,GACnC,OAAIA,IAASiG,GACXzG,EAAQW,QAAQH,GACTkI,GAGI,OAATlI,EACKuC,EAAIvC,GAGTmC,EAAmBnC,IACrBwG,EAAcwB,EACPX,EAAarH,KAGtBR,EAAQW,QAAQH,GACTgI,GAGT,SAASE,EAAiClI,GACxC,OAAa,KAATA,GAAwB,KAATA,GAAeqG,EAA0BrG,GACnD4H,EAAe5H,GAGjBuC,EAAIvC,GAGb,SAASiI,EAA8BjI,GACrC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACxEuC,EAAIvC,GAGA,KAATA,GAAeqG,EAA0BrG,GACpC4H,EAAe5H,IAGxBR,EAAQW,QAAQH,GACTiI,GAKT,SAASZ,EAAarH,GAKpB,OAJAR,EAAQa,KAAK,gBACbb,EAAQU,MAAM,cACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,cACN2D,EAAaxE,EAAS2I,EAAa,aAAc1I,EAAKG,OAAOD,WAAWyI,QAAQC,KAAKC,QAAQ,iBAAmB,OAAI1H,EAAY,GAGzI,SAASuH,EAAYnI,GAEnB,OADAR,EAAQU,MAAM,gBACPsG,EAAYxG,GAGrB,SAASiB,EAAIjB,GACX,OAAa,KAATA,GACFR,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,gBACbb,EAAQa,KAAK,YACNiC,GAGFC,EAAIvC,MAIfiC,EAAOxD,QAAU6H,G,oCC5ZjB,IAAIiC,EAAe,EAAQ,QAEvBnC,EAAoB,EAAQ,QAE5BoC,EAAa,EAAQ,QAErBC,EAAgB,EAAQ,QAE5B,SAASC,EAAsBC,GAC7B,OAAOA,GAAkB,iBAANA,GAAkB,YAAaA,EAAIA,EAAI,CACxDC,QAASD,GAIb,IAAIE,EAAqCH,EAAsBH,GAE3DO,EAAqB,CACvBzG,KAAM,qBACN9C,SAGF,SAAoCC,EAAS8C,EAAIC,GAC/C,IAEIwG,EACAC,EAHAvJ,EAAOC,KACP4B,EAAO,EAGX,OAEA,SAAetB,GAKb,OAJAR,EAAQU,MAAM,sBACdV,EAAQU,MAAM,4BACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,4BACNoG,GAGT,SAASA,EAAKzG,GACZ,OAAa,KAATA,GACFR,EAAQU,MAAM,mCACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,mCACN4I,IAGTzJ,EAAQU,MAAM,2BACd6I,EAAM,GACNC,EAAO5C,EACAvH,EAAMmB,IAGf,SAASiJ,EAAQjJ,GACf,OAAa,KAATA,GAAwB,MAATA,GACjBR,EAAQU,MAAM,uCACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,uCACbb,EAAQU,MAAM,2BACd6I,EAAM,EACNC,EAAOP,EACA5J,IAGTW,EAAQU,MAAM,2BACd6I,EAAM,EACNC,EAAOR,EACA3J,EAAMmB,IAGf,SAASnB,EAAMmB,GACb,IAAIwB,EAEJ,OAAa,KAATxB,GAAesB,GACjBE,EAAQhC,EAAQa,KAAK,2BAEjB2I,IAAS5C,GAAsByC,EAA+B,QAAEpJ,EAAKyJ,eAAe1H,KAIxFhC,EAAQU,MAAM,4BACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,4BACbb,EAAQa,KAAK,sBACNiC,GAPEC,EAAIvC,IAUXgJ,EAAKhJ,IAASsB,IAASyH,GACzBvJ,EAAQW,QAAQH,GACTnB,GAGF0D,EAAIvC,MAIfiC,EAAOxD,QAAUqK,G,oCC7FjB,IAAIN,EAAa,EAAQ,QAErBlE,EAAgB,EAAQ,QAExB6E,EAAa,EAAQ,QAErBC,EAAa,EAAQ,QAErBpF,EAAe,EAAQ,QAEvBqF,EAAmB,EAAQ,QAE3BrD,EAAgB,EAAQ,QAExB1F,EAAO,CACT+B,KAAM,OACN9C,SAeF,SAA2BC,EAAS8C,EAAIC,GACtC,IAAI9C,EAAOC,KACP4J,EAAcH,EAAW1J,EAAKqB,OAAQ,cACtCQ,EAAO,EACX,OAEA,SAAetB,GACb,IAAIuJ,EAAO9J,EAAK+J,eAAexI,OAAkB,KAAThB,GAAwB,KAATA,GAAwB,KAATA,EAAc,gBAAkB,eAEtG,GAAa,kBAATuJ,GAA4B9J,EAAK+J,eAAevD,QAAUjG,IAASP,EAAK+J,eAAevD,OAASuC,EAAWxI,GAAO,CAQpH,GAPKP,EAAK+J,eAAexI,OACvBvB,EAAK+J,eAAexI,KAAOuI,EAC3B/J,EAAQU,MAAMqJ,EAAM,CAClBE,YAAY,KAIH,kBAATF,EAEF,OADA/J,EAAQU,MAAM,kBACE,KAATF,GAAwB,KAATA,EAAcR,EAAQkK,MAAM1D,EAAezD,EAAKoH,EAAlCnK,CAA4CQ,GAAQ2J,EAAS3J,GAGnG,IAAKP,EAAKmK,WAAsB,KAAT5J,EAGrB,OAFAR,EAAQU,MAAM,kBACdV,EAAQU,MAAM,iBACP2J,EAAO7J,GAIlB,OAAOuC,EAAIvC,IAGb,SAAS6J,EAAO7J,GACd,OAAIwI,EAAWxI,MAAWsB,EAAO,IAC/B9B,EAAQW,QAAQH,GACT6J,KAGHpK,EAAKmK,WAAatI,EAAO,KAAO7B,EAAK+J,eAAevD,OAASjG,IAASP,EAAK+J,eAAevD,OAAkB,KAATjG,GAAwB,KAATA,IACtHR,EAAQa,KAAK,iBACNsJ,EAAS3J,IAGXuC,EAAIvC,GAGb,SAAS2J,EAAS3J,GAKhB,OAJAR,EAAQU,MAAM,kBACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,kBACbZ,EAAK+J,eAAevD,OAASxG,EAAK+J,eAAevD,QAAUjG,EACpDR,EAAQkK,MAAML,EACrB5J,EAAKmK,UAAYrH,EAAMuH,EAAStK,EAAQK,QAAQkK,EAAmCC,EAAaC,IAGlG,SAASH,EAAQ9J,GAGf,OAFAP,EAAK+J,eAAeU,kBAAmB,EACvCZ,IACOU,EAAYhK,GAGrB,SAASiK,EAAYjK,GACnB,OAAIsE,EAActE,IAChBR,EAAQU,MAAM,4BACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,4BACN2J,GAGFzH,EAAIvC,GAGb,SAASgK,EAAYhK,GAEnB,OADAP,EAAK+J,eAAelI,KAAOgI,EAAcF,EAAW3J,EAAKiC,YAAYlC,EAAQa,KAAK,oBAC3EiC,EAAGtC,KAxFZmK,aAAc,CACZ5K,SA2FJ,SAAkCC,EAAS8C,EAAIC,GAC7C,IAAI9C,EAAOC,KAEX,OADAD,EAAK+J,eAAeY,gBAAaxJ,EAC1BpB,EAAQkK,MAAML,GAErB,SAAiBrJ,GAIf,OAHAP,EAAK+J,eAAea,kBAAoB5K,EAAK+J,eAAea,mBAAqB5K,EAAK+J,eAAeU,iBAG9FlG,EAAaxE,EAAS8C,EAAI,iBAAkB7C,EAAK+J,eAAelI,KAAO,EAAvE0C,CAA0EhE,MAGnF,SAAkBA,GAChB,GAAIP,EAAK+J,eAAea,oBAAsB/F,EAActE,GAE1D,OADAP,EAAK+J,eAAea,kBAAoB5K,EAAK+J,eAAeU,sBAAmBtJ,EACxE0J,EAAiBtK,GAI1B,OADAP,EAAK+J,eAAea,kBAAoB5K,EAAK+J,eAAeU,sBAAmBtJ,EACxEpB,EAAQK,QAAQ0K,EAAiBjI,EAAIgI,EAArC9K,CAAuDQ,MAGhE,SAASsK,EAAiBtK,GAKxB,OAHAP,EAAK+J,eAAeY,YAAa,EAEjC3K,EAAKmK,eAAYhJ,EACVoD,EAAaxE,EAASA,EAAQK,QAAQS,EAAMgC,EAAIC,GAAM,aAAc9C,EAAKG,OAAOD,WAAWyI,QAAQC,KAAKC,QAAQ,iBAAmB,OAAI1H,EAAY,EAAnJoD,CAAsJhE,MApH/JK,KAiIF,SAAyBb,GACvBA,EAAQa,KAAKX,KAAK8J,eAAexI,QAhI/B+I,EAAoC,CACtCxK,SAkIF,SAA0CC,EAAS8C,EAAIC,GACrD,IAAI9C,EAAOC,KACX,OAAOsE,EAAaxE,GAEpB,SAAqBQ,GACnB,OAAOsE,EAActE,KAAUmJ,EAAW1J,EAAKqB,OAAQ,4BAA8ByB,EAAIvC,GAAQsC,EAAGtC,KAH5D,2BAA4BP,EAAKG,OAAOD,WAAWyI,QAAQC,KAAKC,QAAQ,iBAAmB,OAAI1H,EAAY,IAnIrJ4J,SAAS,GAEPD,EAAkB,CACpBhL,SAiHF,SAAwBC,EAAS8C,EAAIC,GACnC,IAAI9C,EAAOC,KACX,OAAOsE,EAAaxE,GAEpB,SAAqBQ,GACnB,OAAOmJ,EAAW1J,EAAKqB,OAAQ,oBAAsBrB,EAAK+J,eAAelI,KAAOgB,EAAGtC,GAAQuC,EAAIvC,KAHvD,iBAAkBP,EAAK+J,eAAelI,KAAO,IAlHvFkJ,SAAS,GAsIXvI,EAAOxD,QAAU6B,G,oCClKjB,IAAIxB,EAAS,EAAQ,QAEjBqD,EAAqB,EAAQ,QAE7BsI,EAAc,EAAQ,QAEtBC,EAAgB,EAAQ,QAExBlH,EAAW,EAAQ,QAEnBpE,EAAa,EAAQ,QAErBuL,EAAkB,EAAQ,QAE1B5L,EAAU,EAAQ,QAElB6L,EAAc,EAAQ,QAqS1B3I,EAAOxD,QA5RP,SAAyBmB,EAAQiL,EAAY9G,GAC3C,IAAI7B,EAAQ6B,EAAOhF,EAAQgF,GAAQ,CACjCnC,KAAM,EACNC,OAAQ,EACRC,OAAQ,GAENgJ,EAAc,GACdC,EAAuB,GACvB5J,EAAS,GACT6J,EAAQ,GACRxL,EAAU,CACZW,QA2GF,SAAiBH,GACXmC,EAAmBnC,IACrBkC,EAAMN,OACNM,EAAML,OAAS,EACfK,EAAMJ,SAAoB,IAAV9B,EAAc,EAAI,EAClCiL,MACmB,IAAVjL,IACTkC,EAAML,SACNK,EAAMJ,UAIJI,EAAMF,aAAe,EACvBE,EAAMH,UAENG,EAAMF,eAEFE,EAAMF,eAAiBb,EAAOe,EAAMH,QAAQvB,SAC9C0B,EAAMF,cAAgB,EACtBE,EAAMH,WAKVhB,EAAQN,SAAWT,GAlInBE,MAsIF,SAAec,EAAMkK,GACnB,IAAI1J,EAAQ0J,GAAU,GAKtB,OAJA1J,EAAMR,KAAOA,EACbQ,EAAM1B,MAAQqL,IACdpK,EAAQD,OAAOiE,KAAK,CAAC,QAASvD,EAAOT,IACrCiK,EAAMjG,KAAKvD,GACJA,GA3IPnB,KA+IF,SAAcW,GACZ,IAAIQ,EAAQwJ,EAAMI,MAGlB,OAFA5J,EAAMP,IAAMkK,IACZpK,EAAQD,OAAOiE,KAAK,CAAC,OAAQvD,EAAOT,IAC7BS,GAlJP3B,QAASwL,GAsJX,SAA+BC,EAAWC,GACxCC,EAAUF,EAAWC,EAAKxH,SAtJ1B2F,MAAO2B,EAAiBI,GACxB7B,UAAWyB,EAAiBI,EAAmB,CAC7C7B,WAAW,IAEb8B,KAAML,EAAiBI,EAAmB,CACxCC,MAAM,KAIN3K,EAAU,CACZN,SAAU,KACVK,OAAQ,GACRlB,OAAQA,EACR8B,YAAaA,EACbwH,eAkCF,SAAwB1H,GACtB,OAAOmJ,EAAgBjJ,EAAYF,KAlCnC2J,IAAKA,EACLQ,WA4CF,SAAc9M,GACZiM,EAAYjM,EAAM+C,MAAQ/C,EAAMgD,OAChCoJ,KA7CAW,MAcF,SAAe9G,GAIb,GAHA3D,EAASsJ,EAAYtJ,EAAQ2D,GAC7B+G,IAEkC,OAA9B1K,EAAOA,EAAOX,OAAS,GACzB,MAAO,GAMT,OAHAgL,EAAUX,EAAY,GAEtB9J,EAAQD,OAAS1B,EAAW2L,EAAsBhK,EAAQD,OAAQC,GAC3DA,EAAQD,SAtBbgL,EAAQjB,EAAWtL,SAASmB,KAAKK,EAASvB,GAS9C,OAPIqL,EAAWzL,YACb2L,EAAqBhG,KAAK8F,GAI5B3I,EAAMH,OAAS,EACfG,EAAMF,cAAgB,EACfjB,EAuBP,SAASW,EAAYF,GACnB,OAAOoJ,EAAYzJ,EAAQK,GAG7B,SAAS2J,IACP,OAAOpM,EAAQmD,GAiBjB,SAAS2J,IAIP,IAHA,IAAIE,EACA3K,EAEGc,EAAMH,OAASZ,EAAOX,QAG3B,GAAqB,iBAFrBY,EAAQD,EAAOe,EAAMH,SASnB,IANAgK,EAAa7J,EAAMH,OAEfG,EAAMF,aAAe,IACvBE,EAAMF,aAAe,GAGhBE,EAAMH,SAAWgK,GAAc7J,EAAMF,aAAeZ,EAAMZ,QAC/DwL,EAAG5K,EAAMO,WAAWO,EAAMF,oBAG5BgK,EAAG5K,GAMT,SAAS4K,EAAGhM,GACV8L,EAAQA,EAAM9L,GAuDhB,SAASyL,EAAkBH,EAAWC,GACpCA,EAAKU,UAIP,SAASZ,EAAiBa,EAAUhB,GAClC,OAGA,SAAcvL,EAAY6G,EAAa2F,GACrC,IAAIC,EACAC,EACAC,EACAf,EACJ,OAAO5L,EAAWJ,UAAY,WAAYI,EAAa4M,EAAuB/I,EAAS7D,IAEvF,SAA+BK,GAC7B,GAAIA,KAAQL,GAAc,QAAQA,EAChC,OAAO4M,EAAuB5M,EAAW0I,KAEzC7E,EAAS7D,EAAWK,IAAO2D,OAAOH,EAAS7D,EAAW0I,OAAS1I,EAAWK,GAFnEuM,CAE0EvM,GAGnF,OAAOmM,EAAWnM,IAGpB,SAASuM,EAAuBjM,GAG9B,OAFA8L,EAAmB9L,EAEZkM,EAAgBlM,EADvB+L,EAAiB,IAInB,SAASG,EAAgBlB,GACvB,OAEA,SAAetL,GAKbuL,EA8CR,WACE,IAAIkB,EAAatB,IACbuB,EAAgB3L,EAAQN,SACxBkM,EAAwB5L,EAAQuL,iBAChCM,EAAmB7L,EAAQD,OAAON,OAClCqM,EAAaC,MAAM/I,KAAKiH,GAC5B,MAAO,CACLiB,QAIF,WACE/J,EAAQuK,EACR1L,EAAQN,SAAWiM,EACnB3L,EAAQuL,iBAAmBK,EAC3B5L,EAAQD,OAAON,OAASoM,EACxB5B,EAAQ6B,EACR5B,KATAlH,KAAM6I,GAtDKG,GACPT,EAAmBhB,EAEdA,EAAUd,UACbzJ,EAAQuL,iBAAmBhB,GAG7B,GAAIA,EAAUjJ,MAAQtB,EAAQnB,OAAOD,WAAWyI,QAAQC,KAAKC,QAAQgD,EAAUjJ,OAAS,EACtF,OAAOE,IAGT,OAAO+I,EAAU/L,SAASmB,KAAKwK,EAASpM,EAAO,GAAIiC,EAASmK,GAAUnK,EAASvB,EAAS8C,EAAIC,EAArF+I,CAA0FtL,IAIrG,SAASsC,EAAGtC,GAEV,OADAkM,EAASI,EAAkBf,GACpB/E,EAGT,SAASjE,EAAIvC,GAGX,OAFAuL,EAAKU,YAECI,EAAiBD,EAAiB5L,OAC/BgM,EAAgBJ,EAAiBC,IAGnCF,IAKb,SAASX,EAAUF,EAAWvH,GACxBuH,EAAUlM,YAAc2L,EAAqBzC,QAAQgD,GAAa,GACpEP,EAAqBhG,KAAKuG,GAGxBA,EAAU1I,SACZ8H,EAAc3J,EAAQD,OAAQiD,EAAMhD,EAAQD,OAAON,OAASuD,EAAMuH,EAAU1I,QAAQ7B,EAAQD,OAAOgE,MAAMf,GAAOhD,IAG9GuK,EAAU0B,YACZjM,EAAQD,OAASwK,EAAU0B,UAAUjM,EAAQD,OAAQC,IAyBzD,SAASkK,IACH/I,EAAMN,QAAQkJ,GAAe5I,EAAML,OAAS,IAC9CK,EAAML,OAASiJ,EAAY5I,EAAMN,MACjCM,EAAMJ,QAAUgJ,EAAY5I,EAAMN,MAAQ,M,oCChThD,IAAIqL,EAAStO,OAAOuO,UAAUlK,eAC1BmK,EAAQxO,OAAOuO,UAAUE,SACzBxO,EAAiBD,OAAOC,eACxByO,EAAO1O,OAAO2O,yBAEdC,EAAU,SAAiBC,GAC7B,MAA6B,mBAAlBV,MAAMS,QACRT,MAAMS,QAAQC,GAGI,mBAApBL,EAAMzM,KAAK8M,IAGhBC,EAAgB,SAAuBC,GACzC,IAAKA,GAA2B,oBAApBP,EAAMzM,KAAKgN,GACrB,OAAO,EAGT,IASIC,EATAC,EAAoBX,EAAOvM,KAAKgN,EAAK,eACrCG,EAAmBH,EAAII,aAAeJ,EAAII,YAAYZ,WAAaD,EAAOvM,KAAKgN,EAAII,YAAYZ,UAAW,iBAE9G,GAAIQ,EAAII,cAAgBF,IAAsBC,EAC5C,OAAO,EAOT,IAAKF,KAAOD,GAIZ,YAAsB,IAARC,GAAuBV,EAAOvM,KAAKgN,EAAKC,IAIpDI,EAAc,SAAqBC,EAAQvK,GACzC7E,GAAmC,cAAjB6E,EAAQpB,KAC5BzD,EAAeoP,EAAQvK,EAAQpB,KAAM,CACnC4L,YAAY,EACZC,cAAc,EACdrP,MAAO4E,EAAQ0K,SACfC,UAAU,IAGZJ,EAAOvK,EAAQpB,MAAQoB,EAAQ0K,UAK/BE,EAAc,SAAqBX,EAAKrL,GAC1C,GAAa,cAATA,EAAsB,CACxB,IAAK4K,EAAOvM,KAAKgN,EAAKrL,GACpB,OACK,GAAIgL,EAGT,OAAOA,EAAKK,EAAKrL,GAAMxD,MAI3B,OAAO6O,EAAIrL,IAGbJ,EAAOxD,QAAU,SAAS6P,IACxB,IAAI7K,EAASpB,EAAM+C,EAAKmJ,EAAMC,EAAaC,EACvCT,EAASU,UAAU,GACnBC,EAAI,EACJnO,EAASkO,UAAUlO,OACnBoO,GAAO,EAaX,IAXsB,kBAAXZ,IACTY,EAAOZ,EACPA,EAASU,UAAU,IAAM,GAEzBC,EAAI,IAGQ,MAAVX,GAAoC,iBAAXA,GAAyC,mBAAXA,KACzDA,EAAS,IAGJW,EAAInO,IAAUmO,EAGnB,GAAe,OAFflL,EAAUiL,UAAUC,IAIlB,IAAKtM,KAAQoB,EACX2B,EAAMiJ,EAAYL,EAAQ3L,GAGtB2L,KAFJO,EAAOF,EAAY5K,EAASpB,MAItBuM,GAAQL,IAASd,EAAcc,KAAUC,EAAcjB,EAAQgB,MAC7DC,GACFA,GAAc,EACdC,EAAQrJ,GAAOmI,EAAQnI,GAAOA,EAAM,IAEpCqJ,EAAQrJ,GAAOqI,EAAcrI,GAAOA,EAAM,GAI5C2I,EAAYC,EAAQ,CAClB3L,KAAMA,EACN8L,SAAUG,EAAOM,EAAMH,EAAOF,WAEP,IAATA,GAChBR,EAAYC,EAAQ,CAClB3L,KAAMA,EACN8L,SAAUI,KAStB,OAAOP,I,oCCvHT,IAAIa,EAAQ,EAAQ,QAEhBC,EAAU,EAAQ,QAElBC,EAAQ,EAAQ,QAEhBC,EAAe,EAAQ,QAEvBC,EAAY,EAAQ,QAGpBC,EAAO,EAAQ,QAEfC,EAAS,EAAQ,QAEjBC,EAAiB,EAAQ,QAEzBC,EAAkB,EAAQ,QAAqBC,oBAwBnDrN,EAAOxD,QAAU8Q,EACjB,IAAIxM,EAAM,GAAGC,eAYTwM,EAAa,CACfC,UAAW,CACTC,GAAI,aACJC,GAAI,kCAENC,WAAY,CACVD,GAAI,wCAENE,mBAAoB,CAClBF,GAAI,wCAENG,WAAY,CACVH,GAAI,wCAENI,OAAQ,CACNL,GAAI,WACJC,GAAI,6BAENK,UAAW,CACTN,GAAI,eACJC,GAAI,sDAENM,aAAc,CACZP,GAAI,kBACJC,GAAI,sDAENO,gBAAiB,CACfR,GAAI,qBACJC,GAAI,sDAENQ,iBAAkB,CAChBT,GAAI,sBACJC,GAAI,mDAQR,SAASJ,EAAc9L,GACrB,IAAK,IAAIkK,KAAO6B,EACd,GAAIzM,EAAIrC,KAAK8O,EAAY7B,IAAQ5K,EAAIrC,KAAK+C,EAASkK,GAAM,CAEvD,IAAIyC,EAAcZ,EAAW7B,GAC7B0C,QAAQC,KAAK,oCAAoC3M,OAAOyM,EAAYV,GAAK,QAAQ/L,OAAOyM,EAAYV,GAAI,gBAAkB,SAAU,MAAM/L,OAAOgK,EAAK,YAAYhK,OAxDxJ,oEAwD0K,KAAKA,OAAOyM,EAAYT,GAAI,4BACzMH,EAAW7B,GAItB,IAAI4C,EAAYzB,IAAU0B,IAAIzB,GAC7ByB,IAAI/M,EAAQgN,eAAiBhN,EAAQiN,SAAW,IAAIF,IAAIxB,EAAc,CACrEa,oBAAoB,IACnBW,IAAI/M,EAAQkN,eAAiB,IAAIH,IAAIrB,EAAQ1L,GAI5CmN,EAAWL,EAAUM,QAAQN,EAAUxB,MAAMtL,EAAQmC,UAAY,KAErE,GAAsB,SAAlBgL,EAAS5P,KACX,MAAM,IAAI8P,UAAU,0BAKtB,IAAIrL,EAASoJ,EAAMkC,cAAclC,EAAMmC,SAAU,GAAI3B,EAAgB,CACnE5L,QAASA,EACTwN,OAAQ/B,EACRgC,UAAW,GACVN,IAQH,OANInN,EAAQ0N,YACV1L,EAASoJ,EAAMkC,cAAc,MAAO,CAClCI,UAAW1N,EAAQ0N,WAClB1L,IAGEA,EAGT8J,EAAc6B,aAAe,CAC3BC,iBAAkBjC,GAEpBG,EAAc+B,UAAY,CAExB1L,SAAUqJ,EAAU/P,OAEpBiS,UAAWlC,EAAU/P,OAErBqS,aAActC,EAAUuC,KACxBC,gBAAiBxC,EAAUyC,QAAQzC,EAAU/P,QAC7CyS,mBAAoB1C,EAAUyC,QAAQzC,EAAU/P,QAChD0S,iBAAkB3C,EAAU4C,KAG5BpB,cAAexB,EAAUyC,QAAQzC,EAAU6C,UAAU,CAAC7C,EAAU8C,OAAQ9C,EAAUuC,KAAMvC,EAAUyC,QAAQzC,EAAU6C,UAAU,CAAC7C,EAAU8C,OAAQ9C,EAAUuC,WAE3Jb,cAAe1B,EAAUyC,QAAQzC,EAAU6C,UAAU,CAAC7C,EAAU8C,OAAQ9C,EAAUuC,KAAMvC,EAAUyC,QAAQzC,EAAU6C,UAAU,CAAC7C,EAAU8C,OAAQ9C,EAAUuC,WAE3JQ,UAAW/C,EAAU4C,KACrBI,aAAchD,EAAU4C,KACxBK,SAAUjD,EAAU4C,KACpBM,oBAAqBlD,EAAU4C,KAC/BR,iBAAkBpC,EAAU6C,UAAU,CAAC7C,EAAUuC,KAAMvC,EAAU4C,OACjEO,WAAYnD,EAAU6C,UAAU,CAAC7C,EAAUuC,KAAMvC,EAAU/P,SAC3DmT,kBAAmBpD,EAAUuC,KAC7Bc,WAAYrD,EAAU8C,QAExBxC,EAAcH,eAAiBA,G,oCClK/B,IAAImD,EAAQ,EAAQ,QAEhBC,EAAQ,EAAQ,QAEhBC,EAAM,EAAQ,QAEdC,EAAQ,EAAQ,QAEhBC,EAAO,EAAQ,QAEfzD,EAAO,EAAQ,QAEnBjN,EAAOxD,QAAU8T,EAAM,CAACE,EAAKD,EAAOE,EAAOC,EAAMzD,K,oCCZjD,IAEI0D,EAAkB,CACpBvQ,KAAM,kBACN9C,SAIF,SAAiCC,EAAS8C,EAAIC,GAC5C,IAAI9C,EAAOC,KACX,OAEA,SAAeM,GAKb,OAJAR,EAAQU,MAAM,cACdV,EAAQU,MAAM,oBACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,oBACNoG,GAGT,SAASA,EAAKzG,GACZ,OAAa,KAATA,GACFR,EAAQU,MAAM,eACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,eACbb,EAAQa,KAAK,cACNwS,GAGFtQ,EAAIvC,GAGb,SAAS6S,EAAM7S,GAEb,OAAgB,KAATA,GAEP,2BAA4BP,EAAKG,OAAOD,WAExC4C,EAAIvC,GAAQsC,EAAGtC,KAjCjBZ,WALa,EAAQ,QAKAA,YAqCvB6C,EAAOxD,QAAUmU,G,oCC1CjB,IAEIE,EAFa,EAAQ,OAERC,CAAW,uBAC5B9Q,EAAOxD,QAAUqU,G,oCCHjB7Q,EAAOxD,QAIP,SAAkBwG,EAAGC,GACnB,IAAI8N,EAAe/N,EAAE+N,aACjBC,EAAgBhO,EAAEgO,cAClBC,EAAa,EAEjB,KAAOA,KAAcF,GACnBE,IAgBF,OAbAA,EAAaC,OAAOD,GAGpBD,EAAclO,KAAKmO,GACnBF,EAAaE,GAAc,CACzBlS,KAAM,qBACNkS,WAAYA,EACZtN,SAAU,CAAC,CACT5E,KAAM,YACN4E,SAAUV,EAAKU,WAEjB3C,SAAUiC,EAAKjC,UAEVmQ,EAAkBnO,EAAG,CAC1BjE,KAAM,oBACNkS,WAAYA,EACZjQ,SAAUiC,EAAKjC,YA3BnB,IAAImQ,EAAoB,EAAQ,S,oCCKhCnR,EAAOxD,QAPP,SAAsBuB,GACpB,OAEEA,EAAO,IAAe,MAATA,I,oCCHjB,IAAImC,EAAqB,EAAQ,QAE7B6B,EAAe,EAAQ,QAwE3B/B,EAAOxD,QAtEP,SAAsBe,EAAS8C,EAAIC,EAAKvB,EAAMqS,EAAYC,GACxD,IAAIrN,EACJ,OAEA,SAAejG,GAMb,OALAR,EAAQU,MAAMc,GACdxB,EAAQU,MAAMmT,GACd7T,EAAQW,QAAQH,GAChBR,EAAQa,KAAKgT,GACbpN,EAAkB,KAATjG,EAAc,GAAKA,EACrBuT,GAGT,SAASA,EAAkBvT,GACzB,OAAIA,IAASiG,GACXzG,EAAQU,MAAMmT,GACd7T,EAAQW,QAAQH,GAChBR,EAAQa,KAAKgT,GACb7T,EAAQa,KAAKW,GACNsB,IAGT9C,EAAQU,MAAMoT,GACPE,EAAaxT,IAGtB,SAASwT,EAAaxT,GACpB,OAAIA,IAASiG,GACXzG,EAAQa,KAAKiT,GACNC,EAAkBtN,IAGd,OAATjG,EACKuC,EAAIvC,GAITmC,EAAmBnC,IACrBR,EAAQU,MAAM,cACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,cACN2D,EAAaxE,EAASgU,EAAc,gBAG7ChU,EAAQU,MAAM,cAAe,CAC3BkE,YAAa,WAERmB,EAAMvF,IAGf,SAASuF,EAAMvF,GACb,OAAIA,IAASiG,GAAmB,OAATjG,GAAiBmC,EAAmBnC,IACzDR,EAAQa,KAAK,eACNmT,EAAaxT,KAGtBR,EAAQW,QAAQH,GACA,KAATA,EAAcyT,EAAclO,GAGrC,SAASkO,EAAYzT,GACnB,OAAIA,IAASiG,GAAmB,KAATjG,GACrBR,EAAQW,QAAQH,GACTuF,GAGFA,EAAMvF,M,oCCtEjBiC,EAAOxD,QAOP,SAAgBwG,EAAGC,GACjB,IAEIwO,EACAhO,EACAiO,EAJAC,EAAU1O,EAAK2O,cACfC,EAAS,IAKG,cAAZF,EACFE,GAAU,KACW,SAAZF,IACTE,GAAU,KAAO5O,EAAK6O,OAAS7O,EAAKgO,YAAc,KAGpD,GAAkB,mBAAdhO,EAAKlE,KACP,OAAOgT,EAAE,OAAQ,KAAO9O,EAAKI,IAAMwO,GAGrCJ,EAAWO,EAAIhP,EAAGC,IAClBQ,EAAOgO,EAAS,KAEU,SAAdhO,EAAK1E,KACf0E,EAAK7G,MAAQ,IAAM6G,EAAK7G,MAExB6U,EAASQ,QAAQF,EAAE,OAAQ,OAG7BL,EAAOD,EAASA,EAASlT,OAAS,KAER,SAAdmT,EAAK3S,KACf2S,EAAK9U,OAASiV,EAEdJ,EAAS3O,KAAKiP,EAAE,OAAQF,IAG1B,OAAOJ,GAvCT,IAAIM,EAAI,EAAQ,QAEZC,EAAM,EAAQ,S,kCCJlB,IAAI9N,EAAa,EAAQ,QAErBC,EAAoB,EAAQ,QAE5B0M,EAAa,EAAQ,QAErBqB,EAAe,EAAQ,QAEvBC,EAAW,CACb/R,KAAM,WACN9C,SAGF,SAA0BC,EAAS8C,EAAIC,GACrC,IAAIjB,EAAO,EACX,OAEA,SAAetB,GAMb,OALAR,EAAQU,MAAM,YACdV,EAAQU,MAAM,kBACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,kBACbb,EAAQU,MAAM,oBACPuG,GAGT,SAASA,EAAKzG,GACZ,OAAImG,EAAWnG,IACbR,EAAQW,QAAQH,GACTqU,GAGFvB,EAAW9S,GAAQsU,EAAWtU,GAAQuC,EAAIvC,GAGnD,SAASqU,EAAmBrU,GAC1B,OAAgB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAeoG,EAAkBpG,GAAQuU,EAAyBvU,GAAQsU,EAAWtU,GAG5H,SAASuU,EAAyBvU,GAChC,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACTwU,IAGK,KAATxU,GAAwB,KAATA,GAAwB,KAATA,GAAeoG,EAAkBpG,KAAUsB,IAAS,IACrF9B,EAAQW,QAAQH,GACTuU,GAGFD,EAAWtU,GAGpB,SAASwU,EAAUxU,GACjB,OAAa,KAATA,GACFR,EAAQa,KAAK,oBACNY,EAAIjB,IAGA,KAATA,GAAwB,KAATA,GAAemU,EAAanU,GACtCuC,EAAIvC,IAGbR,EAAQW,QAAQH,GACTwU,GAGT,SAASF,EAAWtU,GAClB,OAAa,KAATA,GACFR,EAAQW,QAAQH,GAChBsB,EAAO,EACAmT,GAGL3B,EAAW9S,IACbR,EAAQW,QAAQH,GACTsU,GAGF/R,EAAIvC,GAGb,SAASyU,EAAiBzU,GACxB,OAAOoG,EAAkBpG,GAAQ0U,EAAW1U,GAAQuC,EAAIvC,GAG1D,SAAS0U,EAAW1U,GAClB,OAAa,KAATA,GACFR,EAAQW,QAAQH,GAChBsB,EAAO,EACAmT,GAGI,KAATzU,GAEFR,EAAQa,KAAK,oBAAoBW,KAAO,gBACjCC,EAAIjB,IAGN2U,EAAW3U,GAGpB,SAAS2U,EAAW3U,GAClB,OAAc,KAATA,GAAeoG,EAAkBpG,KAAUsB,IAAS,IACvD9B,EAAQW,QAAQH,GACA,KAATA,EAAc2U,EAAaD,GAG7BnS,EAAIvC,GAGb,SAASiB,EAAIjB,GAKX,OAJAR,EAAQU,MAAM,kBACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,kBACbb,EAAQa,KAAK,YACNiC,KAIXL,EAAOxD,QAAU2V,G,kCCxHjB,IAAIvF,EAAQ,EAAQ,QAEhB+F,EAAU,EAAQ,QAGlBC,EAAM,EAAQ,QAGdC,EAAO,EAAQ,QAGfC,EAAc,EAAQ,QAGtBC,EAAS,EAAQ,QAGjBC,EAAS,EAAQ,QAEjBC,EAAQ,EAAQ,QAEpBzW,EAAQsW,YAAcI,EACtB1W,EAAQ6Q,oBAAsBD,EAwI9B,IAAItM,EAAM,GAAGC,eAGToS,EAAgB,IAAIC,IAAI,CAAC,QAAS,QAAS,QAAS,QAAS,OAMjE,SAAShG,EAAgBtO,EAASmE,GAQhC,IANA,IAIIoQ,EAJA1P,EAAW,GACX2P,GAAc,IAKTA,EAAarQ,EAAKU,SAASpF,QAGf,aAFnB8U,EAAQpQ,EAAKU,SAAS2P,IAEZvU,KACR4E,EAASb,KAAKoQ,EAAQpU,EAASuU,EAAOC,EAAYrQ,IAC1B,SAAfoQ,EAAMtU,KAGG,YAAdkE,EAAKlE,MAAuBoU,EAAcI,IAAItQ,EAAKuQ,UAA4B,OAAhBH,EAAMzW,OACvE+G,EAASb,KAAKuQ,EAAMzW,OAGA,QAAfyW,EAAMtU,MAAmBD,EAAQ0C,QAAQyO,UAG9CtM,EAASb,KAAKuQ,EAAMzW,OAI1B,OAAO+G,EAUT,SAASuP,EAAQpU,EAASmE,EAAM3E,EAAOiF,GACrC,IAYIkQ,EAZAjS,EAAU1C,EAAQ0C,QAClBkS,EAAe5U,EAAQkQ,OAIvB5O,EAAO6C,EAAKuQ,QAGZG,EAAa,GACb3E,EAAS0E,EAUb,IAAKD,IALsB,SAAvBC,EAAaE,OAA6B,QAATxT,IACnC4O,EAAS4D,EACT9T,EAAQkQ,OAASA,GAGF/L,EAAK0Q,WAEhB7S,EAAIrC,KAAKwE,EAAK0Q,WAAYF,IAC5BI,EAAYF,EAAYF,EAAUxQ,EAAK0Q,WAAWF,GAAW3U,GAIpD,OAATsB,GAA0B,OAATA,GACnBtB,EAAQmQ,YAGV,IAAItL,EAAWyJ,EAAgBtO,EAASmE,GAE3B,OAAT7C,GAA0B,OAATA,GACnBtB,EAAQmQ,YAIVnQ,EAAQkQ,OAAS0E,EAGjB,IAoNuBzS,EApNnBD,EAAWiC,EAAKjC,UAAY,CAC9BnD,MAAO,CACL8B,KAAM,KACNC,OAAQ,KACRC,OAAQ,MAEVb,IAAK,CACHW,KAAM,KACNC,OAAQ,KACRC,OAAQ,OAKRiU,EAAYtS,EAAQ6O,YAAcvP,EAAIrC,KAAK+C,EAAQ6O,WAAYjQ,GAAQoB,EAAQ6O,WAAWjQ,GAAQA,EAClG2T,EAA6B,iBAAdD,GAA0BA,IAAclH,EAAMmC,SAEjE,IAAK4D,EAAQqB,mBAAmBF,GAC9B,MAAM,IAAIjF,UAAU,uBAAuBnN,OAAOtB,EAAM,uCA4B1D,GAzBAuT,EAAWjI,IAAM,CAACtL,EAAMY,EAASnD,MAAM8B,KAAMqB,EAASnD,MAAM+B,OAAQtB,GAAO2V,KAAK,KAEnE,MAAT7T,GAAgBoB,EAAQ2O,aAC1BwD,EAAW5H,OAAuC,mBAAvBvK,EAAQ2O,WACnC3O,EAAQ2O,WAAWwD,EAAWO,KAAMjR,EAAKU,SAAUgQ,EAAWrQ,OAAS9B,EAAQ2O,YAGpE,MAAT/P,GAAgBoB,EAAQ4N,mBAC1BuE,EAAWO,KAAO1S,EAAQ4N,iBAC1BuE,EAAWO,KAAMjR,EAAKU,SAAUgQ,EAAWrQ,QAGxCyQ,GAAkB,SAAT3T,GAAsC,QAAnBmD,EAAOiQ,UACtCG,EAAWQ,QAAS,GAGjBJ,GAAmB,OAAT3T,GAA0B,OAATA,GAA0B,OAATA,GAA0B,OAATA,GAA0B,OAATA,GAA0B,OAATA,IAClGuT,EAAWS,MAAQC,SAASjU,EAAKkU,OAAO,GAAI,KAGjC,QAATlU,GAAkBoB,EAAQ4O,oBAC5BuD,EAAWxQ,IAAM3B,EAAQ4O,kBACzBuD,EAAWxQ,IAAKwQ,EAAWtQ,IAAKsQ,EAAWrQ,SAGxCyQ,GAAkB,OAAT3T,EAAe,CAC3B,IAAImU,EAwDR,SAAyBtR,GACvB,IAAI3E,GAAS,EAEb,OAASA,EAAQ2E,EAAKU,SAASpF,QAAQ,CACrC,IAAI8U,EAAQpQ,EAAKU,SAASrF,GAE1B,GAAmB,YAAf+U,EAAMtU,MAAwC,UAAlBsU,EAAMG,QACpC,OAAOH,EAIX,OAAO,KAnEOmB,CAAgBvR,GAC5B0Q,EAAWc,QAAUF,EAAQG,QAAQH,EAAMZ,WAAWc,SAAW,KACjEd,EAAWrV,MAAQqW,EAAuBpR,EAAQN,GAClD0Q,EAAWiB,QAA6B,OAAnBrR,EAAOiQ,QA6C9B,OA1CKO,GAAmB,OAAT3T,GAA0B,OAATA,IAC9BuT,EAAWiB,QAAmB,OAATxU,EACrBuT,EAAWkB,MAAQ/V,EAAQmQ,WAGhB,OAAT7O,GAA0B,OAATA,IACfuT,EAAWmB,QACRnB,EAAWV,QAAOU,EAAWV,MAAQ,IAE1CU,EAAWV,MAAM8B,UAAYpB,EAAWmB,aACjCnB,EAAWmB,OAGff,IACHJ,EAAWqB,SAAoB,OAAT5U,IAIrB2T,GAAkB,OAAT3T,IACZuT,EAAWqB,SAAWN,QAA2B,UAAnBnR,EAAOiQ,UAInChS,EAAQuO,YACV4D,EAAW,kBAwIN,EADgB1S,EAvI0BD,GAwIrCnD,MAAM8B,KAAM,IAAKsB,EAAIpD,MAAM+B,OAAQ,IAAKqB,EAAIjC,IAAIW,KAAM,IAAKsB,EAAIjC,IAAIY,QAAQqV,KAAI,SAAUC,GACnG,OAAOhE,OAAOgE,MACbjB,KAAK,MAvIHF,GAASvS,EAAQwO,eACpB2D,EAAWwB,eAAiBlS,EAAKjC,WAI9B+S,GAASvS,EAAQ0O,sBACpByD,EAAWrV,MAAQqW,EAAuBpR,EAAQN,GAClD0Q,EAAWyB,aAAeT,EAAuBpR,IAG9CwQ,IACHJ,EAAW1Q,KAAOA,GAIbU,EAASpF,OAAS,EAAIqO,EAAMkC,cAAcgF,EAAWH,EAAYhQ,GAAYiJ,EAAMkC,cAAcgF,EAAWH,GA4BrH,SAASgB,EAAuBpR,EAAQN,GAItC,IAHA,IAAI3E,GAAS,EACT+W,EAAQ,IAEH/W,EAAQiF,EAAOI,SAASpF,QAC3BgF,EAAOI,SAASrF,KAAW2E,GACK,YAAhCM,EAAOI,SAASrF,GAAOS,MAAoBsW,IAGjD,OAAOA,EAUT,SAASxB,EAAY3Q,EAAOoS,EAAM1Y,EAAO2Y,GAEvC,IAAIjM,EAAOuJ,EAAK0C,EAAIvG,OAAQsG,GACxB9R,EAAS5G,EAGT4G,SAA2CA,GAAWA,IAMtDA,GAA4B,iBAAXA,GAAuB,WAAYA,IAEtDA,GAAU8F,EAAKkM,eAAiBxC,EAASD,GAAQ0C,UAAUjS,IAGvC,UAAlB8F,EAAKmK,UAA0C,iBAAXjQ,IACtCA,EAeJ,SAAoB5G,GAElB,IAAI4G,EAAS,GAEb,IACEyP,EAAMrW,GAYR,SAAkBwD,EAAMsV,GACtB,IAAIC,EAAyB,SAArBvV,EAAKyC,MAAM,EAAG,GAAgB,MAAMnB,OAAOtB,EAAKyC,MAAM,IAAMzC,EACpEoD,EAAOmS,EAAE7R,QAAQ,YAAa8R,IAAkBF,KAbhD,MAEFG,IAGA,OAAOrS,EA1BIsS,CAAWtS,IAGlB8F,EAAKsK,MACP1Q,EAAMpC,EAAIrC,KAAKqU,EAAaxJ,EAAKmK,UAAYX,EAAYxJ,EAAKmK,UAAYnK,EAAKmK,UAAYjQ,EAE3FN,EAAMoG,EAAKyM,WAAavS,GAqC5B,SAASoS,EAAcC,EAAGG,GACxB,OAAOA,EAAGC,gB,kCCjcZ,IAAIpY,EAAQqY,EAAQ,SAChBlX,EAAMkX,EAAQ,OAKlB,SAASlV,EAASiC,GAChB,MAAO,CACLpF,MAAOA,EAAMoF,GACbjE,IAAKA,EAAIiE,IAIb,SAASiT,EAAQnX,GAEf,OADAkB,EAAMkW,YAAcpX,EACbkB,EAEP,SAASA,EAAMgD,GACb,IAAIhD,EAAQgD,GAAQA,EAAKjC,UAAYiC,EAAKjC,SAASjC,IAAS,GAC5D,MAAO,CACLY,KAAMM,EAAMN,MAAQ,KACpBC,OAAQK,EAAML,QAAU,KACxBC,OAAQuW,MAAMnW,EAAMJ,QAAU,KAAOI,EAAMJ,SApBjDG,EAAOxD,QAAUwE,EACjBA,EAASnD,MAAQA,EACjBmD,EAAShC,IAAMA,G,kCCQfgB,EAAOxD,QAZP,SAA6BI,GAC3B,OAAOA,EACNkH,QAAQ,cAAe,KACvBA,QAAQ,SAAU,IAMlBuS,cAAcJ,gB,kCCTjB,IAAIK,EAA0B,EAAQ,QAKlCC,EAHa,EAAQ,OAGAzF,CAAWwF,GACpCtW,EAAOxD,QAAU+Z,G,qBCRjB,IAAIzJ,EAAQ,EAAQ,QA2CpB9M,EAAOxD,QA7BP,SAAuByW,EAAOuD,GAC5B,IAMIzR,EANA0R,EAAS,KAEb,IAAKxD,GAA0B,iBAAVA,EACnB,OAAOwD,EAST,IALA,IAEIhD,EACA7W,EAHA8Z,EAAe5J,EAAMmG,GACrB0D,EAAkC,mBAAbH,EAIhB9J,EAAI,EAAGkK,EAAMF,EAAanY,OAAQmO,EAAIkK,EAAKlK,IAElD+G,GADA1O,EAAc2R,EAAahK,IACJ+G,SACvB7W,EAAQmI,EAAYnI,MAEhB+Z,EACFH,EAAS/C,EAAU7W,EAAOmI,GACjBnI,IACT6Z,IAAWA,EAAS,IACpBA,EAAOhD,GAAY7W,GAIvB,OAAO6Z,I,kCCtCTzW,EAAOxD,QAKP,SAAcwG,EAAGC,GACf,OAAOD,EAAE6T,UAAY7T,EAAE8T,QAAQ7T,EAAM8O,EAAE,MAAO9O,EAAKrG,QAAU,MAJ/D,IAAImV,EAAI,EAAQ,S,kCCFhB,IAAI7R,EAAqB,EAAQ,QAE7BkE,EAA4B,EAAQ,QAEpC/B,EAAgB,EAAQ,QAExBoG,EAAgB,EAAQ,QAExB1G,EAAe,EAAQ,QAEvBgV,EAAa,CACf3W,KAAM,aACN9C,SAyCF,SAA4BC,EAAS8C,EAAIC,GACvC,IAAI9C,EAAOC,KACP4B,EAAO,EACX,OAEA,SAAetB,GAGb,OAFAR,EAAQU,MAAM,cACdV,EAAQU,MAAM,sBACP+Y,EAAgBjZ,IAGzB,SAASiZ,EAAgBjZ,GACvB,OAAa,KAATA,GAAesB,IAAS,GAC1B9B,EAAQW,QAAQH,GACTiZ,GAGI,OAATjZ,GAAiBqG,EAA0BrG,IAC7CR,EAAQa,KAAK,sBACNZ,EAAKmK,UAAYtH,EAAGtC,GAAQkZ,EAAalZ,IAG3CuC,EAAIvC,GAGb,SAASkZ,EAAalZ,GACpB,OAAa,KAATA,GACFR,EAAQU,MAAM,sBACPgG,EAASlG,IAGL,OAATA,GAAiBmC,EAAmBnC,IACtCR,EAAQa,KAAK,cACNiC,EAAGtC,IAGRsE,EAActE,GACTgE,EAAaxE,EAAS0Z,EAAc,aAApClV,CAAkDhE,IAG3DR,EAAQU,MAAM,kBACPE,EAAKJ,IAGd,SAASkG,EAASlG,GAChB,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACTkG,IAGT1G,EAAQa,KAAK,sBACN6Y,EAAalZ,IAGtB,SAASI,EAAKJ,GACZ,OAAa,OAATA,GAA0B,KAATA,GAAeqG,EAA0BrG,IAC5DR,EAAQa,KAAK,kBACN6Y,EAAalZ,KAGtBR,EAAQW,QAAQH,GACTI,KArGTwC,QAGF,SAA2B9B,EAAQC,GACjC,IAEIoC,EACAnE,EAHAma,EAAarY,EAAON,OAAS,EAC7ByD,EAAe,EAIkB,eAAjCnD,EAAOmD,GAAc,GAAGjD,OAC1BiD,GAAgB,GAIdkV,EAAa,EAAIlV,GAA+C,eAA/BnD,EAAOqY,GAAY,GAAGnY,OACzDmY,GAAc,GAGmB,uBAA/BrY,EAAOqY,GAAY,GAAGnY,OAAkCiD,IAAiBkV,EAAa,GAAKA,EAAa,EAAIlV,GAAmD,eAAnCnD,EAAOqY,EAAa,GAAG,GAAGnY,QACxJmY,GAAclV,EAAe,IAAMkV,EAAa,EAAI,GAGlDA,EAAalV,IACfd,EAAU,CACRnC,KAAM,iBACNlB,MAAOgB,EAAOmD,GAAc,GAAGnE,MAC/BmB,IAAKH,EAAOqY,GAAY,GAAGlY,KAE7BjC,EAAO,CACLgC,KAAM,YACNlB,MAAOgB,EAAOmD,GAAc,GAAGnE,MAC/BmB,IAAKH,EAAOqY,GAAY,GAAGlY,IAC3BmD,YAAa,QAEfsG,EAAc5J,EAAQmD,EAAckV,EAAalV,EAAe,EAAG,CAAC,CAAC,QAASd,EAASpC,GAAU,CAAC,QAAS/B,EAAM+B,GAAU,CAAC,OAAQ/B,EAAM+B,GAAU,CAAC,OAAQoC,EAASpC,MAGxK,OAAOD,IAoETmB,EAAOxD,QAAUua,G,kCCtHjB,IAAIhU,EAAY,EAAQ,QAEpBoU,EAAS,EAAQ,QAEjBC,EAAc,EAAQ,QAE1BpX,EAAOxD,QAEP,SAAgB6a,GACd,IAOI/B,EACAhM,EARAsK,EAAQyD,EAAWzD,MACnB0D,EAAkBD,EAAWC,iBAAmB,GAChDC,EAAaF,EAAWE,YAAc,GACtCrU,EAAQmU,EAAW1D,WACnB6D,EAAYH,EAAWG,UACvB/D,EAAW,GACXgE,EAAS,GAIb,IAAKnC,KAAQpS,EACXoG,EAAO,IAAI8N,EAAY9B,EAAMkC,EAAUD,EAAYjC,GAAOpS,EAAMoS,GAAO1B,IAEhC,IAAnC0D,EAAgBjR,QAAQiP,KAC1BhM,EAAKgO,iBAAkB,GAGzB7D,EAAS6B,GAAQhM,EACjBmO,EAAO1U,EAAUuS,IAASA,EAC1BmC,EAAO1U,EAAUuG,EAAKyM,YAAcT,EAGtC,OAAO,IAAI6B,EAAO1D,EAAUgE,EAAQ7D,K,oCC3BtC5T,EAAOxD,QAJP,SAA4BuB,GAC1B,OAAOA,GAAQ,I,kCCDjB,IAAI8E,EAAQ,GAAGA,MACf7C,EAAOxD,QAIP,SAAckb,EAAIC,GAChB,IAAIC,EACJ,OAEA,WACE,IAEIpU,EAFAqU,EAAShV,EAAMpE,KAAKgO,UAAW,GAC/BkL,EAAWD,EAAGnZ,OAASsZ,EAAOtZ,OAG9BoZ,GACFE,EAAO/U,KAAKgV,GAGd,IACEtU,EAASkU,EAAGK,MAAM,KAAMF,GACxB,MAAOG,GAMP,GAAIL,GAAYC,EACd,MAAMI,EAGR,OAAOF,EAAKE,GAGTL,IACCnU,GAAiC,mBAAhBA,EAAOyU,KAC1BzU,EAAOyU,KAAKA,EAAMH,GACTtU,aAAkB0U,MAC3BJ,EAAKtU,GAELyU,EAAKzU,KAMX,SAASsU,IACFF,IACHA,GAAU,EACVD,EAASI,MAAM,KAAMtL,YAMzB,SAASwL,EAAKrb,GACZkb,EAAK,KAAMlb,M,kCCvDf,IAAIub,EAAejH,OAAOiH,aAC1BnY,EAAOxD,QAAU2b,G,uBCHjB,IAAIC,EAAQ,EAAQ,QAEhBnZ,EAAS,GAAGA,OAChBe,EAAOxD,QAsBP,SAAsBgF,GACpB,GAAIA,EAAQgO,iBAAmBhO,EAAQkO,mBACrC,MAAM,IAAIb,UAAU,4EAGtB,OAAOrN,EAAQgO,iBAAmBhO,EAAQkO,oBAAsBlO,EAAQ8N,aAKxE,SAAmB+I,GACjBD,EAAMC,EAAM,UAAWC,SAN0E3Z,EAgBnG,SAAS2Z,EAAUrV,EAAM3E,EAAOiF,GAE9B,IAAIgV,EAYJ,GAVI/W,EAAQgO,gBACV+I,GAAU/W,EAAQgO,gBAAgBgJ,SAASvV,EAAKuQ,SACvChS,EAAQkO,qBACjB6I,EAAS/W,EAAQkO,mBAAmB8I,SAASvV,EAAKuQ,WAG/C+E,GAAU/W,EAAQ8N,eACrBiJ,GAAU/W,EAAQ8N,aAAarM,EAAM3E,EAAOiF,IAG1CgV,EAAQ,CAEV,IAAIE,EAAa,CAACna,EAAO,GAOzB,OALIkD,EAAQmO,kBAAoB1M,EAAKU,WACnC8U,EAAaA,EAAW/W,OAAOuB,EAAKU,WAGtC1E,EAAO8Y,MAAMxU,EAAOI,SAAU8U,GACvBna,M,kCCnEb0B,EAAOxD,QAAU,EAAQ,S,kCCAzBwD,EAAOxD,QAIP,SAAiBwG,EAAGC,GAClB,OAAOD,EAAEC,EAAM,IAAMA,EAAK4R,MAAO7C,EAAIhP,EAAGC,KAH1C,IAAI+O,EAAM,EAAQ,S,kCCFlB,IAAIjP,EAAY,EAAQ,QAEpBqU,EAAc,EAAQ,QAEtBsB,EAAO,EAAQ,QAGnB1Y,EAAOxD,QAKP,SAAcwS,EAAQpS,GACpB,IAAI6a,EAAS1U,EAAUnG,GACnB0Y,EAAO1Y,EACP+b,EAAOD,EAEX,GAAIjB,KAAUzI,EAAOyI,OACnB,OAAOzI,EAAOyE,SAASzE,EAAOyI,OAAOA,IAGnCA,EAAOlZ,OAAS,GAfX,SAegBkZ,EAAO5U,MAAM,EAAG,IAAe+V,EAAM7R,KAAKnK,KAEzC,MAApBA,EAAM0X,OAAO,GACfgB,EAWN,SAA2BS,GACzB,IAAInZ,EAAQmZ,EAAUlT,MAAM,GAAGiB,QAAQ+U,EAAMC,GAC7C,MA/BS,OA+BKlc,EAAM0X,OAAO,GAAG2B,cAAgBrZ,EAAMiG,MAAM,GAb/CkW,CAAkBnc,GAEzBA,EAcN,SAA4B6W,GAC1B,IAAI7W,EAAQ6W,EAAS5Q,MAAM,GAE3B,GAAIgW,EAAK9R,KAAKnK,GACZ,OAAO6W,EAKe,OAFxB7W,EAAQA,EAAMkH,QAAQkV,EAAKC,IAEjB3E,OAAO,KACf1X,EAAQ,IAAMA,GAGhB,MA/CS,OA+CKA,EA3BFsc,CAAmBtc,GAG7B+b,EAAOvB,GAGT,OAAO,IAAIuB,EAAKrD,EAAM1Y,IAxBxB,IAAIgc,EAAQ,kBACRC,EAAO,UACPG,EAAM,SA8CV,SAASC,EAAME,GACb,MAAO,IAAMA,EAAG9C,cAGlB,SAASyC,EAAUK,GACjB,OAAOA,EAAG7E,OAAO,GAAG2B,gB,kCC7DtB,IAAIkC,EAAe,EAAQ,QAqC3BnY,EAAOxD,QAnCP,SAAyB0C,GAOvB,IANA,IAEIC,EACAvC,EACAwc,EAJA9a,GAAS,EACTkF,EAAS,KAKJlF,EAAQY,EAAOX,QAAQ,CAG9B,GAAqB,iBAFrBY,EAAQD,EAAOZ,IAGb1B,EAAQuC,OACH,IAAe,IAAXA,EACTvC,EAAQ,UACH,IAAe,IAAXuC,EACTvC,EAAQ,UACH,IAAe,IAAXuC,EACTvC,EAAQ,YACH,IAAe,IAAXuC,EACTvC,EAAQ,UACH,IAAe,IAAXuC,EAAc,CACvB,GAAIia,EAAO,SACXxc,EAAQ,SAGRA,EAAQub,EAAahZ,GAGvBia,GAAmB,IAAXja,EACRqE,EAAOV,KAAKlG,GAGd,OAAO4G,EAAOyQ,KAAK,M,mBCpCrBjU,EAAOxD,QAEP,SAAkB0Y,GAChB,OAAOA,I,kCCDT,IAAImE,EAAS,EASb,SAASC,IACP,OAAOC,KAAKC,IAAI,IAAKH,GATvB7c,EAAQid,QAAUH,IAClB9c,EAAQkd,WAAaJ,IACrB9c,EAAQmd,kBAAoBL,IAC5B9c,EAAQod,OAASN,IACjB9c,EAAQqd,eAAiBP,IACzB9c,EAAQgZ,eAAiB8D,IACzB9c,EAAQsd,sBAAwBR,K,kCCPhCtZ,EAAOxD,QAEP,SAAcud,GACZ,GAAIA,EACF,MAAMA,I,kCCJV/Z,EAAOxD,QAQP,SAAcwG,EAAGC,GACf,OAAOD,EAAE8T,QAAQ7T,EAAM8O,EAAE,OAAQiI,EAAKhI,EAAIhP,EAAGC,OAP/C,IAAI8O,EAAI,EAAQ,QAEZiI,EAAO,EAAQ,QAEfhI,EAAM,EAAQ,S,8hBCNlB,IAAIvJ,EAAgB,EAAQ,QAW5BzI,EAAOxD,QATP,SAAqB6B,EAAM4b,GACzB,OAAI5b,EAAKE,QACPkK,EAAcpK,EAAMA,EAAKE,OAAQ,EAAG0b,GAC7B5b,GAGF4b,I,kCCRT,IAAI/Z,EAAqB,EAAQ,QAE7BkE,EAA4B,EAAQ,QAEpC8V,EAAsB,EAAQ,QAE9BC,EAAqB,EAAQ,QAE7BC,EAAe,EAAQ,QAEvBrY,EAAe,EAAQ,QAEvBsY,EAAoB,EAAQ,QAE5BC,EAAe,EAAQ,QAEvBjD,EAAa,CACfjX,KAAM,aACN9C,SAOF,SAA4BC,EAAS8C,EAAIC,GACvC,IACI2Q,EADAzT,EAAOC,KAEX,OAEA,SAAeM,GAEb,OADAR,EAAQU,MAAM,cACPmc,EAAa3b,KAAKjB,EAAMD,EAASgd,EAAYja,EAAK,kBAAmB,wBAAyB,wBAA9F8Z,CAAuHrc,IAGhI,SAASwc,EAAWxc,GAGlB,OAFAkT,EAAaiJ,EAAoB1c,EAAKyJ,eAAezJ,EAAKqB,OAAOrB,EAAKqB,OAAON,OAAS,GAAG,IAAIsE,MAAM,GAAI,IAE1F,KAAT9E,GACFR,EAAQU,MAAM,oBACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,oBAENic,EAAkB9c,EAAS4c,EAAmB5c,EAASA,EAAQK,QAAQ4c,EAAgBzY,EAAaxE,EAASqT,EAAO,cAAe7O,EAAaxE,EAASqT,EAAO,eAAgBtQ,EAAK,wBAAyB,+BAAgC,qCAAsC,2BAA4B,iCAGlTA,EAAIvC,GAGb,SAAS6S,EAAM7S,GACb,OAAa,OAATA,GAAiBmC,EAAmBnC,IACtCR,EAAQa,KAAK,cAETZ,EAAKG,OAAO8D,QAAQ4E,QAAQ4K,GAAc,GAC5CzT,EAAKG,OAAO8D,QAAQqB,KAAKmO,GAGpB5Q,EAAGtC,IAGLuC,EAAIvC,MAxCXyc,EAAiB,CACnBld,SA2CF,SAAuBC,EAAS8C,EAAIC,GAClC,OAEA,SAAevC,GACb,OAAOqG,EAA0BrG,GAAQsc,EAAkB9c,EAASkd,EAA3BJ,CAAmCtc,GAAQuC,EAAIvC,IAG1F,SAAS0c,EAAO1c,GACd,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzBuc,EAAa/c,EAASwE,EAAaxE,EAASqT,EAAO,cAAetQ,EAAK,kBAAmB,wBAAyB,wBAAnHga,CAA4Ivc,GAG9IuC,EAAIvC,GAGb,SAAS6S,EAAM7S,GACb,OAAgB,OAATA,GAAiBmC,EAAmBnC,GAAQsC,EAAGtC,GAAQuC,EAAIvC,KA1DpEwK,SAAS,GA8DXvI,EAAOxD,QAAU6a,G,kCCpFjBrX,EAAOxD,QAIP,SAAuBwG,EAAGC,GACxB,OAAOD,EAAEC,EAAM,MAAO+O,EAAIhP,EAAGC,KAH/B,IAAI+O,EAAM,EAAQ,S,oCCFlB,IAAI1B,EAAQ,EAAQ,QAEhBC,EAAQ,EAAQ,QAEhBC,EAAM,EAAQ,QAEdC,EAAQ,EAAQ,QAEhBC,EAAO,EAAQ,QAEfkC,EAAM,EAAQ,QAElB5S,EAAOxD,QAAU8T,EAAM,CAACE,EAAKD,EAAOE,EAAOC,EAAMkC,K,kCCZjD,IAEI8H,EAAiB,CACnBta,KAAM,iBACN9C,SAIF,SAAgCC,EAAS8C,EAAIC,GAC3C,IAAI9C,EAAOC,KACX,OAEA,SAAeM,GAMb,OALAR,EAAQU,MAAM,aACdV,EAAQU,MAAM,eACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,eACbb,EAAQa,KAAK,aACNwS,GAGT,SAASA,EAAM7S,GAEb,OAAgB,KAATA,GAEP,2BAA4BP,EAAKG,OAAOD,WAExC4C,EAAIvC,GAAQsC,EAAGtC,KAtBjBZ,WALa,EAAQ,QAKAA,YA0BvB6C,EAAOxD,QAAUke,G,kCCdjB1a,EAAOxD,QAjBP,SAAoBkB,EAAYmB,EAAQC,GAKtC,IAJA,IAEI6B,EAFAga,EAAS,GACTrc,GAAS,IAGJA,EAAQZ,EAAWa,SAC1BoC,EAAUjD,EAAWY,GAAOnB,aAEbwd,EAAOtU,QAAQ1F,GAAW,IACvC9B,EAAS8B,EAAQ9B,EAAQC,GACzB6b,EAAO7X,KAAKnC,IAIhB,OAAO9B,I,oCCdT,IAAIqB,EAAqB,EAAQ,QAE7BpD,EAAU,EAAQ,QAElBiF,EAAe,EAAQ,QAEvB6Y,EAAkB,CACpBxa,KAAM,kBACN9C,SAyDF,SAAiCC,EAAS8C,EAAIC,GAC5C,IAEI0D,EACA6W,EAHArd,EAAOC,KACPa,EAAQd,EAAKqB,OAAON,OAIxB,KAAOD,KAGL,GAAmC,eAA/Bd,EAAKqB,OAAOP,GAAO,GAAGS,MAAwD,eAA/BvB,EAAKqB,OAAOP,GAAO,GAAGS,MAAwD,YAA/BvB,EAAKqB,OAAOP,GAAO,GAAGS,KAAoB,CAC1I8b,EAA2C,cAA/Brd,EAAKqB,OAAOP,GAAO,GAAGS,KAClC,MAIJ,OAEA,SAAehB,GACb,IAAKP,EAAKiM,OAASjM,EAAKmK,WAAakT,GAInC,OAHAtd,EAAQU,MAAM,qBACdV,EAAQU,MAAM,6BACd+F,EAASjG,EACF2C,EAAgB3C,GAGzB,OAAOuC,EAAIvC,IAGb,SAAS2C,EAAgB3C,GACvB,OAAIA,IAASiG,GACXzG,EAAQW,QAAQH,GACT2C,IAGTnD,EAAQa,KAAK,6BACN2D,EAAaxE,EAASud,EAAoB,aAA1C/Y,CAAwDhE,IAGjE,SAAS+c,EAAmB/c,GAC1B,OAAa,OAATA,GAAiBmC,EAAmBnC,IACtCR,EAAQa,KAAK,qBACNiC,EAAGtC,IAGLuC,EAAIvC,KApGbgN,UAGF,SAAkClM,EAAQC,GACxC,IACIoC,EACAnE,EACAsa,EACA0D,EAJAzc,EAAQO,EAAON,OAOnB,KAAOD,KACL,GAAyB,UAArBO,EAAOP,GAAO,GAAgB,CAChC,GAA8B,YAA1BO,EAAOP,GAAO,GAAGS,KAAoB,CACvCmC,EAAU5C,EACV,MAG4B,cAA1BO,EAAOP,GAAO,GAAGS,OACnBhC,EAAOuB,OAIuB,YAA1BO,EAAOP,GAAO,GAAGS,MAEnBF,EAAOI,OAAOX,EAAO,GAGlB+Y,GAAwC,eAA1BxY,EAAOP,GAAO,GAAGS,OAClCsY,EAAa/Y,GAKrByc,EAAU,CACRhc,KAAM,gBACNlB,MAAOf,EAAQ+B,EAAO9B,GAAM,GAAGc,OAC/BmB,IAAKlC,EAAQ+B,EAAOA,EAAON,OAAS,GAAG,GAAGS,MAG5CH,EAAO9B,GAAM,GAAGgC,KAAO,oBAGnBsY,GACFxY,EAAOI,OAAOlC,EAAM,EAAG,CAAC,QAASge,EAASjc,IAC1CD,EAAOI,OAAOoY,EAAa,EAAG,EAAG,CAAC,OAAQxY,EAAOqC,GAAS,GAAIpC,IAC9DD,EAAOqC,GAAS,GAAGlC,IAAMlC,EAAQ+B,EAAOwY,GAAY,GAAGrY,MAEvDH,EAAOqC,GAAS,GAAK6Z,EAKvB,OADAlc,EAAOiE,KAAK,CAAC,OAAQiY,EAASjc,IACvBD,IAmDTmB,EAAOxD,QAAUoe,G,kCChHjB5a,EAAOxD,QADI,CAAC,MAAO,SAAU,QAAS,a,kCCAtC,IAAI0H,EAAa,EAAQ,QAErBC,EAAoB,EAAQ,QAE5BjE,EAAqB,EAAQ,QAE7BkE,EAA4B,EAAQ,QAEpC/B,EAAgB,EAAQ,QAExB8V,EAAe,EAAQ,QAEvB6C,EAAiB,EAAQ,QAEzBC,EAAe,EAAQ,QAEvB7T,EAAmB,EAAQ,QAE3B8T,EAAW,CACb9a,KAAM,WACN9C,SA8BF,SAA0BC,EAAS8C,EAAIC,GACrC,IACIgH,EACA6T,EACA7W,EACAhG,EACA0F,EALAxG,EAAOC,KAMX,OAEA,SAAeM,GAIb,OAHAR,EAAQU,MAAM,YACdV,EAAQU,MAAM,gBACdV,EAAQW,QAAQH,GACTyG,GAGT,SAASA,EAAKzG,GACZ,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACTqd,GAGI,KAATrd,GACFR,EAAQW,QAAQH,GACT2G,GAGI,KAAT3G,GACFR,EAAQW,QAAQH,GAChBuJ,EAAO,EAGA9J,EAAKmK,UAAYtH,EAAKgb,GAG3BnX,EAAWnG,IACbR,EAAQW,QAAQH,GAChBuG,EAAS6T,EAAapa,GACtBod,GAAW,EACJ3H,GAGFlT,EAAIvC,GAGb,SAASqd,EAAiBrd,GACxB,OAAa,KAATA,GACFR,EAAQW,QAAQH,GAChBuJ,EAAO,EACAgU,GAGI,KAATvd,GACFR,EAAQW,QAAQH,GAChBuJ,EAAO,EACPhD,EAAS,SACThG,EAAQ,EACDid,GAGLrX,EAAWnG,IACbR,EAAQW,QAAQH,GAChBuJ,EAAO,EACA9J,EAAKmK,UAAYtH,EAAKgb,GAGxB/a,EAAIvC,GAGb,SAASud,EAAkBvd,GACzB,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACTP,EAAKmK,UAAYtH,EAAKgb,GAGxB/a,EAAIvC,GAGb,SAASwd,EAAgBxd,GACvB,OAAIA,IAASuG,EAAO5E,WAAWpB,MAC7Bf,EAAQW,QAAQH,GACTO,IAAUgG,EAAO/F,OAASf,EAAKmK,UAAYtH,EAAK6H,EAAeqT,GAGjEjb,EAAIvC,GAGb,SAAS2G,EAAc3G,GACrB,OAAImG,EAAWnG,IACbR,EAAQW,QAAQH,GAChBuG,EAAS6T,EAAapa,GACfyV,GAGFlT,EAAIvC,GAGb,SAASyV,EAAQzV,GACf,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAeqG,EAA0BrG,GAC9D,KAATA,GAAeod,GAAYF,EAAa5U,QAAQ/B,EAAO+R,gBAAkB,GAC3E/O,EAAO,EACA9J,EAAKmK,UAAYtH,EAAGtC,GAAQmK,EAAanK,IAG9Cid,EAAe3U,QAAQ/B,EAAO+R,gBAAkB,GAClD/O,EAAO,EAEM,KAATvJ,GACFR,EAAQW,QAAQH,GACTyd,GAGFhe,EAAKmK,UAAYtH,EAAGtC,GAAQmK,EAAanK,KAGlDuJ,EAAO,EAEA9J,EAAKmK,UAAYrH,EAAIvC,GAAQod,EAAWM,EAA4B1d,GAAQ2d,EAAwB3d,IAGhG,KAATA,GAAeoG,EAAkBpG,IACnCR,EAAQW,QAAQH,GAChBuG,GAAU6T,EAAapa,GAChByV,GAGFlT,EAAIvC,GAGb,SAASyd,EAAiBzd,GACxB,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACTP,EAAKmK,UAAYtH,EAAK6H,GAGxB5H,EAAIvC,GAGb,SAAS2d,EAAwB3d,GAC/B,OAAIsE,EAActE,IAChBR,EAAQW,QAAQH,GACT2d,GAGFC,EAAY5d,GAGrB,SAAS0d,EAA4B1d,GACnC,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACT4d,GAGI,KAAT5d,GAAwB,KAATA,GAAemG,EAAWnG,IAC3CR,EAAQW,QAAQH,GACT6d,GAGLvZ,EAActE,IAChBR,EAAQW,QAAQH,GACT0d,GAGFE,EAAY5d,GAGrB,SAAS6d,EAAsB7d,GAC7B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAeoG,EAAkBpG,IAChFR,EAAQW,QAAQH,GACT6d,GAGFC,EAA2B9d,GAGpC,SAAS8d,EAA2B9d,GAClC,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACT+d,GAGLzZ,EAActE,IAChBR,EAAQW,QAAQH,GACT8d,GAGFJ,EAA4B1d,GAGrC,SAAS+d,EAA6B/d,GACpC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzDuC,EAAIvC,GAGA,KAATA,GAAwB,KAATA,GACjBR,EAAQW,QAAQH,GAChBiG,EAASjG,EACFge,GAGL1Z,EAActE,IAChBR,EAAQW,QAAQH,GACT+d,IAGT9X,OAASrF,EACFqd,EAA+Bje,IAGxC,SAASge,EAA6Bhe,GACpC,OAAIA,IAASiG,GACXzG,EAAQW,QAAQH,GACTke,GAGI,OAATle,GAAiBmC,EAAmBnC,GAC/BuC,EAAIvC,IAGbR,EAAQW,QAAQH,GACTge,GAGT,SAASC,EAA+Bje,GACtC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAeqG,EAA0BrG,GAChI8d,EAA2B9d,IAGpCR,EAAQW,QAAQH,GACTie,GAGT,SAASC,EAAkCle,GACzC,OAAa,KAATA,GAAwB,KAATA,GAAesE,EAActE,GACvC0d,EAA4B1d,GAG9BuC,EAAIvC,GAGb,SAAS4d,EAAY5d,GACnB,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACTme,GAGF5b,EAAIvC,GAGb,SAASme,EAAcne,GACrB,OAAIsE,EAActE,IAChBR,EAAQW,QAAQH,GACTme,GAGO,OAATne,GAAiBmC,EAAmBnC,GAAQmK,EAAanK,GAAQuC,EAAIvC,GAG9E,SAASmK,EAAanK,GACpB,OAAa,KAATA,GAAwB,IAATuJ,GACjB/J,EAAQW,QAAQH,GACToe,GAGI,KAATpe,GAAwB,IAATuJ,GACjB/J,EAAQW,QAAQH,GACTqe,GAGI,KAATre,GAAwB,IAATuJ,GACjB/J,EAAQW,QAAQH,GACTse,GAGI,KAATte,GAAwB,IAATuJ,GACjB/J,EAAQW,QAAQH,GACTsd,GAGI,KAATtd,GAAwB,IAATuJ,GACjB/J,EAAQW,QAAQH,GACTue,IAGLpc,EAAmBnC,IAAmB,IAATuJ,GAAuB,IAATA,EAIlC,OAATvJ,GAAiBmC,EAAmBnC,GAC/Bwe,EAAyBxe,IAGlCR,EAAQW,QAAQH,GACTmK,GARE3K,EAAQkK,MAAM+U,EAAoBH,EAAmBE,EAArDhf,CAA+EQ,GAW1F,SAASwe,EAAyBxe,GAEhC,OADAR,EAAQa,KAAK,gBACNqe,EAAkB1e,GAG3B,SAAS0e,EAAkB1e,GACzB,OAAa,OAATA,EACK+Z,EAAK/Z,GAGVmC,EAAmBnC,IACrBR,EAAQU,MAAM,cACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,cACNqe,IAGTlf,EAAQU,MAAM,gBACPiK,EAAanK,IAGtB,SAASoe,EAA0Bpe,GACjC,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACTsd,GAGFnT,EAAanK,GAGtB,SAASqe,EAAuBre,GAC9B,OAAa,KAATA,GACFR,EAAQW,QAAQH,GAChBuG,EAAS,GACFoY,GAGFxU,EAAanK,GAGtB,SAAS2e,EAAsB3e,GAC7B,OAAa,KAATA,GAAekd,EAAa5U,QAAQ/B,EAAO+R,gBAAkB,GAC/D9Y,EAAQW,QAAQH,GACTse,GAGLnY,EAAWnG,IAASuG,EAAO/F,OAAS,GACtChB,EAAQW,QAAQH,GAChBuG,GAAU6T,EAAapa,GAChB2e,GAGFxU,EAAanK,GAGtB,SAASue,EAAgCve,GACvC,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACTsd,GAGFnT,EAAanK,GAGtB,SAASsd,EAA8Btd,GACrC,OAAa,KAATA,GACFR,EAAQW,QAAQH,GACTse,GAGFnU,EAAanK,GAGtB,SAASse,EAAkBte,GACzB,OAAa,OAATA,GAAiBmC,EAAmBnC,IACtCR,EAAQa,KAAK,gBACN0Z,EAAK/Z,KAGdR,EAAQW,QAAQH,GACTse,GAGT,SAASvE,EAAK/Z,GAEZ,OADAR,EAAQa,KAAK,YACNiC,EAAGtC,KA1ZZgN,UAQF,SAA2BlM,GACzB,IAAIP,EAAQO,EAAON,OAEnB,KAAOD,MACoB,UAArBO,EAAOP,GAAO,IAA4C,aAA1BO,EAAOP,GAAO,GAAGS,QAKnDT,EAAQ,GAAmC,eAA9BO,EAAOP,EAAQ,GAAG,GAAGS,OAEpCF,EAAOP,GAAO,GAAGT,MAAQgB,EAAOP,EAAQ,GAAG,GAAGT,MAE9CgB,EAAOP,EAAQ,GAAG,GAAGT,MAAQgB,EAAOP,EAAQ,GAAG,GAAGT,MAElDgB,EAAOI,OAAOX,EAAQ,EAAG,IAG3B,OAAOO,GAzBP8d,UAAU,GAERH,EAAqB,CACvBlf,SA0ZF,SAA2BC,EAAS8C,EAAIC,GACtC,OAEA,SAAevC,GAKb,OAJAR,EAAQa,KAAK,gBACbb,EAAQU,MAAM,mBACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,mBACNb,EAAQK,QAAQwJ,EAAkB/G,EAAIC,KAja/CiI,SAAS,GAqaXvI,EAAOxD,QAAU0e,G,kCC/bjBlb,EAAOxD,QAQP,SAAewG,EAAGC,GAChB,IAKIhC,EACA2b,EACAC,EACAzc,EACA0c,EATAC,EAAO9Z,EAAKU,SACZrF,EAAQye,EAAKxe,OACbuW,EAAQ7R,EAAK6R,OAAS,GACtBkI,EAAclI,EAAMvW,OACpBiF,EAAS,GAOb,KAAOlF,KAAS,CAMd,IALAse,EAAMG,EAAKze,GAAOqF,SAClBvD,EAAiB,IAAV9B,EAAc,KAAO,KAC5B2C,EAAM+b,GAAeJ,EAAIre,OACzBse,EAAM,GAEC5b,KACL6b,EAAOF,EAAI3b,GACX4b,EAAI5b,GAAO+B,EAAE8Z,EAAM1c,EAAM,CACvB0U,MAAOA,EAAM7T,IACZ6b,EAAO9K,EAAIhP,EAAG8Z,GAAQ,IAG3BtZ,EAAOlF,GAAS0E,EAAE+Z,EAAKze,GAAQ,KAAM0b,EAAK6C,GAAK,IAGjD,OAAO7Z,EAAEC,EAAM,QAAS+W,EAAK,CAAChX,EAAEQ,EAAO,GAAGxC,SAAU,QAASgZ,EAAK,CAACxW,EAAO,KAAK,KAAQ9B,OAAO8B,EAAO,GAAKR,EAAE,CAC1GnF,MAAOmD,EAASnD,MAAM2F,EAAO,IAC7BxE,IAAKgC,EAAShC,IAAIwE,EAAOA,EAAOjF,OAAS,KACxC,QAASyb,EAAKxW,EAAOX,MAAM,IAAI,IAAS,KAAK,KArClD,IAAI7B,EAAW,EAAQ,QAEnBgZ,EAAO,EAAQ,QAEfhI,EAAM,EAAQ,S,kCCNlBtV,OAAOC,eAAeH,EAAS,aAAc,CAC3CI,OAAO,IAGT,IAAIsE,EAAU,EAAQ,QAElBa,EAAe,EAAQ,QAEvBqF,EAAmB,EAAQ,QAE3B9J,EAEJ,SAAwBC,GACtB,IAAIC,EAAOC,KACPwf,EAAU1f,EAAQK,QACtBwJ,GAIA,SAAuBrJ,GACrB,GAAa,OAATA,EAEF,YADAR,EAAQW,QAAQH,GAQlB,OAJAR,EAAQU,MAAM,mBACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,mBACbZ,EAAK6M,sBAAmB1L,EACjBse,IAbT1f,EAAQK,QAAQH,KAAKE,OAAOD,WAAWwf,YAAaC,EAAgBpb,EAAaxE,EAASA,EAAQK,QAAQH,KAAKE,OAAOD,WAAW0D,KAAM+b,EAAgB5f,EAAQK,QAAQsD,EAASic,IAAkB,gBAClM,OAAOF,EAeP,SAASE,EAAepf,GACtB,GAAa,OAATA,EASJ,OAJAR,EAAQU,MAAM,cACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,cACbZ,EAAK6M,sBAAmB1L,EACjBse,EARL1f,EAAQW,QAAQH,KAYtBvB,EAAQc,SAAWA,G,kCC9CnB0C,EAAOxD,QAAU,EAAQ,S,kCCAzB,IAAI4b,EAAQ,EAAQ,QAEpBpY,EAAOxD,QAGP,SAA8ByG,EAAMzB,GAClC,OAwBF,SAAuB4b,GACrB,OAEA,SAAgBnM,GACd,IAAIvD,EAAKuD,GAAcoM,EAAUpM,GACjC,OAAOvD,GAAM5M,EAAIrC,KAAK2e,EAAO1P,GAAM0P,EAAM1P,GAAM,MA7B1C4P,CAIT,SAAgBra,GACd,IAAIma,EAAQ,GAEZ,IAAKna,IAASA,EAAKlE,KACjB,MAAM,IAAImZ,MAAM,wCAIlB,OADAE,EAAMnV,EAAM,cAGZ,SAAsBoU,GACpB,IAAI3J,EAAK2P,EAAUhG,EAAWpG,YAEzBnQ,EAAIrC,KAAK2e,EAAO1P,KACnB0P,EAAM1P,GAAM2J,MANT+F,EAZcG,CAAOta,KAH9B,IAAInC,EAAM,GAAGC,eAoCb,SAASsc,EAAUpM,GACjB,OAAOA,EAAWgF,gB,mBCxCpB,IAAIuH,EAAgB,kCAChBC,EAAgB,MAChBC,EAAmB,OAEnBC,EAAiB,yCACjBC,EAAc,QACdC,EAAc,uDACdC,EAAkB,UAElBC,EAAa,aAoPjB,SAASC,EAAKC,GACZ,OAAOA,EAAMA,EAAIna,QAAQia,EAhPR,OAYnB/d,EAAOxD,QAAU,SAAUyW,EAAOzR,GAChC,GAAqB,iBAAVyR,EACT,MAAM,IAAIpE,UAAU,mCAGtB,IAAKoE,EAAO,MAAO,GACnBzR,EAAUA,GAAW,GAKrB,IAAI0c,EAAS,EACTte,EAAS,EAOb,SAASue,EAAeF,GACtB,IAAIG,EAAQH,EAAII,MAAMZ,GAClBW,IAAOF,GAAUE,EAAM7f,QAC3B,IAAImO,EAAIuR,EAAIK,YArCF,MAsCV1e,GAAU8M,EAAIuR,EAAI1f,OAASmO,EAAI9M,EAASqe,EAAI1f,OAS9C,SAASyC,IACP,IAAInD,EAAQ,CACV8B,KAAMue,EACNte,OAAQA,GAEV,OAAO,SAAUqD,GAGf,OAFAA,EAAKjC,SAAW,IAAIud,EAAS1gB,GAC7B2gB,IACOvb,GAaX,SAASsb,EAAS1gB,GAChBJ,KAAKI,MAAQA,EACbJ,KAAKuB,IAAM,CACTW,KAAMue,EACNte,OAAQA,GAEVnC,KAAKqQ,OAAStM,EAAQsM,OAOxByQ,EAAStT,UAAU/J,QAAU+R,EAC7B,IAAIwL,EAAa,GAQjB,SAASzG,EAAM0G,GACb,IAAI3E,EAAM,IAAI7B,MAAM1W,EAAQsM,OAAS,IAAMoQ,EAAS,IAAMte,EAAS,KAAO8e,GAO1E,GANA3E,EAAI4E,OAASD,EACb3E,EAAI6E,SAAWpd,EAAQsM,OACvBiM,EAAIpa,KAAOue,EACXnE,EAAIna,OAASA,EACbma,EAAIjM,OAASmF,GAETzR,EAAQqd,OAGV,MAAM9E,EAFN0E,EAAW3b,KAAKiX,GAapB,SAASsE,EAAMS,GACb,IAAIC,EAAID,EAAGE,KAAK/L,GAChB,GAAK8L,EAAL,CACA,IAAId,EAAMc,EAAE,GAGZ,OAFAZ,EAAeF,GACfhL,EAAQA,EAAMpQ,MAAMob,EAAI1f,QACjBwgB,GAOT,SAASP,IACPH,EAAMX,GAUR,SAASuB,EAASC,GAChB,IAAIC,EAGJ,IAFAD,EAAQA,GAAS,GAEVC,EAAIja,MACC,IAANia,GACFD,EAAMpc,KAAKqc,GAIf,OAAOD,EAUT,SAASha,IACP,IAAIjE,EAAMD,IACV,GA7JgB,KA6JKiS,EAAMqB,OAAO,IA5JvB,KA4JyCrB,EAAMqB,OAAO,GAAjE,CAGA,IAFA,IAAI5H,EAAI,EA5JO,IA8JQuG,EAAMqB,OAAO5H,KA/JzB,KA+J4CuG,EAAMqB,OAAO5H,IAhKpD,KAgK2EuG,EAAMqB,OAAO5H,EAAI,OACxGA,EAKJ,GAFAA,GAAK,EAlKU,KAoKMuG,EAAMqB,OAAO5H,EAAI,GACpC,OAAOsL,EAAM,0BAGf,IAAIiG,EAAMhL,EAAMpQ,MAAM,EAAG6J,EAAI,GAK7B,OAJA9M,GAAU,EACVue,EAAeF,GACfhL,EAAQA,EAAMpQ,MAAM6J,GACpB9M,GAAU,EACHqB,EAAI,CACTlC,KA5Ka,UA6KbmG,QAAS+Y,KAWb,SAASlZ,IACP,IAAI9D,EAAMD,IAENsU,EAAO+I,EAAMV,GACjB,GAAKrI,EAAL,CAGA,GAFApQ,KAEKmZ,EAAMT,GAAc,OAAO5F,EAAM,wBAEtC,IAAIoH,EAAMf,EAAMR,GACZwB,EAAMpe,EAAI,CACZlC,KAlMiB,cAmMjB0U,SAAUuK,EAAK1I,EAAK,GAAGxR,QAAQ0Z,EAtMlB,KAuMb5gB,MAAOwiB,EAAMpB,EAAKoB,EAAI,GAAGtb,QAAQ0Z,EAvMpB,UA2Mf,OADAa,EAAMP,GACCuB,GA0BT,OADAb,IAhBA,WACE,IAGIc,EAHAC,EAAQ,GAKZ,IAJAN,EAASM,GAIFD,EAAOva,MACC,IAATua,IACFC,EAAMzc,KAAKwc,GACXL,EAASM,IAIb,OAAOA,EAIF7I,K,oCC7OT1W,EAAOxD,QADkB,ovC,kCCLzB,IAAIK,EAAS,EAAQ,QAEjB4L,EAAgB,EAAQ,QAExB3L,EAAU,EAAQ,QAsFtB,SAAS0iB,EAAW3gB,EAAQW,GAiB1B,IAhBA,IAQIigB,EACAjhB,EACAF,EACAohB,EACA1gB,EACA2gB,EAbApgB,EAAQV,EAAOW,GAAY,GAC3BV,EAAUD,EAAOW,GAAY,GAC7BogB,EAAgBpgB,EAAa,EAC7BqgB,EAAiB,GACjBC,EAAYvgB,EAAMwgB,YAAcjhB,EAAQnB,OAAO4B,EAAM4C,aAAa5C,EAAM1B,OACxEmiB,EAAcF,EAAUjhB,OACxBohB,EAAQ,GACRC,EAAO,GASJ3gB,GAAO,CAEZ,KAAOV,IAAS+gB,GAAe,KAAOrgB,IAGtCsgB,EAAe/c,KAAK8c,GAEfrgB,EAAMwgB,aACTN,EAAS3gB,EAAQW,YAAYF,GAExBA,EAAM6C,MACTqd,EAAO3c,KAAK,MAGVtE,GACFshB,EAAUpW,WAAWnK,EAAM1B,OAGzB0B,EAAM4gB,6BACRL,EAAUM,oCAAqC,GAGjDN,EAAUnW,MAAM8V,GAEZlgB,EAAM4gB,6BACRL,EAAUM,wCAAqCzhB,IAKnDH,EAAWe,EACXA,EAAQA,EAAM6C,KAQhB,IAHA7C,EAAQf,EACRF,EAAQ0hB,EAAYzhB,OAEbD,KAGyB,UAA1B0hB,EAAY1hB,GAAO,GACrBohB,GAAU,EAEZA,GAAWM,EAAY1hB,GAAO,GAAGS,OAASihB,EAAY1hB,EAAQ,GAAG,GAAGS,MAAQihB,EAAY1hB,GAAO,GAAGT,MAAM8B,OAASqgB,EAAY1hB,GAAO,GAAGU,IAAIW,OACzI0gB,EAAIL,EAAYnd,MAAMvE,EAAQ,EAAGU,IAEjCO,EAAMwgB,WAAaxgB,EAAM6C,UAAOzD,EAChCY,EAAQA,EAAMf,SACdQ,EAAMV,EAAQ,GAWlB,IANAwhB,EAAUjhB,OAASU,EAAMwgB,WAAaxgB,EAAM6C,UAAOzD,EAEnD0hB,EAAIL,EAAYnd,MAAM,EAAG7D,IACzBV,GAAS,EACTqhB,EAAS,IAEArhB,EAAQ2hB,EAAM1hB,QACrB2hB,EAAKP,EAASM,EAAM3hB,GAAO,IAAMqhB,EAASM,EAAM3hB,GAAO,GACvDqhB,GAAUM,EAAM3hB,GAAO,GAAK2hB,EAAM3hB,GAAO,GAAK,EAGhD,OAAO4hB,EAEP,SAASG,EAAIxd,GACX,IAAIhF,EAAQgiB,EAAe1W,MAC3B8W,EAAMhO,QAAQ,CAACpU,EAAOA,EAAQgF,EAAMtE,OAAS,IAC7CkK,EAAc5J,EAAQhB,EAAO,EAAGgF,IAIpC7C,EAAOxD,QAhLP,SAAqBqC,GAWnB,IAVA,IAEIyhB,EACAC,EACAC,EACAC,EACAhI,EACAiI,EACAC,EARAV,EAAQ,GACR3hB,GAAS,IASJA,EAAQO,EAAON,QAAQ,CAC9B,KAAOD,KAAS2hB,GACd3hB,EAAQ2hB,EAAM3hB,GAMhB,GAHAgiB,EAAQzhB,EAAOP,GAGXA,GAA2B,cAAlBgiB,EAAM,GAAGvhB,MAAsD,mBAA9BF,EAAOP,EAAQ,GAAG,GAAGS,QAEjEyhB,EAAa,IADbE,EAAYJ,EAAM,GAAGP,WAAWlhB,QAGLN,QAA4C,oBAAlCmiB,EAAUF,GAAY,GAAGzhB,OAC5DyhB,GAAc,GAGZA,EAAaE,EAAUniB,QAA4C,YAAlCmiB,EAAUF,GAAY,GAAGzhB,MAC5D,OAASyhB,EAAaE,EAAUniB,QACQ,YAAlCmiB,EAAUF,GAAY,GAAGzhB,MAIS,cAAlC2hB,EAAUF,GAAY,GAAGzhB,OAC3B2hB,EAAUF,GAAY,GAAGL,4BAA6B,EACtDK,KAOR,GAAiB,UAAbF,EAAM,GACJA,EAAM,GAAGne,cACXtF,EAAOojB,EAAOT,EAAW3gB,EAAQP,IACjCA,EAAQ2hB,EAAM3hB,GACdqiB,GAAO,QAGN,GAAIL,EAAM,GAAG9Y,YAAc8Y,EAAM,GAAGM,yBAA0B,CAI/D,IAHAJ,EAAaliB,EACbiiB,OAAY5hB,EAEL6hB,MAGsB,gBAF3BC,EAAa5hB,EAAO2hB,IAEL,GAAGzhB,MAAgD,oBAAvB0hB,EAAW,GAAG1hB,OACjC,UAAlB0hB,EAAW,KACTF,IACF1hB,EAAO0hB,GAAW,GAAGxhB,KAAO,mBAG9B0hB,EAAW,GAAG1hB,KAAO,aACrBwhB,EAAYC,GAOdD,IAEFD,EAAM,GAAGthB,IAAMlC,EAAQ+B,EAAO0hB,GAAW,GAAG1iB,QAE5C4a,EAAa5Z,EAAOgE,MAAM0d,EAAWjiB,IAC1B2T,QAAQqO,GACnB7X,EAAc5J,EAAQ0hB,EAAWjiB,EAAQiiB,EAAY,EAAG9H,KAKhE,OAAQkI,I,kCCvFV,IAAIzgB,EAAqB,EAAQ,QAE7BuI,EAAgB,EAAQ,QAExBvB,EAAa,EAAQ,QAErBnF,EAAe,EAAQ,QAEvB8e,EAAe,CACjBzgB,KAAM,eACN9C,SAmBF,SAA8BC,EAAS8C,EAAIC,GACzC,OAAO/C,EAAQK,QAAQkjB,EAA0B5a,EAAa5F,GAE9D,SAAS4F,EAAYnI,GACnB,OAAa,OAATA,EACKsC,EAAGtC,GAGRmC,EAAmBnC,GACdR,EAAQK,QAAQkjB,EAA0B5a,EAAa7F,EAAvD9C,CAA2DQ,IAGpER,EAAQU,MAAM,iBACPiD,EAAQnD,IAGjB,SAASmD,EAAQnD,GACf,OAAa,OAATA,GAAiBmC,EAAmBnC,IACtCR,EAAQa,KAAK,iBACN8H,EAAYnI,KAGrBR,EAAQW,QAAQH,GACTmD,KAzCTP,QAOF,SAA6B9B,EAAQC,GACnC,IAAIf,EAAO,CACTgB,KAAM,eACNlB,MAAOgB,EAAO,GAAG,GAAGhB,MACpBmB,IAAKH,EAAOA,EAAON,OAAS,GAAG,GAAGS,KAIpC,OAFAyJ,EAAc5J,EAAQ,EAAG,EAAG,CAAC,CAAC,QAASd,EAAMe,KAC7C2J,EAAc5J,EAAQA,EAAON,OAAQ,EAAG,CAAC,CAAC,OAAQR,EAAMe,KACjDD,IAbLiiB,EAA2B,CAC7BxjB,SA0CF,SAAiCC,EAAS8C,EAAIC,GAC5C,IAAI9C,EAAOC,KACX,OAAOsE,EAAaxE,GAEpB,SAAS2I,EAAYnI,GACnB,GAAImC,EAAmBnC,GAIrB,OAHAR,EAAQU,MAAM,cACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,cACN2D,EAAaxE,EAAS2I,EAAa,aAAc,GAG1D,OAAOgB,EAAW1J,EAAKqB,OAAQ,cAAgB,EAAIyB,EAAIvC,GAAQsC,EAAGtC,KAV1B,aAAc,IA3CxDwK,SAAS,GAyDXvI,EAAOxD,QAAUqkB,G,kCCxEjB,IAAIhkB,EAASH,OAAOG,OACpBmD,EAAOxD,QAAUK,G,kCCDjB,IAEIsH,EAFa,EAAQ,OAED2M,CAAW,cACnC9Q,EAAOxD,QAAU2H,G,oCCHjB,IAAIgD,EAAa,EAAQ,QAQzBnH,EAAOxD,QANP,SAAoBqC,EAAQE,GAC1B,IAAI2S,EAAO7S,EAAOA,EAAON,OAAS,GAClC,OAAKmT,GAAQA,EAAK,GAAG3S,OAASA,EACvBoI,EAAWuK,EAAK,GAAGjS,YAAYiS,EAAK,KADA,I,kCCJ7C,IAAItN,EAA4B,EAAQ,QAEpCoE,EAAc,EAAQ,QAEtBC,EAAgB,EAAQ,QAExByR,EAAsB,EAAQ,QAE9B/c,EAAa,EAAQ,QAErBL,EAAU,EAAQ,QAElBqd,EAAqB,EAAQ,QAE7BC,EAAe,EAAQ,QAEvBE,EAAe,EAAQ,QAEvBD,EAAoB,EAAQ,QAE5B0G,EAAW,CACb3gB,KAAM,WACN9C,SAuGF,SAA0BC,EAAS8C,EAAIC,GACrC,IAEI0gB,EACAvf,EAHAjE,EAAOC,KACPa,EAAQd,EAAKqB,OAAON,OAIxB,KAAOD,KACL,IAAoC,eAA/Bd,EAAKqB,OAAOP,GAAO,GAAGS,MAAwD,cAA/BvB,EAAKqB,OAAOP,GAAO,GAAGS,QAA0BvB,EAAKqB,OAAOP,GAAO,GAAG2iB,UAAW,CACnID,EAAaxjB,EAAKqB,OAAOP,GAAO,GAChC,MAIJ,OAEA,SAAeP,GACb,IAAKijB,EACH,OAAO1gB,EAAIvC,GAIb,OAAIijB,EAAWE,UAAkBC,EAASpjB,IAC1C0D,EAAUjE,EAAKG,OAAO8D,QAAQ4E,QAAQ6T,EAAoB1c,EAAKyJ,eAAe,CAC5EpJ,MAAOmjB,EAAWhiB,IAClBA,IAAKxB,EAAK0L,WACJ,EACR3L,EAAQU,MAAM,YACdV,EAAQU,MAAM,eACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,eACbb,EAAQa,KAAK,YACNgjB,IAGT,SAASA,EAAcrjB,GAErB,OAAa,KAATA,EACKR,EAAQK,QAAQyjB,EAAmBhhB,EAAIoB,EAAUpB,EAAK8gB,EAAtD5jB,CAAgEQ,GAI5D,KAATA,EACKR,EAAQK,QAAQ0jB,EAAwBjhB,EAAIoB,EAAUlE,EAAQK,QAAQ2jB,EAA6BlhB,EAAI8gB,GAAYA,EAAnH5jB,CAA6HQ,GAI/H0D,EAAUpB,EAAGtC,GAAQojB,EAASpjB,GAGvC,SAASojB,EAASpjB,GAEhB,OADAijB,EAAWC,WAAY,EAChB3gB,EAAIvC,KAzJbgN,UA+BF,SAA2BlM,EAAQC,GACjC,IAEI0iB,EACA1P,EACA/U,EACAwC,EACAiF,EACAid,EACAC,EARApjB,EAAQO,EAAON,OACfsB,EAAS,EASb,KAAOvB,KAGL,GAFAiB,EAAQV,EAAOP,GAAO,GAElBkG,EAAM,CAER,GAAmB,SAAfjF,EAAMR,MAAkC,cAAfQ,EAAMR,MAAwBQ,EAAM2hB,UAC/D,MAKuB,UAArBriB,EAAOP,GAAO,IAAiC,cAAfiB,EAAMR,OACxCQ,EAAM2hB,WAAY,QAEf,GAAIO,GACT,GAAyB,UAArB5iB,EAAOP,GAAO,KAAkC,eAAfiB,EAAMR,MAAwC,cAAfQ,EAAMR,QAA0BQ,EAAM0hB,YACxGzc,EAAOlG,EAEY,cAAfiB,EAAMR,MAAsB,CAC9Bc,EAAS,EACT,WAGoB,aAAfN,EAAMR,OACf0iB,EAAQnjB,GAiCZ,OA7BAkjB,EAAQ,CACNziB,KAA+B,cAAzBF,EAAO2F,GAAM,GAAGzF,KAAuB,OAAS,QACtDlB,MAAOf,EAAQ+B,EAAO2F,GAAM,GAAG3G,OAC/BmB,IAAKlC,EAAQ+B,EAAOA,EAAON,OAAS,GAAG,GAAGS,MAE5C8S,EAAQ,CACN/S,KAAM,QACNlB,MAAOf,EAAQ+B,EAAO2F,GAAM,GAAG3G,OAC/BmB,IAAKlC,EAAQ+B,EAAO4iB,GAAO,GAAGziB,MAEhCjC,EAAO,CACLgC,KAAM,YACNlB,MAAOf,EAAQ+B,EAAO2F,EAAO3E,EAAS,GAAG,GAAGb,KAC5CA,IAAKlC,EAAQ+B,EAAO4iB,EAAQ,GAAG,GAAG5jB,QAIpC6jB,EAAQlZ,EAFRkZ,EAAQ,CAAC,CAAC,QAASF,EAAO1iB,GAAU,CAAC,QAASgT,EAAOhT,IAE1BD,EAAOgE,MAAM2B,EAAO,EAAGA,EAAO3E,EAAS,IAElE6hB,EAAQlZ,EAAYkZ,EAAO,CAAC,CAAC,QAAS3kB,EAAM+B,KAE5C4iB,EAAQlZ,EAAYkZ,EAAOvkB,EAAW2B,EAAQnB,OAAOD,WAAWikB,WAAWvb,KAAMvH,EAAOgE,MAAM2B,EAAO3E,EAAS,EAAG4hB,EAAQ,GAAI3iB,IAE7H4iB,EAAQlZ,EAAYkZ,EAAO,CAAC,CAAC,OAAQ3kB,EAAM+B,GAAUD,EAAO4iB,EAAQ,GAAI5iB,EAAO4iB,EAAQ,GAAI,CAAC,OAAQ3P,EAAOhT,KAE3G4iB,EAAQlZ,EAAYkZ,EAAO7iB,EAAOgE,MAAM4e,EAAQ,IAEhDC,EAAQlZ,EAAYkZ,EAAO,CAAC,CAAC,OAAQF,EAAO1iB,KAC5C2J,EAAc5J,EAAQ2F,EAAM3F,EAAON,OAAQmjB,GACpC7iB,GAlGP1B,WAYF,SAA4B0B,GAC1B,IACIU,EADAjB,GAAS,EAGb,OAASA,EAAQO,EAAON,SACtBgB,EAAQV,EAAOP,GAAO,IAEXsjB,OAAyB,eAAfriB,EAAMR,MAAwC,cAAfQ,EAAMR,MAAuC,aAAfQ,EAAMR,OAEtFF,EAAOI,OAAOX,EAAQ,EAAkB,eAAfiB,EAAMR,KAAwB,EAAI,GAC3DQ,EAAMR,KAAO,OACbT,KAIJ,OAAOO,IAzBLwiB,EAAoB,CACtB/jB,SAyJF,SAA0BC,EAAS8C,EAAIC,GACrC,OAEA,SAAevC,GAKb,OAJAR,EAAQU,MAAM,YACdV,EAAQU,MAAM,kBACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,kBACNic,EAAkB9c,EAASiH,IAGpC,SAASA,EAAKzG,GACZ,OAAa,KAATA,EACKiB,EAAIjB,GAGNoc,EAAmB5c,EAASskB,EAAkBvhB,EAAK,sBAAuB,6BAA8B,mCAAoC,yBAA0B,4BAA6B,EAAnM6Z,CAAsMpc,GAG/M,SAAS8jB,EAAiB9jB,GACxB,OAAOqG,EAA0BrG,GAAQsc,EAAkB9c,EAASukB,EAA3BzH,CAAoCtc,GAAQiB,EAAIjB,GAG3F,SAAS+jB,EAAQ/jB,GACf,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzBuc,EAAa/c,EAAS8c,EAAkB9c,EAASyB,GAAMsB,EAAK,gBAAiB,sBAAuB,sBAApGga,CAA2Hvc,GAG7HiB,EAAIjB,GAGb,SAASiB,EAAIjB,GACX,OAAa,KAATA,GACFR,EAAQU,MAAM,kBACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,kBACbb,EAAQa,KAAK,YACNiC,GAGFC,EAAIvC,MA/LXujB,EAAyB,CAC3BhkB,SAkMF,SAA+BC,EAAS8C,EAAIC,GAC1C,IAAI9C,EAAOC,KACX,OAEA,SAAeM,GACb,OAAOqc,EAAa3b,KAAKjB,EAAMD,EAASwkB,EAAYzhB,EAAK,YAAa,kBAAmB,kBAAlF8Z,CAAqGrc,IAG9G,SAASgkB,EAAWhkB,GAClB,OAAOP,EAAKG,OAAO8D,QAAQ4E,QAAQ6T,EAAoB1c,EAAKyJ,eAAezJ,EAAKqB,OAAOrB,EAAKqB,OAAON,OAAS,GAAG,IAAIsE,MAAM,GAAI,KAAO,EAAIvC,EAAIvC,GAAQsC,EAAGtC,MAzMvJwjB,EAA8B,CAChCjkB,SA4MF,SAAoCC,EAAS8C,EAAIC,GAC/C,OAEA,SAAevC,GAKb,OAJAR,EAAQU,MAAM,aACdV,EAAQU,MAAM,mBACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,mBACNoG,GAGT,SAASA,EAAKzG,GACZ,OAAa,KAATA,GACFR,EAAQU,MAAM,mBACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,mBACbb,EAAQa,KAAK,aACNiC,GAGFC,EAAIvC,MAIfiC,EAAOxD,QAAUukB,G,kCCrQjB/gB,EAAOxD,QA+GP,SAAgB6b,EAAM7W,GACpB,IAAIwB,EA3FN,SAAiBqV,EAAM7W,GACrB,IAAIwgB,EAAWxgB,GAAW,QAEU7C,IAAhCqjB,EAASC,oBAAqCC,IAChDA,GAA2B,EAC3B9T,QAAQC,KAAK,2GAGf,IAAIwI,EAAYmL,EAASpU,oBAAsBoU,EAASC,mBACpDlR,EAAe,GAUnB,OATA/N,EAAE6T,UAAYA,EACd7T,EAAEqU,WAAa8K,EAAY9J,GAC3BrV,EAAE+N,aAAeA,EACjB/N,EAAEgO,cAAgB,GAClBhO,EAAE8T,QAAUA,EACZ9T,EAAEof,SAAW1lB,OAAOG,OAAO,GAAIulB,EAAUJ,EAASI,UAClDpf,EAAEqf,eAAiBL,EAASK,eAC5Brf,EAAEsf,YAAcN,EAASM,YACzBlK,EAAMC,EAAM,sBA6DZ,SAA8BhB,GAC5B,IAAI3J,EAAKwD,OAAOmG,EAAWpG,YAAYgF,cAGlCnV,EAAIrC,KAAKsS,EAAcrD,KAC1BqD,EAAarD,GAAM2J,MAjEhBrU,EAEP,SAAS8T,EAAQyL,EAAMC,GACrB,IAAIrkB,EACAoX,EAsCJ,OApCIgN,GAAQA,EAAKpkB,QACfA,EAAOokB,EAAKpkB,MAEHskB,QACY,YAAfD,EAAMzjB,OACRyjB,EAAQ,CACNzjB,KAAM,UACNyU,QAAS,GACTG,WAAY,GACZhQ,SAAU,KAId6e,EAAMhP,QAAUrV,EAAKskB,OAGJ,YAAfD,EAAMzjB,MAAsBZ,EAAKukB,cACnCF,EAAM7O,WAAajX,OAAOG,OAAO,GAAI2lB,EAAM7O,WAAYxV,EAAKukB,cAG1DF,EAAM7e,UAAYxF,EAAKwkB,YACzBH,EAAM7e,SAAWxF,EAAKwkB,YAI1BpN,EAAMgN,GAAQA,EAAKvhB,SAAWuhB,EAAO,CACnCvhB,SAAUuhB,GAGPK,EAAUrN,KACbiN,EAAMxhB,SAAW,CACfnD,MAAOmD,EAASnD,MAAM0X,GACtBvW,IAAKgC,EAAShC,IAAIuW,KAIfiN,EAIT,SAASxf,EAAEC,EAAMuQ,EAAStQ,EAAOS,GAM/B,OALI,MAACA,GAAiE,iBAAVT,GAAsB,WAAYA,IAC5FS,EAAWT,EACXA,EAAQ,IAGH4T,EAAQ7T,EAAM,CACnBlE,KAAM,UACNyU,QAASA,EACTG,WAAYzQ,GAAS,GACrBS,SAAUA,GAAY,MAgBlBuS,CAAQmC,EAAM7W,GAClByB,EAAOY,EAAIb,EAAGqV,GACdwK,EAAOC,EAAO9f,GAEd6f,IACF5f,EAAKU,SAAWV,EAAKU,SAASjC,OAAOqQ,EAAE,OAAQ,MAAO8Q,IAGxD,OAAO5f,GAtHT,IAAI8O,EAAI,EAAQ,QAEZqG,EAAQ,EAAQ,QAEhBpX,EAAW,EAAQ,QAEnB4hB,EAAY,EAAQ,QAEpBT,EAAc,EAAQ,QAEtBte,EAAM,EAAQ,QAEdif,EAAS,EAAQ,QAEjBV,EAAW,EAAQ,QAEnBthB,EAAM,GAAGC,eACTmhB,GAA2B,G,kCCnB/BliB,EAAOxD,QAMP,SAAwBwG,EAAGC,GACzB,IACIC,EADA6f,EAAM/f,EAAEqU,WAAWpU,EAAKgO,YAG5B,IAAK8R,EACH,OAAOC,EAAOhgB,EAAGC,GAGnBC,EAAQ,CACNC,IAAKJ,EAAUggB,EAAI3f,KAAO,IAC1BC,IAAKJ,EAAKI,KAGM,OAAd0f,EAAIzf,YAAgC3E,IAAdokB,EAAIzf,QAC5BJ,EAAMI,MAAQyf,EAAIzf,OAGpB,OAAON,EAAEC,EAAM,MAAOC,IArBxB,IAAIH,EAAY,EAAQ,QAEpBigB,EAAS,EAAQ,S,kCCJrB,IAAIC,EAAW,EAAQ,QAEnBC,EAAQ,EAAQ,QAEpBljB,EAAOxD,QAAU0mB,EACjBA,EAAMjY,UAAUkY,QAKhB,SAAiBxE,EAAQ3d,EAAUoiB,GACjC,IAAID,EAAU,IAAIF,EAAStE,EAAQ3d,EAAUoiB,GAEzC3lB,KAAK4lB,OACPF,EAAQ/iB,KAAO3C,KAAK4lB,KAAO,IAAMF,EAAQ/iB,KACzC+iB,EAAQG,KAAO7lB,KAAK4lB,MAKtB,OAFAF,EAAQI,OAAQ,EAChB9lB,KAAK+lB,SAAS1gB,KAAKqgB,GACZA,GAdTD,EAAMjY,UAAU3B,KA0BhB,WACE,IAAI6Z,EAAU1lB,KAAK0lB,QAAQpL,MAAMta,KAAMgP,WAEvC,OADA0W,EAAQI,MAAQ,KACTJ,GA5BTD,EAAMjY,UAAUwY,KAiBhB,WACE,IAAIN,EAAU1lB,KAAK0lB,QAAQpL,MAAMta,KAAMgP,WAEvC,MADA0W,EAAQI,OAAQ,EACVJ,I,kCC3BR,IAAIjjB,EAAqB,EAAQ,QAE7BkE,EAA4B,EAAQ,QAEpC8C,EAAa,EAAQ,QAErBnF,EAAe,EAAQ,QAEvB2hB,EAAa,CACftjB,KAAM,aACN9C,SAIF,SAA4BC,EAAS8C,EAAIC,GACvC,IAOI0D,EAPAxG,EAAOC,KACPkmB,EAAwB,CAC1BrmB,SA+GF,SAA8BC,EAAS8C,EAAIC,GACzC,IAAIjB,EAAO,EACX,OAAO0C,EAAaxE,GAEpB,SAA8BQ,GAG5B,OAFAR,EAAQU,MAAM,mBACdV,EAAQU,MAAM,2BACPyC,EAAgB3C,KAL0B,aAAcN,KAAKE,OAAOD,WAAWyI,QAAQC,KAAKC,QAAQ,iBAAmB,OAAI1H,EAAY,GAQhJ,SAAS+B,EAAgB3C,GACvB,OAAIA,IAASiG,GACXzG,EAAQW,QAAQH,GAChBsB,IACOqB,GAGLrB,EAAOkB,EAAiBD,EAAIvC,IAChCR,EAAQa,KAAK,2BACN2D,EAAaxE,EAASud,EAAoB,aAA1C/Y,CAAwDhE,IAGjE,SAAS+c,EAAmB/c,GAC1B,OAAa,OAATA,GAAiBmC,EAAmBnC,IACtCR,EAAQa,KAAK,mBACNiC,EAAGtC,IAGLuC,EAAIvC,KA1IbwK,SAAS,GAEPqb,EAAgB1c,EAAWzJ,KAAKoB,OAAQ,cACxC0B,EAAW,EAEf,OAEA,SAAexC,GAKb,OAJAR,EAAQU,MAAM,cACdV,EAAQU,MAAM,mBACdV,EAAQU,MAAM,2BACd+F,EAASjG,EACF8lB,EAAa9lB,IAGtB,SAAS8lB,EAAa9lB,GACpB,OAAIA,IAASiG,GACXzG,EAAQW,QAAQH,GAChBwC,IACOsjB,IAGTtmB,EAAQa,KAAK,2BACNmC,EAAW,EAAID,EAAIvC,GAAQgE,EAAaxE,EAASumB,EAAU,aAAhC/hB,CAA8ChE,IAGlF,SAAS+lB,EAAS/lB,GAChB,OAAa,OAATA,GAAiBmC,EAAmBnC,GAC/BgmB,EAAUhmB,IAGnBR,EAAQU,MAAM,uBACdV,EAAQU,MAAM,cAAe,CAC3BkE,YAAa,WAERmH,EAAKvL,IAGd,SAASuL,EAAKvL,GACZ,OAAa,OAATA,GAAiBqG,EAA0BrG,IAC7CR,EAAQa,KAAK,eACbb,EAAQa,KAAK,uBACN2D,EAAaxE,EAASymB,EAAW,aAAjCjiB,CAA+ChE,IAG3C,KAATA,GAAeA,IAASiG,EAAe1D,EAAIvC,IAC/CR,EAAQW,QAAQH,GACTuL,GAGT,SAAS0a,EAAUjmB,GACjB,OAAa,OAATA,GAAiBmC,EAAmBnC,GAC/BgmB,EAAUhmB,IAGnBR,EAAQU,MAAM,uBACdV,EAAQU,MAAM,cAAe,CAC3BkE,YAAa,WAER8hB,EAAKlmB,IAGd,SAASkmB,EAAKlmB,GACZ,OAAa,OAATA,GAAiBmC,EAAmBnC,IACtCR,EAAQa,KAAK,eACbb,EAAQa,KAAK,uBACN2lB,EAAUhmB,IAGN,KAATA,GAAeA,IAASiG,EAAe1D,EAAIvC,IAC/CR,EAAQW,QAAQH,GACTkmB,GAGT,SAASF,EAAUhmB,GAEjB,OADAR,EAAQa,KAAK,mBACNZ,EAAKmK,UAAYtH,EAAGtC,GAAQmD,EAAQnD,GAG7C,SAASmD,EAAQnD,GACf,OAAa,OAATA,EACK6S,EAAM7S,GAGXmC,EAAmBnC,IACrBR,EAAQU,MAAM,cACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,cACNb,EAAQK,QAAQ+lB,EAAuB/S,EAAOgT,EAAgB7hB,EAAaxE,EAAS2D,EAAS,aAAc0iB,EAAgB,GAAK1iB,KAGzI3D,EAAQU,MAAM,iBACPimB,EAAgBnmB,IAGzB,SAASmmB,EAAgBnmB,GACvB,OAAa,OAATA,GAAiBmC,EAAmBnC,IACtCR,EAAQa,KAAK,iBACN8C,EAAQnD,KAGjBR,EAAQW,QAAQH,GACTmmB,GAGT,SAAStT,EAAM7S,GAEb,OADAR,EAAQa,KAAK,cACNiC,EAAGtC,KAlHZ4e,UAAU,GAsJZ3c,EAAOxD,QAAUknB,G,kCC7JjB1jB,EAAOxD,QAJP,SAAmCuB,GACjC,OAAOA,EAAO,GAAc,KAATA,I,oCCDrB,IAEIyI,EAFa,EAAQ,OAELsK,CAAW,cAC/B9Q,EAAOxD,QAAUgK,G,kCCFjBxG,EAAOxD,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,mBCFtiB,IAAI2nB,EAAY,CAAC,OAAQ,QAAS,SAAU,OAC5CnkB,EAAOxD,QAMP,SAAwB4nB,GACtB,IAAIhhB,GAAOghB,GAAO,IAAIpG,OAClBqG,EAAQjhB,EAAIkR,OAAO,GAEvB,GAAc,MAAV+P,GAA2B,MAAVA,EACnB,OAAOjhB,EAGT,IAAIkhB,EAAQlhB,EAAIiD,QAAQ,KAExB,IAAe,IAAXie,EACF,OAAOlhB,EAGT,IAAI9E,GAAS,EAEb,OAASA,EAAQ6lB,EAAU5lB,QAAQ,CACjC,IAAIgmB,EAAWJ,EAAU7lB,GAEzB,GAAIgmB,IAAUC,EAAShmB,QAAU6E,EAAIP,MAAM,EAAG0hB,EAAShmB,QAAQ8X,gBAAkBkO,EAC/E,OAAOnhB,EAMX,IAAe,KAFf9E,EAAQ8E,EAAIiD,QAAQ,OAEAie,EAAQhmB,EAC1B,OAAO8E,EAKT,IAAe,KAFf9E,EAAQ8E,EAAIiD,QAAQ,OAEAie,EAAQhmB,EAC1B,OAAO8E,EAIT,MAAO,uB,kCC1CT,IAAIohB,EAAQ,EAAQ,QAEhB5iB,EAAS,EAAQ,QAEjB6iB,EAA2B,EAAQ,QAEnChL,EAAU+K,EAAM/K,QAChBE,EAAoB6K,EAAM7K,kBAC1BD,EAAa8K,EAAM9K,WACnBE,EAAS4K,EAAM5K,OACfC,EAAiB2K,EAAM3K,eACvBrE,EAAiBgP,EAAMhP,eAC3BxV,EAAOxD,QAAUoF,EAAO,CACtBgS,MAAO,OACP2D,WAAY,CACVmN,cAAe,iBACfC,UAAW,QACXC,QAAS,MACTC,UAAW,cAEbrN,UAAWiN,EACXnN,gBAAiB,CAAC,UAAW,WAAY,QAAS,YAClD3D,WAAY,CAEVmR,KAAM,KACNC,OAAQvP,EACRwP,cAAenL,EACfoL,UAAWpL,EACXqL,OAAQ,KACRC,MAAO,KACPC,gBAAiB3L,EACjB4L,oBAAqB5L,EACrB6L,eAAgB7L,EAChBpW,IAAK,KACLkiB,GAAI,KACJC,MAAO/L,EACPgM,eAAgB,KAChBC,aAAc7L,EACd8L,UAAWlM,EACXmM,SAAUnM,EACVoM,QAASpM,EACTqM,QAAS,KACTrR,QAASgF,EACTsM,KAAM,KACN7W,UAAW2K,EACXmM,KAAMpM,EACNqM,QAAS,KACT/kB,QAAS,KACTglB,gBAAiBxM,EACjByM,SAAU1M,EACV2M,aAAcvM,EACdwM,OAAQzM,EAASpE,EACjB8Q,YAAa,KACbnoB,KAAM,KACNooB,SAAU,KACVC,SAAU,KACV7f,QAAS8S,EACTgN,MAAOhN,EACPiN,IAAK,KACLC,QAAS,KACTC,SAAUnN,EACVoN,SAAUlN,EACVmN,UAAWpN,EACXqN,QAAS,KACTC,aAAc,KACdC,KAAM,KACNC,WAAY,KACZC,YAAa,KACbC,WAAY,KACZC,eAAgB5N,EAChB6N,WAAY,KACZC,QAAS1N,EACT2N,OAAQ5N,EACR6N,OAAQhO,EACRiO,KAAM9N,EACN1F,KAAM,KACNyT,SAAU,KACVC,QAAS/N,EACTgO,UAAWhO,EACXnM,GAAI,KACJoa,WAAY,KACZC,YAAavS,EACbwS,UAAW,KACXC,UAAW,KACXC,GAAI,KACJC,MAAO1O,EACP2O,OAAQ,KACRC,SAAUxO,EACVyO,QAASzO,EACT0O,UAAW9O,EACX+O,SAAU3O,EACVvS,KAAM,KACNwK,MAAO,KACP2W,KAAM,KACNC,SAAU,KACVrqB,KAAM,KACNsqB,QAAS,KACTC,KAAMnP,EACNoP,IAAKjP,EACLkP,SAAU,KACVhiB,IAAK,KACLiiB,UAAWnP,EACX8H,MAAO,KACPsH,OAAQ,KACRC,IAAK,KACLC,UAAWtP,EACXuP,SAAU1P,EACV2P,MAAO3P,EACPrZ,KAAM,KACNipB,MAAO,KACPC,SAAU7P,EACV8P,WAAY9P,EACZ+P,QAAS,KACTC,aAAc,KACdC,WAAY,KACZC,cAAe,KACfC,eAAgB,KAChBC,OAAQ,KACRC,SAAU,KACVC,UAAW,KACXC,iBAAkB,KAClBC,SAAU,KACVC,QAAS,KACTC,QAAS,KACTC,cAAe,KACfC,OAAQ,KACRC,YAAa,KACbC,MAAO,KACPC,WAAY,KACZC,OAAQ,KACRC,UAAW,KACXC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,OAAQ,KACRC,iBAAkB,KAClBC,UAAW,KACXC,QAAS,KACTC,QAAS,KACTC,QAAS,KACTC,WAAY,KACZC,aAAc,KACdC,QAAS,KACTC,UAAW,KACXC,UAAW,KACXC,WAAY,KACZC,QAAS,KACTC,iBAAkB,KAClBC,OAAQ,KACRC,aAAc,KACdC,iBAAkB,KAClBC,UAAW,KACXC,YAAa,KACbC,UAAW,KACXC,eAAgB,KAChBC,YAAa,KACbC,aAAc,KACdC,aAAc,KACdC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,UAAW,KACXC,UAAW,KACXC,SAAU,KACVC,WAAY,KACZC,WAAY,KACZC,QAAS,KACTC,QAAS,KACTC,OAAQ,KACRC,UAAW,KACXC,WAAY,KACZC,WAAY,KACZC,aAAc,KACdC,mBAAoB,KACpBC,QAAS,KACTC,SAAU,KACVC,SAAU,KACVC,0BAA2B,KAC3BC,SAAU,KACVC,UAAW,KACXC,SAAU,KACVC,aAAc,KACdC,UAAW,KACXC,UAAW,KACXC,SAAU,KACVC,UAAW,KACXC,aAAc,KACdC,SAAU,KACVC,qBAAsB,KACtBC,SAAU,KACVC,eAAgB,KAChBC,UAAW,KACXC,QAAS,KACTlqB,KAAMiV,EACNkV,QAAS/U,EACTgV,QAAS,KACTC,KAAMhV,EACNiV,YAAa,KACbC,YAAatV,EACbuV,OAAQ,KACRC,QAAS,KACTC,SAAUzV,EACV0V,eAAgB,KAChBC,IAAKvV,EACLwV,SAAU5V,EACV6V,SAAU7V,EACVsD,KAAMnD,EACN2V,QAAS3V,EACT4V,QAAS3V,EACT4V,MAAO,KACPC,OAAQjW,EACRkW,SAAUlW,EACVmW,SAAUnW,EACVoW,MAAO,KACPxwB,KAAMua,EACNkW,MAAO,KACPC,KAAM,KACNC,KAAMpW,EACNqW,WAAYvW,EACZvW,IAAK,KACL+sB,OAAQ,KACRC,QAAS,KACTC,OAAQ5a,EACR3X,MAAO+b,EACPyW,KAAM,KACNpd,MAAO,KACPqd,SAAU1W,EACV7N,OAAQ,KACRzI,MAAO,KACPitB,UAAW,KACXxxB,KAAM,KACNyxB,cAAe/W,EACfgX,OAAQ,KACR7zB,MAAO8c,EACPgX,MAAO9W,EACPI,KAAM,KAGNlF,MAAO,KAEP6b,MAAO,KAEPC,QAAS/W,EAETgX,KAAM,KAENC,WAAY,KAEZC,QAAS,KAETC,OAAQpX,EAERqX,YAAa,KAEbC,aAActX,EAEduX,YAAa,KAEbC,YAAa,KAEbC,KAAM,KAENC,QAAS,KAETC,QAAS,KAETC,MAAO,KAEPzzB,KAAM,KAEN0zB,SAAU,KAEVC,SAAU,KAEVC,MAAO,KAEPC,QAASnY,EAEToY,QAASpY,EAET6G,MAAO,KAEPwR,KAAM,KAENC,MAAO,KAEPC,YAAa,KAEbC,OAAQrY,EAERsY,WAAYtY,EAEZuY,KAAM,KAENC,SAAU,KAEVC,OAAQ,KAERC,aAAc1Y,EAEd2Y,YAAa3Y,EAEb4Y,SAAU/Y,EAEVgZ,OAAQhZ,EAERiZ,QAASjZ,EAETkZ,OAAQlZ,EAER3J,OAAQ,KAER8iB,QAAS,KAETC,OAAQ,KAERC,IAAK,KAELC,YAAanZ,EAEbsF,MAAO,KAEP8T,OAAQ,KAERC,UAAWvZ,EAEXwZ,QAAS,KAETC,QAAS,KAETp2B,KAAM,KAENq2B,UAAWxZ,EAEXyZ,UAAW,KAEXC,QAAS,KAETC,OAAQ,KAERC,MAAO,KAEPC,OAAQ7Z,EAGR8Z,kBAAmB,KACnBC,YAAa,KACbC,SAAU,KACVC,wBAAyBpa,EACzBqa,sBAAuBra,EACvBsa,OAAQ,KACRtgB,SAAU,KACVugB,QAASpa,EACTqa,SAAU,KACVC,aAAc,S,kCCpWlBx3B,OAAOC,eAAeH,EAAS,aAAc,CAC3CI,OAAO,IAGT,IAAIu3B,EAAS,EAAQ,QAEjBC,EAAY,EAAQ,QAEpBjiB,EAAW,EAAQ,QAEnBkiB,EAAa,EAAQ,QAErBC,EAAkB,EAAQ,QAE1BztB,EAAqB,EAAQ,QAE7B6c,EAAa,EAAQ,QAErB7C,EAAe,EAAQ,QAEvB1gB,EAAW,EAAQ,QAEnBkX,EAAa,EAAQ,QAErBkd,EAAkB,EAAQ,QAE1Bxd,EAAa,EAAQ,QAErBmE,EAAW,EAAQ,QAEnB7W,EAAW,EAAQ,QAEnB0c,EAAW,EAAQ,QAEnBpQ,EAAkB,EAAQ,QAE1B+J,EAAiB,EAAQ,QAEzB8Z,EAAa,EAAQ,QAErBn2B,EAAO,EAAQ,QAEfuc,EAAkB,EAAQ,QAE1B7W,EAAgB,EAAQ,QAExB5C,EAAW,CACbszB,GAAIp2B,EAEJq2B,GAAIr2B,EAEJs2B,GAAIt2B,EAEJu2B,GAAIv2B,EAEJw2B,GAAIx2B,EAEJy2B,GAAIz2B,EAEJ02B,GAAI12B,EAEJ22B,GAAI32B,EAEJ42B,GAAI52B,EAEJ62B,GAAI72B,EAEJ82B,GAAI92B,EAEJ+2B,GAAI/2B,EAEJg3B,GAAIh3B,EAEJi3B,GAAIjB,GAGFpyB,EAAiB,CACnBszB,GAAIle,GAGF6F,EAAc,CAChB,KAAM2D,EAEN,KAAMA,EAEN2U,GAAI3U,GAGFzf,EAAO,CACTq0B,GAAI1e,EAEJ0d,GAAI1wB,EAEJ4wB,GAAI,CAAC/Z,EAAiB7W,GAEtB2xB,GAAIxa,EAEJya,GAAI/a,EAEJgb,GAAI7xB,EAEJ8xB,GAAInS,EAEJoS,IAAKpS,GAGHzmB,EAAS,CACX84B,GAAIlvB,EAEJmvB,GAAI1B,GAGFv3B,EAAO,CACT,KAAMy3B,EAEN,KAAMA,EAEN,KAAMA,EAENyB,GAAItlB,EAEJolB,GAAIlvB,EAEJ4tB,GAAIL,EAEJsB,GAAI,CAACvjB,EAAU9N,GAEfkxB,GAAI7a,EAEJsb,GAAI,CAACzB,EAAiBD,GAEtB4B,GAAInV,EAEJ6U,GAAIxB,EAEJyB,GAAI11B,GAGFwhB,EAAa,CACfvb,KAAM,CAACguB,EAAWD,EAAOj3B,WAK3BV,EAAQyF,eAAiBA,EACzBzF,EAAQ2J,QAJM,CACZC,KAAM,IAIR5J,EAAQ2E,SAAWA,EACnB3E,EAAQ4E,KAAOA,EACf5E,EAAQ0gB,YAAcA,EACtB1gB,EAAQmlB,WAAaA,EACrBnlB,EAAQS,OAASA,EACjBT,EAAQO,KAAOA,G,kCCvJfiD,EAAOxD,QAIP,SAA2BwG,EAAGC,GAC5B,IAAI+N,EAAgBhO,EAAEgO,cAClBC,EAAaC,OAAOjO,EAAKgO,aAEc,IAAvCD,EAAc3K,QAAQ4K,IACxBD,EAAclO,KAAKmO,GAGrB,OAAOjO,EAAEC,EAAKjC,SAAU,MAAO,CAC7B0M,GAAI,SAAWuD,GACd,CAACjO,EAAEC,EAAM,IAAK,CACfiR,KAAM,OAASjD,EACf/B,UAAW,CAAC,iBACX,CAAC6C,EAAE,OAAQ9O,EAAK6O,OAASb,QAf9B,IAAIc,EAAI,EAAQ,S,kCCFhB,IAAIlV,EAAS,EAAQ,QAMrBmD,EAAOxD,QAJP,SAAiBsT,GACf,OAAOjT,EAAO,GAAIiT,K,kCCHpB,IAAIhP,EAAM,GAAGC,eACbf,EAAOxD,QAAUsE,G,kCCDjBtE,EAAQsQ,MAMR,SAAelQ,GACb,IAAI2X,EAAQrD,OAAOtU,GALT,IAKyBohB,OACnC,MANU,KAMHzJ,EAAkB,GAAKA,EAAM4hB,MAAMC,IAP5C55B,EAAQiZ,UAUR,SAAmB7R,GACjB,OAAOA,EAAOqQ,KATJ,KASgB+J,QAV5B,IAEIoY,EAAa,iB,kCCJjBp2B,EAAOxD,QAIP,SAAmBwG,EAAGC,GACpB,OAAOD,EAAEC,EAAM,IAAK+O,EAAIhP,EAAGC,KAH7B,IAAI+O,EAAM,EAAQ,S,kCCFlBhS,EAAOxD,QAIP,SAAmBwG,EAAGC,GACpB,MAAO,CAACD,EAAEC,EAAM,MAAO8O,EAAE,OAAQ,QAHnC,IAAIA,EAAI,EAAQ,S,mBCJhB/R,EAAOxD,QAGP,WAGE,IAFA,IAAIuP,EAAS,GAEJW,EAAI,EAAGA,EAAID,UAAUlO,OAAQmO,IAAK,CACzC,IAAIoB,EAASrB,UAAUC,GAEvB,IAAK,IAAIhB,KAAOoC,EACV/M,EAAetC,KAAKqP,EAAQpC,KAC9BK,EAAOL,GAAOoC,EAAOpC,IAK3B,OAAOK,GAfT,IAAIhL,EAAiBrE,OAAOuO,UAAUlK,gB,kCCCtCf,EAAOxD,QAMP,SAAckH,EAAO2yB,GACnB,IAAI7yB,EAAS,GACTlF,GAAS,EACTC,EAASmF,EAAMnF,OAEf83B,GACF7yB,EAAOV,KAAKiP,EAAE,OAAQ,OAGxB,OAASzT,EAAQC,GACXD,GACFkF,EAAOV,KAAKiP,EAAE,OAAQ,OAGxBvO,EAAOV,KAAKY,EAAMpF,IAGhB+3B,GAAS3yB,EAAMnF,OAAS,GAC1BiF,EAAOV,KAAKiP,EAAE,OAAQ,OAGxB,OAAOvO,GAzBT,IAAIuO,EAAI,EAAQ,S,kCCFhB,IAAIukB,EAAmB,EAAQ,QAE3BhC,EAAkB,CACpBl0B,KAAM,kBACN9C,SAGF,SAAiCC,EAAS8C,EAAIC,GAC5C,OAEA,SAAevC,GAKb,OAJAR,EAAQU,MAAM,mBACdV,EAAQU,MAAM,gBACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,gBACNoG,GAGT,SAASA,EAAKzG,GACZ,OAAIu4B,EAAiBv4B,IACnBR,EAAQU,MAAM,wBACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,wBACbb,EAAQa,KAAK,mBACNiC,GAGFC,EAAIvC,MAIfiC,EAAOxD,QAAU83B,G,kCC/BjBt0B,EAAOxD,QAAUkc,EACjB,IAAI6d,EAAQ7d,EAAKzN,UAcjB,SAASyN,EAAKjF,EAAUsC,GACtBtY,KAAKgW,SAAWA,EAChBhW,KAAKsY,UAAYA,EAfnBwgB,EAAM3iB,MAAQ,KACd2iB,EAAMxgB,UAAY,KAClBwgB,EAAM9iB,SAAW,KACjB8iB,EAAM9c,SAAU,EAChB8c,EAAM7c,YAAa,EACnB6c,EAAM5c,mBAAoB,EAC1B4c,EAAM3c,QAAS,EACf2c,EAAM/gB,gBAAiB,EACvB+gB,EAAM1c,gBAAiB,EACvB0c,EAAMzc,uBAAwB,EAC9Byc,EAAMjf,iBAAkB,EACxBif,EAAM90B,SAAU,G,kCCbhBzB,EAAOxD,QAQP,SAAuBwG,EAAGC,GACxB,IACIC,EADA6f,EAAM/f,EAAEqU,WAAWpU,EAAKgO,YAG5B,IAAK8R,EACH,OAAOC,EAAOhgB,EAAGC,GAGnBC,EAAQ,CACNgR,KAAMnR,EAAUggB,EAAI3f,KAAO,KAGX,OAAd2f,EAAIzf,YAAgC3E,IAAdokB,EAAIzf,QAC5BJ,EAAMI,MAAQyf,EAAIzf,OAGpB,OAAON,EAAEC,EAAM,IAAKC,EAAO8O,EAAIhP,EAAGC,KAtBpC,IAAIF,EAAY,EAAQ,QAEpBigB,EAAS,EAAQ,QAEjBhR,EAAM,EAAQ,S,kCCNlB,IAAI9R,EAAqB,EAAQ,QAE7B6B,EAAe,EAAQ,QAEvBqF,EAAmB,CACrB9J,SAIF,SAAkCC,EAAS8C,EAAIC,GAC7C,OAAOyB,EAAaxE,GAEpB,SAAyBQ,GACvB,OAAgB,OAATA,GAAiBmC,EAAmBnC,GAAQsC,EAAGtC,GAAQuC,EAAIvC,KAHtB,eAJ9CwK,SAAS,GAWXvI,EAAOxD,QAAU4K,G,kCCjBjBpH,EAAOxD,QAEP,SAAmByG,GACjB,QAAQA,GAASA,EAAKjC,UAAaiC,EAAKjC,SAASnD,OAAUoF,EAAKjC,SAASnD,MAAM8B,MAASsD,EAAKjC,SAASnD,MAAM+B,QAAWqD,EAAKjC,SAAShC,KAAQiE,EAAKjC,SAAShC,IAAIW,MAASsD,EAAKjC,SAAShC,IAAIY,U,oCCH5L,IAAIX,EAAS,EAAQ,QAkCrBe,EAAOxD,QA/BP,SAAuB6B,EAAMR,EAAO0a,EAAQ0B,GAC1C,IAEIxB,EAFAzZ,EAAMX,EAAKE,OACXi4B,EAAa,EAWjB,GAPE34B,EADEA,EAAQ,GACDA,EAAQmB,EAAM,EAAIA,EAAMnB,EAEzBA,EAAQmB,EAAMA,EAAMnB,EAG9B0a,EAASA,EAAS,EAAIA,EAAS,EAE3B0B,EAAM1b,OAAS,KACjBka,EAAa5N,MAAM/I,KAAKmY,IACbhI,QAAQpU,EAAO0a,GAC1BtZ,EAAO8Y,MAAM1Z,EAAMoa,QAKnB,IAFIF,GAAQtZ,EAAO8Y,MAAM1Z,EAAM,CAACR,EAAO0a,IAEhCie,EAAavc,EAAM1b,SACxBka,EAAawB,EAAMpX,MAAM2zB,EAAYA,EAAa,MACvCvkB,QAAQpU,EAAO,GAC1BoB,EAAO8Y,MAAM1Z,EAAMoa,GACnB+d,GAAc,IACd34B,GAAS,M,kCC5Bf,IAAI44B,EAGJz2B,EAAOxD,QAEP,SAAsBk6B,GACpB,IACIrF,EADAsF,EAAS,IAAMD,EAAa,IAUhC,IARAD,EAAKA,GAAMt1B,SAAS2N,cAAc,MAC/B8nB,UAAYD,EARD,MASdtF,EAAOoF,EAAGI,aAMDn3B,WAAW2xB,EAAK9yB,OAAS,IAAmC,SAAfm4B,EACpD,OAAO,EAIT,OAAOrF,IAASsF,GAAiBtF,I,kCCtBnCrxB,EAAOxD,QAMP,SAAcwG,EAAGC,GACf,IAEIgX,EAEA1b,EAJA2E,EAAQ,GACR9C,EAAO6C,EAAK2R,QAAU,KAAO,KAE7BtW,GAAS,EAGa,iBAAf2E,EAAKpF,OAAqC,IAAfoF,EAAKpF,QACzCqF,EAAMrF,MAAQoF,EAAKpF,OAGrBoc,EAAQjI,EAAIhP,EAAGC,GACf1E,EAAS0b,EAAM1b,OAEf,OAASD,EAAQC,GACf,GAAI0b,EAAM3b,GAAOqV,WAAWzE,YAA8E,IAAjE+K,EAAM3b,GAAOqV,WAAWzE,UAAU7I,QAAQ,kBAA0B,CAC3GnD,EAAMgM,UAAY,CAAC,sBACnB,MAIJ,OAAOlM,EAAEC,EAAM7C,EAAM8C,EAAO8W,EAAKC,GAAO,KAzB1C,IAAID,EAAO,EAAQ,QAEfhI,EAAM,EAAQ,S,kCCAlB,SAAS7G,EAASlI,GAChB,OAAOA,IAASA,EAAKrG,OAASqG,EAAKI,KAAOJ,EAAKK,OAAS,aAAcL,GAAQ+O,EAAI/O,EAAKU,WAAa,WAAYV,GAAQ+O,EAAI/O,KAAU,GAGxI,SAAS+O,EAAIpO,GAIX,IAHA,IAAIJ,EAAS,GACTlF,GAAS,IAEJA,EAAQsF,EAAOrF,QACtBiF,EAAOlF,GAAS6M,EAASvH,EAAOtF,IAGlC,OAAOkF,EAAOyQ,KAAK,IAhBrBjU,EAAOxD,QAAU2O,G,oCCQjB,IAAI2rB,EAAI,MACJ3X,EAAI,MACJjK,EAAI,MACJxO,EAAI,MACJqwB,EAAI,MACJC,EAAI,MACJh0B,EAAI,MACJ2S,EAAI,MACJshB,EAAI,MACJlY,EAAI,MACJmY,EAAI,MACJC,EAAI,MACJC,EAAI,MACJC,EAAI,MACJtlB,EAAI,MACJ2D,EAAI,MACJ4hB,EAAI,MAER,GAAI,mBAAsBC,QAAUA,OAAOC,IAAK,CAC9C,IAAIC,EAAIF,OAAOC,IACfV,EAAIW,EAAE,iBACNtY,EAAIsY,EAAE,gBACNviB,EAAIuiB,EAAE,kBACN/wB,EAAI+wB,EAAE,qBACNV,EAAIU,EAAE,kBACNT,EAAIS,EAAE,kBACNz0B,EAAIy0B,EAAE,iBACN9hB,EAAI8hB,EAAE,qBACNR,EAAIQ,EAAE,kBACN1Y,EAAI0Y,EAAE,uBACNP,EAAIO,EAAE,cACNN,EAAIM,EAAE,cACNL,EAAIK,EAAE,eACNJ,EAAII,EAAE,sBACN1lB,EAAI0lB,EAAE,qBACN/hB,EAAI+hB,EAAE,0BACNH,EAAIG,EAAE,uBAGR,SAASC,EAAEC,GACT,GAAI,iBAAoBA,GAAK,OAASA,EAAG,CACvC,IAAIC,EAAID,EAAEE,SAEV,OAAQD,GACN,KAAKd,EACH,OAAQa,EAAIA,EAAE54B,MACZ,KAAKmW,EACL,KAAK6hB,EACL,KAAKrwB,EACL,KAAKuwB,EACL,KAAKlY,EACH,OAAO4Y,EAET,QACE,OAAQA,EAAIA,GAAKA,EAAEE,UACjB,KAAK70B,EACL,KAAK2S,EACL,KAAKwhB,EACL,KAAKD,EACL,KAAKF,EACH,OAAOW,EAET,QACE,OAAOC,GAKjB,KAAKzY,EACH,OAAOyY,IAKf,IAAIE,EAAId,EACJe,EAAIjB,EACJkB,EAAIriB,EACJsiB,EAAI/iB,EACJgjB,EAAIf,EACJgB,EAAIjB,EACJkB,EAAIjZ,EACJkZ,EAAItB,EACJuB,EAAI5xB,EACJ6xB,EAAItB,EACRz6B,EAAQg8B,gBAAkBx1B,EAC1BxG,EAAQi8B,gBAAkBX,EAC1Bt7B,EAAQk8B,QAAUX,EAClBv7B,EAAQm8B,WAAaX,EACrBx7B,EAAQuS,SAAWkpB,EACnBz7B,EAAQo8B,KAAOV,EACf17B,EAAQq8B,KAAOV,EACf37B,EAAQs8B,OAASV,EACjB57B,EAAQu8B,SAAWV,EACnB77B,EAAQw8B,WAAaV,EACrB97B,EAAQy8B,SAAWV,EAEnB/7B,EAAQ08B,YAAc,WACpB,OAAO,GAGT18B,EAAQ28B,iBAAmB,WACzB,OAAO,GAGT38B,EAAQ48B,kBAAoB,SAAUzB,GACpC,OAAOD,EAAEC,KAAO30B,GAGlBxG,EAAQ68B,kBAAoB,SAAU1B,GACpC,OAAOD,EAAEC,KAAOX,GAGlBx6B,EAAQ88B,UAAY,SAAU3B,GAC5B,MAAO,iBAAoBA,GAAK,OAASA,GAAKA,EAAEE,WAAaf,GAG/Dt6B,EAAQ+8B,aAAe,SAAU5B,GAC/B,OAAOD,EAAEC,KAAOhiB,GAGlBnZ,EAAQg9B,WAAa,SAAU7B,GAC7B,OAAOD,EAAEC,KAAOziB,GAGlB1Y,EAAQi9B,OAAS,SAAU9B,GACzB,OAAOD,EAAEC,KAAOR,GAGlB36B,EAAQk9B,OAAS,SAAU/B,GACzB,OAAOD,EAAEC,KAAOT,GAGlB16B,EAAQm9B,SAAW,SAAUhC,GAC3B,OAAOD,EAAEC,KAAOxY,GAGlB3iB,EAAQo9B,WAAa,SAAUjC,GAC7B,OAAOD,EAAEC,KAAOZ,GAGlBv6B,EAAQq9B,aAAe,SAAUlC,GAC/B,OAAOD,EAAEC,KAAOjxB,GAGlBlK,EAAQs9B,WAAa,SAAUnC,GAC7B,OAAOD,EAAEC,KAAOV,GAGlBz6B,EAAQwX,mBAAqB,SAAU2jB,GACrC,MAAO,iBAAoBA,GAAK,mBAAsBA,GAAKA,IAAMziB,GAAKyiB,IAAMZ,GAAKY,IAAMjiB,GAAKiiB,IAAMjxB,GAAKixB,IAAMV,GAAKU,IAAM5Y,GAAK4Y,IAAML,GAAK,iBAAoBK,GAAK,OAASA,IAAMA,EAAEE,WAAaV,GAAKQ,EAAEE,WAAaX,GAAKS,EAAEE,WAAab,GAAKW,EAAEE,WAAa70B,GAAK20B,EAAEE,WAAaliB,GAAKgiB,EAAEE,WAAa9lB,GAAK4lB,EAAEE,WAAaT,GAAKO,EAAE,KAAON,IAGvU76B,EAAQu9B,OAASrC,G,kCChKjB13B,EAAOxD,QAAU,SAAUI,GACzB,GAA8C,oBAA1CF,OAAOuO,UAAUE,SAAS1M,KAAK7B,GACjC,OAAO,EAGT,IAAIqO,EAAYvO,OAAOs9B,eAAep9B,GACtC,OAAqB,OAAdqO,GAAsBA,IAAcvO,OAAOuO,Y,kCCNpDvO,OAAOC,eAAeH,EAAS,aAAc,CAC3CI,OAAO,IAGT,IAAIsD,EAAqB,EAAQ,QAE7B6B,EAAe,EAAQ,QAEvBqF,EAAmB,EAAQ,QAE3B9J,EAQJ,SAA4BC,GAC1B,IAOI08B,EACAC,EACAC,EATA38B,EAAOC,KACPsL,EAAQ,GACRqxB,EAAY,EACZC,EAAmB,CACrB/8B,SAuGF,SAAyBC,EAAS8C,GAChC,IAAIi6B,EAAe,EAEnB,OADAL,EAAgB,GACTM,EAEP,SAASA,EAAax8B,GACpB,OAAIu8B,EAAevxB,EAAMxK,QACvBf,EAAK+J,eAAiBwB,EAAMuxB,GAAc,GACnC/8B,EAAQK,QAAQmL,EAAMuxB,GAAc,GAAGpyB,aAAcsyB,EAAiBC,EAAtEl9B,CAAmFQ,IAKxFm8B,EAAU7vB,kBAAoB6vB,EAAU7vB,iBAAiBsS,UAC3Dsd,EAAcS,cAAe,EACtBC,EAAY58B,KAGrBP,EAAKmK,UAAYuyB,EAAU7vB,kBAAoB6vB,EAAU7vB,iBAAiBuwB,cAC1Ep9B,EAAK+J,eAAiB,GACfhK,EAAQK,QAAQi9B,EAAoBC,EAAgBH,EAApDp9B,CAAiEQ,IAG1E,SAASy8B,EAAgBz8B,GAEvB,OADAu8B,IACO98B,EAAK+J,eAAeY,WAAa2yB,EAAe/8B,GAAQw8B,EAAax8B,GAG9E,SAAS08B,EAAY18B,GACnB,OAAIm8B,EAAU7vB,kBAAoB6vB,EAAU7vB,iBAAiBZ,MAE3DjM,EAAK+J,eAAiB,GACfhK,EAAQK,QAAQi9B,EAAoBC,EAC3Cv9B,EAAQK,QAAQm9B,EAAmBD,EAAgBv9B,EAAQkK,MAAML,EAAkB0zB,EAAgBE,IAD5Fz9B,CAC2GQ,IAI7G+8B,EAAe/8B,GAGxB,SAASi9B,EAAYj9B,GAKnB,OAHAu8B,EAAevxB,EAAMxK,OACrB07B,EAAcxwB,MAAO,EACrBwwB,EAAcS,cAAe,EACtBC,EAAY58B,GAIrB,SAAS+8B,EAAe/8B,GAEtB,OADAk8B,EAAcgB,SAAU,EACjBN,EAAY58B,GAGrB,SAAS48B,EAAY58B,GAGnB,OAFAk8B,EAAcG,UAAYE,EAC1B98B,EAAKmK,UAAYnK,EAAK+J,oBAAiB5I,EAChC0B,EAAGtC,KA/JZwK,SAAS,GAKX,OAAO1K,EAEP,SAASA,EAAME,GACb,OAAIq8B,EAAYrxB,EAAMxK,QACpBf,EAAK+J,eAAiBwB,EAAMqxB,GAAW,GAChC78B,EAAQK,QAAQmL,EAAMqxB,GAAW,GAAGlyB,aAAcgzB,EAAkBC,EAApE59B,CAAuFQ,IAGzFo9B,EAAkBp9B,GAG3B,SAASm9B,EAAiBn9B,GAExB,OADAq8B,IACOv8B,EAAME,GAGf,SAASo9B,EAAkBp9B,GAGzB,OAAIk8B,GAAiBA,EAAcS,aAC1BU,EAAUr9B,IAGnBP,EAAKmK,UAAYuyB,GAAaA,EAAU7vB,kBAAoB6vB,EAAU7vB,iBAAiBuwB,cACvFp9B,EAAK+J,eAAiB,GACfhK,EAAQK,QAAQi9B,EAAoBQ,EAAmBD,EAAvD79B,CAAkEQ,IAG3E,SAASs9B,EAAkBt9B,GAGzB,OAFAgL,EAAMjG,KAAK,CAACtF,EAAK6M,iBAAkB7M,EAAK+J,iBACxC/J,EAAK+J,oBAAiB5I,EACfw8B,EAAkBp9B,GAG3B,SAASq9B,EAAUr9B,GACjB,OAAa,OAATA,GACFu9B,EAAe,GAAG,QAClB/9B,EAAQW,QAAQH,KAIlBm8B,EAAYA,GAAa18B,EAAKG,OAAOyD,KAAK5D,EAAK0L,OAC/C3L,EAAQU,MAAM,YAAa,CACzBkE,YAAa,OACb3D,SAAU27B,EACVpa,WAAYma,IAEPQ,EAAa38B,IAGtB,SAAS28B,EAAa38B,GACpB,OAAa,OAATA,GACFw9B,EAAah+B,EAAQa,KAAK,cACnBg9B,EAAUr9B,IAGfmC,EAAmBnC,IACrBR,EAAQW,QAAQH,GAChBw9B,EAAah+B,EAAQa,KAAK,cACnBb,EAAQkK,MAAM4yB,EAAkBmB,KAGzCj+B,EAAQW,QAAQH,GACT28B,GAGT,SAASc,EAAkBz9B,GAGzB,OAFAu9B,EAAerB,EAAcG,UAAWH,GAAiBA,EAAcgB,SACvEb,EAAY,EACLv8B,EAAME,GAGf,SAASw9B,EAAah8B,GAChB46B,IAAYA,EAAW/3B,KAAO7C,GAClC46B,EAAa56B,EACb26B,EAAUzwB,KAAOwwB,GAAiBA,EAAcxwB,KAChDywB,EAAUxwB,WAAWnK,EAAM1B,OAC3Bq8B,EAAUvwB,MAAMnM,EAAKiC,YAAYF,IAGnC,SAAS+7B,EAAej8B,EAAML,GAC5B,IAAIV,EAAQyK,EAAMxK,OAQlB,IANI27B,GAAal7B,IACfk7B,EAAUvwB,MAAM,CAAC,OACjBwwB,EAAaD,OAAYv7B,GAIpBL,KAAUe,GACf7B,EAAK+J,eAAiBwB,EAAMzK,GAAO,GACnCyK,EAAMzK,GAAO,GAAGF,KAAKK,KAAKjB,EAAMD,GAGlCwL,EAAMxK,OAASc,IAhHfw7B,EAAqB,CACvBv9B,SAgLF,SAA2BC,EAAS8C,EAAIC,GACtC,OAAOyB,EAAaxE,EAASA,EAAQK,QAAQH,KAAKE,OAAOD,WAAWyD,SAAUd,EAAIC,GAAM,aAAc7C,KAAKE,OAAOD,WAAWyI,QAAQC,KAAKC,QAAQ,iBAAmB,OAAI1H,EAAY,KA/KnLo8B,EAAoB,CACtBz9B,SAiLF,SAA0BC,EAAS8C,EAAIC,GACrC,OAAOyB,EAAaxE,EAASA,EAAQkM,KAAKhM,KAAKE,OAAOD,WAAW0D,KAAMf,EAAIC,GAAM,aAAc7C,KAAKE,OAAOD,WAAWyI,QAAQC,KAAKC,QAAQ,iBAAmB,OAAI1H,EAAY,KAGhLnC,EAAQc,SAAWA,G,kCCpMnB,IAAIyF,EAAY,EAAQ,QAEpBiP,EAAM,EAAQ,QAElBhS,EAAOxD,QAEP,SAAcwG,EAAGC,GACf,IAAIC,EAAQ,CACVgR,KAAMnR,EAAUE,EAAKG,MAGJ,OAAfH,EAAKK,YAAiC3E,IAAfsE,EAAKK,QAC9BJ,EAAMI,MAAQL,EAAKK,OAGrB,OAAON,EAAEC,EAAM,IAAKC,EAAO8O,EAAIhP,EAAGC,M,kCCfpC,IAAIkV,EAAe,EAAQ,QAiB3BnY,EAAOxD,QAfP,SAAqBI,EAAO6+B,GAC1B,IAAI19B,EAAOsW,SAASzX,EAAO6+B,GAE3B,OACA19B,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,IAGFoa,EAAapa,K,oCCdtB,IAAI29B,EAAO,EAAQ,QAEfp3B,EAAS,EAAQ,QAEjB+H,EAAS,EAAQ,QAEjBsvB,EAAQ,EAAQ,QAEhBC,EAAS,EAAQ,QAEjBC,EAAQ,EAAQ,QAGpB77B,EAAOxD,QAoCP,SAASqQ,IACP,IAIIivB,EAJAC,EAAY,GACZC,EAAeJ,IACfK,EAAY,GACZC,GAAe,EAiBnB,OAdA5tB,EAAUnQ,KAoEV,SAAcuN,EAAK9O,GACjB,GAAmB,iBAAR8O,EAET,OAAyB,IAArBe,UAAUlO,QACZ49B,EAAe,OAAQL,GACvBG,EAAUvwB,GAAO9O,EACV0R,GAIFxN,EAAIrC,KAAKw9B,EAAWvwB,IAAQuwB,EAAUvwB,IAAQ,KAIvD,GAAIA,EAGF,OAFAywB,EAAe,OAAQL,GACvBG,EAAYvwB,EACL4C,EAIT,OAAO2tB,GAvFT3tB,EAAU8tB,OAASA,EAEnB9tB,EAAUytB,UAAYA,EACtBztB,EAAUC,IA8FV,SAAa3R,GACX,IAAIolB,EAGJ,GAFAma,EAAe,MAAOL,GAElBl/B,cACG,GAAqB,mBAAVA,EAChBy/B,EAAUtkB,MAAM,KAAMtL,eACjB,IAAqB,iBAAV7P,EAOhB,MAAM,IAAIsb,MAAM,+BAAiCtb,EAAQ,KANrD,WAAYA,EACd0/B,EAAQ1/B,GAER2/B,EAAU3/B,GAMVolB,IACFia,EAAUja,SAAW3V,EAAO4vB,EAAUja,UAAY,GAAIA,IAGxD,OAAO1T,EAEP,SAASiuB,EAAU/4B,GACjB84B,EAAQ94B,EAAOiL,SAEXjL,EAAOwe,WACTA,EAAW3V,EAAO2V,GAAY,GAAIxe,EAAOwe,WAI7C,SAAS3B,EAAIzjB,GACX,GAAqB,mBAAVA,EACTy/B,EAAUz/B,OACL,IAAqB,iBAAVA,EAOhB,MAAM,IAAIsb,MAAM,+BAAiCtb,EAAQ,KANrD,WAAYA,EACdy/B,EAAUtkB,MAAM,KAAMnb,GAEtB2/B,EAAU3/B,IAOhB,SAAS0/B,EAAQ7tB,GACf,IAAInQ,GAAS,EAEb,GAAImQ,aACG,IAAuB,iBAAZA,KAAwB,WAAYA,GAKpD,MAAM,IAAIyJ,MAAM,oCAAsCzJ,EAAU,KAJhE,OAASnQ,EAAQmQ,EAAQlQ,QACvB8hB,EAAI5R,EAAQnQ,KAOlB,SAAS+9B,EAAUG,EAAQ5/B,GACzB,IAAI6/B,EAAQ5pB,EAAK2pB,GAEbC,GACEd,EAAMc,EAAM,KAAOd,EAAM/+B,KAC3BA,EAAQyP,GAAO,EAAMowB,EAAM,GAAI7/B,IAGjC6/B,EAAM,GAAK7/B,GAEXm/B,EAAUj5B,KAAKD,EAAMpE,KAAKgO,cAhKhC6B,EAAUxB,MAiLV,SAAe4vB,GACb,IACIC,EADArZ,EAAOuY,EAAMa,GAMjB,GAJAN,IAEAQ,EAAa,QADbD,EAASruB,EAAUquB,QAGfE,EAAQF,EAAQ,SAClB,OAAO,IAAIA,EAAOzrB,OAAOoS,GAAOA,GAAMxW,QAGxC,OAAO6vB,EAAOzrB,OAAOoS,GAAOA,IA3L9BhV,EAAUmH,UAkPV,SAAmBxS,EAAMy5B,GACvB,IACII,EADAxZ,EAAOuY,EAAMa,GAOjB,GALAN,IAEAW,EAAe,YADfD,EAAWxuB,EAAUwuB,UAErBE,EAAW/5B,GAEP45B,EAAQC,EAAU,WACpB,OAAO,IAAIA,EAAS75B,EAAMqgB,GAAM2Z,UAGlC,OAAOH,EAAS75B,EAAMqgB,IA7PxBhV,EAAU4uB,IAAMA,EAChB5uB,EAAUM,QAgOV,SAAiB3L,EAAMqgB,GACrB,IAAI9f,EACA25B,EAGJ,OAFAD,EAAIj6B,EAAMqgB,GAIV,SAActL,EAAOK,GACnB8kB,GAAW,EACX35B,EAAS6U,EACTqjB,EAAK1jB,MANPolB,EAAW,UAAW,MAAOD,GACtB35B,GApOT8K,EAAU+uB,QAAUA,EACpB/uB,EAAUgvB,YA+RV,SAAqBZ,GACnB,IAAIpZ,EACA6Z,EAOJ,OANAf,IACAQ,EAAa,cAAetuB,EAAUquB,QACtCI,EAAe,cAAezuB,EAAUwuB,UAExCO,EADA/Z,EAAOuY,EAAMa,IAKb,SAAc1kB,GACZmlB,GAAW,EACXzB,EAAK1jB,MALPolB,EAAW,cAAe,UAAWD,GAC9B7Z,GAtSFhV,EAEP,SAASA,IAIP,IAHA,IAAIivB,EAAc1wB,IACdvO,GAAS,IAEJA,EAAQy9B,EAAUx9B,QACzBg/B,EAAYhvB,IAAIwJ,MAAM,KAAMgkB,EAAUz9B,IAIxC,OADAi/B,EAAYp/B,KAAKkO,GAAO,EAAM,GAAI4vB,IAC3BsB,EAUT,SAASnB,IACP,IAAIx4B,EACA45B,EAEJ,GAAI1B,EACF,OAAOxtB,EAGT,OAAS4tB,EAAcH,EAAUx9B,SAGb,KAFlBqF,EAASm4B,EAAUG,IAER,MAIO,IAAdt4B,EAAO,KACTA,EAAO,QAAKjF,GAKa,mBAF3B6+B,EAAc55B,EAAO,GAAGmU,MAAMzJ,EAAW1K,EAAOf,MAAM,MAGpDm5B,EAAaztB,IAAIivB,IAMrB,OAFA1B,GAAS,EACTI,EAAcuB,IACPnvB,EA6GT,SAASuE,EAAK2pB,GAGZ,IAFA,IAAIl+B,GAAS,IAEJA,EAAQy9B,EAAUx9B,QACzB,GAAIw9B,EAAUz9B,GAAO,KAAOk+B,EAC1B,OAAOT,EAAUz9B,GAuBvB,SAAS4+B,EAAIj6B,EAAMqgB,EAAMoa,GASvB,GARAV,EAAW/5B,GACXm5B,IAEKsB,GAAsB,mBAATpa,IAChBoa,EAAKpa,EACLA,EAAO,OAGJoa,EACH,OAAO,IAAIC,QAAQC,GAKrB,SAASA,EAASj9B,EAASk9B,GACzB7B,EAAakB,IAAIj6B,EAAM44B,EAAMvY,IAE7B,SAActL,EAAOK,EAAMiL,GACzBjL,EAAOA,GAAQpV,EAEX+U,EACF6lB,EAAO7lB,GACErX,EACTA,EAAQ0X,GAERqlB,EAAG,KAAMrlB,EAAMiL,MAbrBsa,EAAS,KAAMF,GAwDjB,SAASL,EAAQX,EAAKgB,GAKpB,GAJAtB,IACAQ,EAAa,UAAWtuB,EAAUquB,QAClCI,EAAe,UAAWzuB,EAAUwuB,WAE/BY,EACH,OAAO,IAAIC,QAAQC,GAKrB,SAASA,EAASj9B,EAASk9B,GACzB,IAAIva,EAAOuY,EAAMa,GACjBoB,EAASZ,IAAI5uB,EAAW,CACtBgV,KAAMA,IAGR,SAActL,GACRA,EACF6lB,EAAO7lB,GACErX,EACTA,EAAQ2iB,GAERoa,EAAG,KAAMpa,MAdfsa,EAAS,KAAMF,IAjUF7wB,GAAUuvB,SAC3B,IAAIv5B,EAAQ,GAAGA,MACX/B,EAAM,GAAGC,eAET+8B,EAAWlC,IAASrtB,KAExB,SAAuB4oB,EAAG5hB,GACxBA,EAAI8C,KAAO8e,EAAErqB,MAAMyI,EAAI+N,SAHkB/U,KAM3C,SAAqB4oB,EAAG5hB,EAAKnT,GAC3B+0B,EAAE+F,IAAI3nB,EAAI8C,KAAM9C,EAAI+N,MAEpB,SAActL,EAAOK,EAAMiL,GACrBtL,EACF5V,EAAK4V,IAELzC,EAAI8C,KAAOA,EACX9C,EAAI+N,KAAOA,EACXlhB,WAfsDmM,KAoB5D,SAA2B4oB,EAAG5hB,GAC5B,IAAI/R,EAAS2zB,EAAE1hB,UAAUF,EAAI8C,KAAM9C,EAAI+N,MAEnC9f,UACyB,iBAAXA,GAAuBc,EAAOd,GAC9C+R,EAAI+N,KAAK7R,SAAWjO,EAEpB+R,EAAI+N,KAAK9f,OAASA,MA0UtB,SAASq5B,EAAQjgC,EAAOwD,GACtB,MAAwB,mBAAVxD,GAAwBA,EAAMqO,YAO9C,SAAcrO,GACZ,IAAI8O,EAEJ,IAAKA,KAAO9O,EACV,OAAO,EAGT,OAAO,EAXPmhC,CAAKnhC,EAAMqO,YAAc7K,KAAQxD,EAAMqO,WAezC,SAAS2xB,EAAax8B,EAAMu8B,GAC1B,GAAsB,mBAAXA,EACT,MAAM,IAAIzkB,MAAM,WAAa9X,EAAO,sBAKxC,SAAS28B,EAAe38B,EAAM08B,GAC5B,GAAwB,mBAAbA,EACT,MAAM,IAAI5kB,MAAM,WAAa9X,EAAO,wBAKxC,SAAS+7B,EAAe/7B,EAAM07B,GAC5B,GAAIA,EACF,MAAM,IAAI5jB,MAAM,kBAAoB9X,EAAO,qHAK/C,SAAS48B,EAAW/5B,GAClB,IAAKA,GAA6B,iBAAdA,EAAKlE,KACvB,MAAM,IAAImZ,MAAM,uBAAyBjV,EAAO,KAKpD,SAASm6B,EAAWh9B,EAAM49B,EAAWb,GACnC,IAAKA,EACH,MAAM,IAAIjlB,MAAM,IAAM9X,EAAO,0BAA4B49B,EAAY,e,kCC1YzE,SAASC,IACP,OAAO,KA9BTj+B,EAAOxD,QAAU,CACf0hC,WAAY,EAAQ,QACpBC,MAAO,EAAQ,QACfpgC,KAAM,EAAQ,QACdqgC,OAAQ,EAAQ,QAChBC,SAAU,EAAQ,QAClBltB,kBAAmB,EAAQ,QAC3BmtB,SAAU,EAAQ,QAClBvjB,QAAS,EAAQ,QACjB9N,KAAM,EAAQ,QACdsxB,eAAgB,EAAQ,QACxBC,MAAO,EAAQ,QACfC,WAAY,EAAQ,QACpBC,cAAe,EAAQ,QACvBvM,KAAM,EAAQ,QACdwM,SAAU,EAAQ,QAClBtgC,KAAM,EAAQ,QACdwc,UAAW,EAAQ,QACnB+jB,KAAM,EAAQ,QACdC,OAAQ,EAAQ,QAChBC,MAAO,EAAQ,QACf/hC,KAAM,EAAQ,QACdgH,cAAe,EAAQ,QACvBg7B,KAAMd,EACNe,KAAMf,EACN5mB,WAAY4mB,EACZgB,mBAAoBhB,I,kCCxBtB,SAASiB,EAAQn4B,GACf,GAAY,MAARA,EACF,OAAO1G,EAGT,GAAoB,iBAAT0G,EACT,OAuDJ,SAAqBA,GACnB,OAEA,SAAc9D,GACZ,OAAOyR,QAAQzR,GAAQA,EAAKlE,OAASgI,IA3D9Bo4B,CAAYp4B,GAGrB,GAAoB,iBAATA,EACT,MAAO,WAAYA,EA0BvB,SAAoBq4B,GAClB,IAAIC,EAAS,GACT/gC,GAAS,EAEb,OAASA,EAAQ8gC,EAAM7gC,QACrB8gC,EAAO/gC,GAAS4gC,EAAQE,EAAM9gC,IAGhC,OAEA,WACE,IAAIA,GAAS,EAEb,OAASA,EAAQ+gC,EAAO9gC,QACtB,GAAI8gC,EAAO/gC,GAAOyZ,MAAMta,KAAMgP,WAC5B,OAAO,EAIX,OAAO,GA7CmB6yB,CAAWv4B,GAYzC,SAAoBA,GAClB,OAEA,SAAa9D,GACX,IAAIyI,EAEJ,IAAKA,KAAO3E,EACV,GAAI9D,EAAKyI,KAAS3E,EAAK2E,GAAM,OAAO,EAGtC,OAAO,GAtBsC6zB,CAAWx4B,GAG1D,GAAoB,mBAATA,EACT,OAAOA,EAGT,MAAM,IAAImR,MAAM,gDAqDlB,SAAS7X,IACP,OAAO,EAzETL,EAAOxD,QAAU0iC,G,kCCAjBl/B,EAAOxD,QAAU4b,EAEjB,IAAIonB,EAAe,EAAQ,QAEvBC,EAAWD,EAAaC,SACxBC,EAAOF,EAAaE,KACpBC,EAAOH,EAAaG,KAKxB,SAASvnB,EAAMC,EAAMtR,EAAM64B,EAASC,GACd,mBAAT94B,GAA0C,mBAAZ64B,IACvCC,EAAUD,EACVA,EAAU74B,EACVA,EAAO,MAGTy4B,EAAannB,EAAMtR,GAEnB,SAAkB9D,EAAM68B,GACtB,IAAIv8B,EAASu8B,EAAQA,EAAQvhC,OAAS,GAClCD,EAAQiF,EAASA,EAAOI,SAAS0C,QAAQpD,GAAQ,KACrD,OAAO28B,EAAQ38B,EAAM3E,EAAOiF,KALKs8B,GAXrCznB,EAAMqnB,SAAWA,EACjBrnB,EAAMsnB,KAAOA,EACbtnB,EAAMunB,KAAOA,G,kCCTb,IAAIlqB,EAAY,EAAQ,QAIxB,SAASsqB,KAFT//B,EAAOxD,QAAUymB,EAIjB8c,EAAkB90B,UAAYiN,MAAMjN,UACpCgY,EAAShY,UAAY,IAAI80B,EAEzB,IAAIxJ,EAAQtT,EAAShY,UAcrB,SAASgY,EAAStE,EAAQ3d,EAAUoiB,GAClC,IAAI4c,EACAC,EACAC,EAEoB,iBAAbl/B,IACToiB,EAASpiB,EACTA,EAAW,MAGbg/B,EA2CF,SAAqB5c,GACnB,IACI9kB,EADAkF,EAAS,CAAC,KAAM,MAGE,iBAAX4f,KAGM,KAFf9kB,EAAQ8kB,EAAO/c,QAAQ,MAGrB7C,EAAO,GAAK4f,GAEZ5f,EAAO,GAAK4f,EAAOvgB,MAAM,EAAGvE,GAC5BkF,EAAO,GAAK4f,EAAOvgB,MAAMvE,EAAQ,KAIrC,OAAOkF,EA1DC28B,CAAY/c,GACpB6c,EAAQxqB,EAAUzU,IAAa,MAC/Bk/B,EAAW,CACTriC,MAAO,CACL8B,KAAM,KACNC,OAAQ,MAEVZ,IAAK,CACHW,KAAM,KACNC,OAAQ,OAIRoB,GAAYA,EAASA,WACvBA,EAAWA,EAASA,UAGlBA,IAEEA,EAASnD,OACXqiC,EAAWl/B,EACXA,EAAWA,EAASnD,OAGpBqiC,EAASriC,MAAQmD,GAIjB2d,EAAO5V,QACTtL,KAAKsL,MAAQ4V,EAAO5V,MACpB4V,EAASA,EAAOwE,SAGlB1lB,KAAK0lB,QAAUxE,EACflhB,KAAK2C,KAAO6/B,EACZxiC,KAAKkhB,OAASA,EACdlhB,KAAKkC,KAAOqB,EAAWA,EAASrB,KAAO,KACvClC,KAAKmC,OAASoB,EAAWA,EAASpB,OAAS,KAC3CnC,KAAKyiC,SAAWA,EAChBziC,KAAKqQ,OAASkyB,EAAM,GACpBviC,KAAK2iC,OAASJ,EAAM,GA/DtBzJ,EAAMjT,KAAO,GACbiT,EAAMn2B,KAAO,GACbm2B,EAAM5X,OAAS,GACf4X,EAAMpT,QAAU,GAChBoT,EAAMxtB,MAAQ,GACdwtB,EAAMhT,MAAQ,KACdgT,EAAM32B,OAAS,KACf22B,EAAM52B,KAAO,M,kCCjBbK,EAAOxD,QAEP,SAAmBI,GACjB,OAAOA,EAAMyZ,gB,kCCHf,IAAImO,EAAQ,EAAQ,QAEhB5iB,EAAS,EAAQ,QAEjB8X,EAAa8K,EAAM9K,WACnBE,EAAS4K,EAAM5K,OACfC,EAAiB2K,EAAM3K,eAC3B7Z,EAAOxD,QAAUoF,EAAO,CACtB4V,UAsDF,SAAuB3B,EAAGP,GACxB,MAAgB,SAATA,EAAkBA,EAAO,QAAUA,EAAKzS,MAAM,GAAGwT,eAtDxD1C,WAAY,CACV0sB,qBAAsB,KACtBC,WAAY5mB,EACZ6mB,iBAAkB,KAClBC,SAAU9mB,EACV+mB,YAAa/mB,EACbgnB,aAAc9mB,EACd+mB,aAAc/mB,EACdgnB,YAAahnB,EACbinB,aAAchnB,EACdinB,YAAa,KACbC,gBAAiBlnB,EACjBmnB,YAAa,KACbC,aAAcvnB,EACdwnB,eAAgBrnB,EAChBsnB,iBAAkB,KAClBC,aAAc1nB,EACd2nB,WAAYxnB,EACZynB,YAAa5nB,EACb6nB,aAAc,KACdC,WAAY9nB,EACZ+nB,YAAa,KACbC,iBAAkB,KAClBC,UAAW,KACXC,eAAgB/nB,EAChBgoB,UAAWjoB,EACXkoB,SAAU,KACVC,UAAWroB,EACXsoB,cAAetoB,EACfuoB,oBAAqBvoB,EACrBwoB,gBAAiB,KACjBC,SAAUtoB,EACVuoB,gBAAiB,KACjBC,aAAczoB,EACd0oB,YAAa5oB,EACb6oB,aAAc7oB,EACd8oB,aAAc,KACdC,aAAc/oB,EACdgpB,oBAAqB7oB,EACrB8oB,aAAc/oB,EACdgpB,aAAchpB,EACdipB,YAAajpB,EACbkpB,aAAcppB,EACdqpB,YAAanpB,EACbopB,SAAU,KACVC,aAAcrpB,EACdspB,aAActpB,EACdupB,aAAcvpB,EACdwpB,cAAe,KACfC,KAAM,S,mBCtDVrjC,EAAOxD,QAAU,SAAkBiP,GACjC,OAAc,MAAPA,GAAkC,MAAnBA,EAAII,aAA2D,mBAA7BJ,EAAII,YAAYy3B,UAA2B73B,EAAII,YAAYy3B,SAAS73B,K,kCCL9H,IAAIjD,EAAc,EAAQ,QAEtBC,EAAgB,EAAQ,QAExB86B,EAAoB,EAAQ,QAE5BC,EAAY,EAAQ,QAEpBrmC,EAAa,EAAQ,QAErBL,EAAU,EAAQ,QAElBs3B,EAAY,CACdh0B,KAAM,YACN9C,SAmGF,SAA2BC,EAAS8C,GAClC,IACI2D,EADAyW,EAAS8oB,EAAkB9lC,KAAKe,UAEpC,OAEA,SAAeT,GAGb,OAFAR,EAAQU,MAAM,qBACd+F,EAASjG,EACFkG,EAASlG,IAGlB,SAASkG,EAASlG,GAChB,IAAIwB,EACAqR,EACApM,EACAid,EAEJ,OAAI1jB,IAASiG,GACXzG,EAAQW,QAAQH,GACTkG,IAGT1E,EAAQhC,EAAQa,KAAK,qBAErBoG,IADAoM,EAAQ2yB,EAAkBxlC,KACC,IAAV6S,GAAe6J,EAChCgH,GAAShH,GAAqB,IAAXA,GAAgB7J,EACnCrR,EAAMkkC,MAAmB,KAAXz/B,EAAgBQ,EAAOA,IAASiW,IAAWgH,GACzDliB,EAAMmkC,OAAoB,KAAX1/B,EAAgByd,EAAQA,IAAU7Q,IAAUpM,GACpDnE,EAAGtC,MA9HZZ,WAGF,SAA6B0B,EAAQC,GACnC,IACI0F,EACAgd,EACAzkB,EACAyD,EACAE,EACA6N,EACAo1B,EACA9jC,EARAvB,GAAS,EAab,OAASA,EAAQO,EAAON,QAEtB,GAAyB,UAArBM,EAAOP,GAAO,IAA4C,sBAA1BO,EAAOP,GAAO,GAAGS,MAAgCF,EAAOP,GAAO,GAAGolC,OAGpG,IAFAl/B,EAAOlG,EAEAkG,KAEL,GAAwB,SAApB3F,EAAO2F,GAAM,IAA0C,sBAAzB3F,EAAO2F,GAAM,GAAGzF,MAAgCF,EAAO2F,GAAM,GAAGi/B,OAClG3kC,EAAQmI,eAAepI,EAAO2F,GAAM,IAAI9E,WAAW,KAAOZ,EAAQmI,eAAepI,EAAOP,GAAO,IAAIoB,WAAW,GAAI,CAKhH,IAAKb,EAAO2F,GAAM,GAAGk/B,QAAU7kC,EAAOP,GAAO,GAAGmlC,SAAW5kC,EAAOP,GAAO,GAAGU,IAAIa,OAAShB,EAAOP,GAAO,GAAGT,MAAMgC,QAAU,MAAQhB,EAAO2F,GAAM,GAAGxF,IAAIa,OAAShB,EAAO2F,GAAM,GAAG3G,MAAMgC,OAAShB,EAAOP,GAAO,GAAGU,IAAIa,OAAShB,EAAOP,GAAO,GAAGT,MAAMgC,QAAU,GAC3P,SAIF0O,EAAM1P,EAAO2F,GAAM,GAAGxF,IAAIa,OAAShB,EAAO2F,GAAM,GAAG3G,MAAMgC,OAAS,GAAKhB,EAAOP,GAAO,GAAGU,IAAIa,OAAShB,EAAOP,GAAO,GAAGT,MAAMgC,OAAS,EAAI,EAAI,EAC7IW,EAAkB,CAChBzB,KAAMwP,EAAM,EAAI,iBAAmB,mBACnC1Q,MAAO2lC,EAAU1mC,EAAQ+B,EAAO2F,GAAM,GAAGxF,MAAOuP,GAChDvP,IAAKlC,EAAQ+B,EAAO2F,GAAM,GAAGxF,MAE/B0B,EAAkB,CAChB3B,KAAMwP,EAAM,EAAI,iBAAmB,mBACnC1Q,MAAOf,EAAQ+B,EAAOP,GAAO,GAAGT,OAChCmB,IAAKwkC,EAAU1mC,EAAQ+B,EAAOP,GAAO,GAAGT,OAAQ0Q,IAElDxR,EAAO,CACLgC,KAAMwP,EAAM,EAAI,aAAe,eAC/B1Q,MAAOf,EAAQ+B,EAAO2F,GAAM,GAAGxF,KAC/BA,IAAKlC,EAAQ+B,EAAOP,GAAO,GAAGT,QAEhC2jB,EAAQ,CACNziB,KAAMwP,EAAM,EAAI,SAAW,WAC3B1Q,MAAOf,EAAQ0D,EAAgB3C,OAC/BmB,IAAKlC,EAAQ4D,EAAgB1B,MAE/BH,EAAO2F,GAAM,GAAGxF,IAAMlC,EAAQ0D,EAAgB3C,OAC9CgB,EAAOP,GAAO,GAAGT,MAAQf,EAAQ4D,EAAgB1B,KACjD2kC,EAAa,GAET9kC,EAAO2F,GAAM,GAAGxF,IAAIa,OAAShB,EAAO2F,GAAM,GAAG3G,MAAMgC,SACrD8jC,EAAan7B,EAAYm7B,EAAY,CAAC,CAAC,QAAS9kC,EAAO2F,GAAM,GAAI1F,GAAU,CAAC,OAAQD,EAAO2F,GAAM,GAAI1F,MAIvG6kC,EAAan7B,EAAYm7B,EAAY,CAAC,CAAC,QAASniB,EAAO1iB,GAAU,CAAC,QAAS0B,EAAiB1B,GAAU,CAAC,OAAQ0B,EAAiB1B,GAAU,CAAC,QAAS/B,EAAM+B,KAE1J6kC,EAAan7B,EAAYm7B,EAAYxmC,EAAW2B,EAAQnB,OAAOD,WAAWikB,WAAWvb,KAAMvH,EAAOgE,MAAM2B,EAAO,EAAGlG,GAAQQ,IAE1H6kC,EAAan7B,EAAYm7B,EAAY,CAAC,CAAC,OAAQ5mC,EAAM+B,GAAU,CAAC,QAAS4B,EAAiB5B,GAAU,CAAC,OAAQ4B,EAAiB5B,GAAU,CAAC,OAAQ0iB,EAAO1iB,KAEpJD,EAAOP,GAAO,GAAGU,IAAIa,OAAShB,EAAOP,GAAO,GAAGT,MAAMgC,QACvDA,EAAS,EACT8jC,EAAan7B,EAAYm7B,EAAY,CAAC,CAAC,QAAS9kC,EAAOP,GAAO,GAAIQ,GAAU,CAAC,OAAQD,EAAOP,GAAO,GAAIQ,MAEvGe,EAAS,EAGX4I,EAAc5J,EAAQ2F,EAAO,EAAGlG,EAAQkG,EAAO,EAAGm/B,GAClDrlC,EAAQkG,EAAOm/B,EAAWplC,OAASsB,EAAS,EAC5C,MAORvB,GAAS,EAET,OAASA,EAAQO,EAAON,QACQ,sBAA1BM,EAAOP,GAAO,GAAGS,OACnBF,EAAOP,GAAO,GAAGS,KAAO,QAI5B,OAAOF,IAmCTmB,EAAOxD,QAAU43B,G,kCCjJjBp0B,EAAOxD,QAAU2a,EACjB,IAAIof,EAAQpf,EAAOlM,UAKnB,SAASkM,EAAO1D,EAAUgE,EAAQ7D,GAChCnW,KAAKgW,SAAWA,EAChBhW,KAAKga,OAASA,EAEV7D,IACFnW,KAAKmW,MAAQA,GATjB2iB,EAAM3iB,MAAQ,KACd2iB,EAAM9e,OAAS,GACf8e,EAAM9iB,SAAW,I,kCCJjB,IAAI7R,EAAS,EAAQ,QAEjB6iB,EAA2B,EAAQ,QAEvCzkB,EAAOxD,QAAUoF,EAAO,CACtBgS,MAAO,QACP2D,WAAY,CACVqsB,WAAY,eAEdpsB,UAAWiN,EACX9Q,WAAY,CACVlD,MAAO,KACPozB,WAAY,S,kCCZhB7jC,EAAOxD,QAQP,SAA2BwG,GACzB,IAKI+f,EACA+gB,EACA5iC,EACAwQ,EARAX,EAAe/N,EAAE+N,aACjBC,EAAgBhO,EAAEgO,cAClBzS,EAASyS,EAAczS,OACvBD,GAAS,EACTylC,EAAY,GAMhB,OAASzlC,EAAQC,IACfwkB,EAAMhS,EAAaC,EAAc1S,GAAO2X,kBAMxC/U,EAAU6hB,EAAIpf,SAASjC,SACvBgQ,EAAOxQ,EAAQA,EAAQ3C,OAAS,GAChCulC,EAAgB,CACd/kC,KAAM,OACNqE,IAAK,UAAY2f,EAAI9R,WACrB9S,KAAM,CACJukB,YAAa,CACXxT,UAAW,CAAC,sBAGhBvL,SAAU,CAAC,CACT5E,KAAM,OACNnC,MAAO,OAIN8U,GAAsB,cAAdA,EAAK3S,OAChB2S,EAAO,CACL3S,KAAM,YACN4E,SAAU,IAEZzC,EAAQ4B,KAAK4O,IAGfA,EAAK/N,SAASb,KAAKghC,GACnBC,EAAUjhC,KAAK,CACb/D,KAAM,WACNZ,KAAM,CACJukB,YAAa,CACXhV,GAAI,MAAQqV,EAAI9R,aAGpBtN,SAAUzC,EACVF,SAAU+hB,EAAI/hB,YAIlB,GAAyB,IAArB+iC,EAAUxlC,OACZ,OAAO,KAGT,OAAOyE,EAAE,KAAM,MAAO,CACpBkM,UAAW,CAAC,cACX8K,EAAK,CAACjW,EAAcf,GAAI3E,EAAK2E,EAAG,CACjCjE,KAAM,OACN6V,SAAS,EACTjR,SAAUogC,MACP,KAvEP,IAAIhgC,EAAgB,EAAQ,QAExB1F,EAAO,EAAQ,QAEf2b,EAAO,EAAQ,S,kCCNnB,IAAIpY,EAAS,EAAQ,QAErB5B,EAAOxD,QAAUoF,EAAO,CACtBgS,MAAO,QACP4D,UAYF,SAAwB3B,EAAGP,GACzB,MAAO,SAAWA,EAAKzS,MAAM,GAAGwT,eAZhC1C,WAAY,CACVqwB,aAAc,KACdC,aAAc,KACdC,UAAW,KACXC,UAAW,KACXC,UAAW,KACXC,WAAY,KACZC,UAAW,S,kCCZftkC,EAAOxD,QAIP,SAAgBwG,EAAGC,GACjB,OAAOD,EAAEC,EAAM,SAAU+O,EAAIhP,EAAGC,KAHlC,IAAI+O,EAAM,EAAQ,S,kCCFlBhS,EAAOxD,QAEP,SAAWuC,EAAMmE,EAAOtG,GACtB,IAAIqG,EAEA,MAACrG,GAA4D,iBAAVsG,IAAsB2H,MAAMS,QAAQpI,KACzFtG,EAAQsG,EACRA,EAAQ,IAGVD,EAAOvG,OAAOG,OAAO,CACnBkC,KAAMmS,OAAOnS,IACZmE,GAEC2H,MAAMS,QAAQ1O,GAChBqG,EAAKU,SAAW/G,EACPA,UACTqG,EAAKrG,MAAQsU,OAAOtU,IAGtB,OAAOqG,I,kCCpBT,IAAIrB,EAAS,EAAQ,QAErB5B,EAAOxD,QAAUoF,EAAO,CACtBgS,MAAO,MACP4D,UAQF,SAAsB3B,EAAGP,GACvB,MAAO,OAASA,EAAKzS,MAAM,GAAGwT,eAR9B1C,WAAY,CACV4wB,QAAS,KACTC,QAAS,KACTC,SAAU,S,kCCRd,IAAIC,EAAa,EAAQ,QAEzB1kC,EAAOxD,QAMP,SAAuB+gC,EAAa/7B,GAC9B+7B,IAAgBA,EAAYF,UAC9B77B,EAAU+7B,EACVA,EAAc,MAGhB,OAAOA,EAKT,SAAgBA,EAAa/7B,GAC3B,OAEA,SAAqByB,EAAMqgB,EAAMlhB,GAC/Bm7B,EAAYL,IAAIwH,EAAWzhC,EAAMzB,GAAU8hB,GAE3C,SAActL,GACZ5V,EAAK4V,OAZY2sB,CAAOpH,EAAa/7B,GAmB3C,SAAgBA,GACd,OAEA,SAAqByB,GACnB,OAAOyhC,EAAWzhC,EAAMzB,IAvB0BojC,CAAOpjC,K,kCCd7D,IAAIO,EAAe,EAAQ,QAEvByyB,EAAa,CACfp0B,KAAM,aACN9C,SAGF,SAA4BC,EAAS8C,GACnC,OAEA,SAAetC,GAIb,OAHAR,EAAQU,MAAM,cACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,cACN2D,EAAaxE,EAAS8C,EAAI,iBAIrCL,EAAOxD,QAAUg4B,G,kCClBjB,IAAIpwB,EAA4B,EAAQ,QAEpCmS,EAAqB,EAAQ,QAE7BsuB,EAAoB,EAAQ,QAgBhC7kC,EAAOxD,QAVP,SAA2BuB,GACzB,OAAa,OAATA,GAAiBqG,EAA0BrG,IAAS8mC,EAAkB9mC,GACjE,EAGLwY,EAAmBxY,GACd,OADT,I,kCCfFiC,EAAOxD,QAMP,SAAkBwG,EAAGC,EAAMM,GACzB,IAKIhF,EACAD,EACA+U,EAPA7P,EAASwO,EAAIhP,EAAGC,GAChBQ,EAAOD,EAAO,GACd6yB,EAAQ9yB,EAoDd,SAAmBN,GACjB,IAAIozB,EAAQpzB,EAAK6hC,OACbnhC,EAAWV,EAAKU,SAChBpF,EAASoF,EAASpF,OAClBD,GAAS,EAEb,MAAQ+3B,KAAW/3B,EAAQC,GACzB83B,EAAQ0O,EAAcphC,EAASrF,IAGjC,OAAO+3B,EA9Dc2O,CAAUzhC,GAAUwhC,EAAc9hC,GACnDC,EAAQ,GACR+hC,EAAU,GAKc,kBAAjBhiC,EAAKwR,UACThR,GAAyB,MAAjBA,EAAK+P,UAChB/P,EAAOT,EAAE,KAAM,IAAK,IACpBQ,EAAOyO,QAAQxO,IAGbA,EAAKE,SAASpF,OAAS,GACzBkF,EAAKE,SAASsO,QAAQF,EAAE,OAAQ,MAGlCtO,EAAKE,SAASsO,QAAQjP,EAAE,KAAM,QAAS,CACrCjE,KAAM,WACN0V,QAASxR,EAAKwR,QACdmS,UAAU,KAIZ1jB,EAAMgM,UAAY,CAAC,mBAGrB3Q,EAASiF,EAAOjF,OAChBD,GAAS,EAET,OAASA,EAAQC,GACf8U,EAAQ7P,EAAOlF,IAEX+3B,GAAmB,IAAV/3B,GAAiC,MAAlB+U,EAAMG,UAChCyxB,EAAQniC,KAAKiP,EAAE,OAAQ,OAGH,MAAlBsB,EAAMG,SAAoB6iB,EAG5B4O,EAAQniC,KAAKuQ,GAFb4xB,EAAUA,EAAQvjC,OAAO2R,EAAM1P,UAO/BpF,IAAW83B,GAA2B,MAAlBhjB,EAAMG,UAC5ByxB,EAAQniC,KAAKiP,EAAE,OAAQ,OAGzB,OAAO/O,EAAEC,EAAM,KAAMC,EAAO+hC,IAxD9B,IAAIlzB,EAAI,EAAQ,QAEZC,EAAM,EAAQ,QAsElB,SAAS+yB,EAAc9hC,GACrB,IAAI6hC,EAAS7hC,EAAK6hC,OAClB,OAAOA,QAA0C7hC,EAAKU,SAASpF,OAAS,EAAIumC,I,kCC5E9E9kC,EAAOxD,QAIP,SAAcwG,EAAGC,GACf,OAAOD,EAAE8T,QAAQ7T,EAAM8O,EAAE,OAAQb,OAAOjO,EAAKrG,OAAOkH,QAAQ,0BAA2B,SAHzF,IAAIiO,EAAI,EAAQ,S,kCCFhB,IAAI7R,EAAqB,EAAQ,QAE7Bq0B,EAAkB,CACpBn0B,KAAM,kBACN9C,SAGF,SAAiCC,EAAS8C,EAAIC,GAC5C,OAEA,SAAevC,GAIb,OAHAR,EAAQU,MAAM,mBACdV,EAAQU,MAAM,gBACdV,EAAQW,QAAQH,GACTyG,GAGT,SAASA,EAAKzG,GACZ,OAAImC,EAAmBnC,IACrBR,EAAQa,KAAK,gBACbb,EAAQa,KAAK,mBACNiC,EAAGtC,IAGLuC,EAAIvC,MAIfiC,EAAOxD,QAAU+3B,G,kCC5BjB,IAAIriB,EAAe,EAAQ,QAEvB9N,EAA4B,EAAQ,QAEpClE,EAAqB,EAAQ,QAoHjCF,EAAOxD,QAjHP,SAA4Be,EAAS8C,EAAIC,EAAKvB,EAAMmmC,EAAaC,EAAmBC,EAAS/zB,EAAYvK,GACvG,IAAIu+B,EAAQv+B,GAAO22B,IACf6H,EAAU,EACd,OAEA,SAAevnC,GACb,GAAa,KAATA,EAMF,OALAR,EAAQU,MAAMc,GACdxB,EAAQU,MAAMinC,GACd3nC,EAAQU,MAAMknC,GACd5nC,EAAQW,QAAQH,GAChBR,EAAQa,KAAK+mC,GACNI,EAGT,GAAIrzB,EAAanU,IAAkB,KAATA,EACxB,OAAOuC,EAAIvC,GASb,OANAR,EAAQU,MAAMc,GACdxB,EAAQU,MAAMmnC,GACd7nC,EAAQU,MAAMoT,GACd9T,EAAQU,MAAM,cAAe,CAC3BkE,YAAa,WAERqjC,EAAeznC,IAGxB,SAASwnC,EAA0BxnC,GACjC,OAAa,KAATA,GACFR,EAAQU,MAAMknC,GACd5nC,EAAQW,QAAQH,GAChBR,EAAQa,KAAK+mC,GACb5nC,EAAQa,KAAK8mC,GACb3nC,EAAQa,KAAKW,GACNsB,IAGT9C,EAAQU,MAAMoT,GACd9T,EAAQU,MAAM,cAAe,CAC3BkE,YAAa,WAERsjC,EAAoB1nC,IAG7B,SAAS0nC,EAAoB1nC,GAC3B,OAAa,KAATA,GACFR,EAAQa,KAAK,eACbb,EAAQa,KAAKiT,GACNk0B,EAA0BxnC,IAGtB,OAATA,GAA0B,KAATA,GAAemC,EAAmBnC,GAC9CuC,EAAIvC,IAGbR,EAAQW,QAAQH,GACA,KAATA,EAAc2nC,EAA4BD,GAGnD,SAASC,EAA0B3nC,GACjC,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCR,EAAQW,QAAQH,GACT0nC,GAGFA,EAAoB1nC,GAG7B,SAASynC,EAAeznC,GACtB,OAAa,KAATA,IACIunC,EAAUD,EAAc/kC,EAAIvC,IAClCR,EAAQW,QAAQH,GACTynC,GAGI,KAATznC,EACGunC,KAQL/nC,EAAQW,QAAQH,GACTynC,IARLjoC,EAAQa,KAAK,eACbb,EAAQa,KAAKiT,GACb9T,EAAQa,KAAKgnC,GACb7nC,EAAQa,KAAKW,GACNsB,EAAGtC,IAOD,OAATA,GAAiBqG,EAA0BrG,GACzCunC,EAAgBhlC,EAAIvC,IACxBR,EAAQa,KAAK,eACbb,EAAQa,KAAKiT,GACb9T,EAAQa,KAAKgnC,GACb7nC,EAAQa,KAAKW,GACNsB,EAAGtC,IAGRmU,EAAanU,GAAcuC,EAAIvC,IACnCR,EAAQW,QAAQH,GACA,KAATA,EAAc4nC,EAAuBH,GAG9C,SAASG,EAAqB5nC,GAC5B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCR,EAAQW,QAAQH,GACTynC,GAGFA,EAAeznC,M,kCCpH1B,IAEImG,EAFa,EAAQ,OAER4M,CAAW,YAC5B9Q,EAAOxD,QAAU0H,G,kCCHjBlE,EAAOxD,QAIP,SAAkBwG,EAAGC,GACnB,OAAOD,EAAEC,EAAM,KAAM+O,EAAIhP,EAAGC,KAH9B,IAAI+O,EAAM,EAAQ,S,kCCSlBhS,EAAOxD,QAXP,SAAoB0C,GAIlB,IAHA,IAAIZ,GAAS,EACTe,EAAO,IAEFf,EAAQY,EAAOX,QACtBc,GAAiC,iBAAlBH,EAAOZ,GAAsBY,EAAOZ,GAAOC,OAAS,EAGrE,OAAOc,I,kCCRT,IAAIgD,EAAgB,EAAQ,QAExBN,EAAe,EAAQ,QAEvBsyB,EAAa,CACfj0B,KAAM,aACN9C,SAOF,SAAiCC,EAAS8C,EAAIC,GAC5C,IAAI9C,EAAOC,KACX,OAEA,SAAeM,GACb,GAAa,KAATA,EAYF,OAXKP,EAAK+J,eAAe/C,OACvBjH,EAAQU,MAAM,aAAc,CAC1BuJ,YAAY,IAEdhK,EAAK+J,eAAe/C,MAAO,GAG7BjH,EAAQU,MAAM,oBACdV,EAAQU,MAAM,oBACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,oBACNwS,EAGT,OAAOtQ,EAAIvC,IAGb,SAAS6S,EAAM7S,GACb,OAAIsE,EAActE,IAChBR,EAAQU,MAAM,8BACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,8BACbb,EAAQa,KAAK,oBACNiC,IAGT9C,EAAQa,KAAK,oBACNiC,EAAGtC,MAvCZmK,aAAc,CACZ5K,SA0CJ,SAAwCC,EAAS8C,EAAIC,GACnD,OAAOyB,EAAaxE,EAASA,EAAQK,QAAQy2B,EAAYh0B,EAAIC,GAAM,aAAc7C,KAAKE,OAAOD,WAAWyI,QAAQC,KAAKC,QAAQ,iBAAmB,OAAI1H,EAAY,KAzChKP,KA4CF,SAAcb,GACZA,EAAQa,KAAK,gBAGf4B,EAAOxD,QAAU63B,G,kCC1DjB,IAAIn0B,EAAqB,EAAQ,QAE7BmC,EAAgB,EAAQ,QAyE5BrC,EAAOxD,QAtEP,SAAsBe,EAAS8C,EAAIC,EAAKvB,EAAMqS,EAAYC,GACxD,IAEIlT,EAFAX,EAAOC,KACP4B,EAAO,EAEX,OAEA,SAAetB,GAMb,OALAR,EAAQU,MAAMc,GACdxB,EAAQU,MAAMmT,GACd7T,EAAQW,QAAQH,GAChBR,EAAQa,KAAKgT,GACb7T,EAAQU,MAAMoT,GACPrT,GAGT,SAASA,EAAQD,GACf,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,IAAgBI,GAE3C,KAATJ,IAECsB,GAED,2BAA4B7B,EAAKG,OAAOD,YAAc2B,EAAO,IACpDiB,EAAIvC,GAGA,KAATA,GACFR,EAAQa,KAAKiT,GACb9T,EAAQU,MAAMmT,GACd7T,EAAQW,QAAQH,GAChBR,EAAQa,KAAKgT,GACb7T,EAAQa,KAAKW,GACNsB,GAGLH,EAAmBnC,IACrBR,EAAQU,MAAM,cACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,cACNJ,IAGTT,EAAQU,MAAM,cAAe,CAC3BkE,YAAa,WAER2P,EAAM/T,IAGf,SAAS+T,EAAM/T,GACb,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAemC,EAAmBnC,IAASsB,IAAS,KACtF9B,EAAQa,KAAK,eACNJ,EAAQD,KAGjBR,EAAQW,QAAQH,GAChBI,EAAOA,IAASkE,EAActE,GACd,KAATA,EAAc6nC,EAAc9zB,GAGrC,SAAS8zB,EAAY7nC,GACnB,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCR,EAAQW,QAAQH,GAChBsB,IACOyS,GAGFA,EAAM/T,M,kCCvEjB,IAEIwI,EAFa,EAAQ,OAERuK,CAAW,MAC5B9Q,EAAOxD,QAAU+J,G,kCCHjBvG,EAAOxD,QAiBP,SAAawG,EAAGC,EAAMM,GACpB,IACImU,EADA3Y,EAAOkE,GAAQA,EAAKlE,KAGxB,IAAKA,EACH,MAAM,IAAImZ,MAAM,uBAAyBjV,EAAO,KAIhDyU,EADE5W,EAAIrC,KAAKuE,EAAEof,SAAUrjB,GAClBiE,EAAEof,SAASrjB,GACPiE,EAAEsf,aAAetf,EAAEsf,YAAYjc,QAAQtH,IAAS,EACpD8mC,EAEA7iC,EAAEqf,eAGT,OAAsB,mBAAP3K,EAAoBA,EAAKouB,GAAS9iC,EAAGC,EAAMM,IA/B5D,IAAIwO,EAAI,EAAQ,QAEZC,EAAM,EAAQ,QAEdlR,EAAM,GAAGC,eAEb,SAAS+kC,EAAQ9iC,EAAGC,GAClB,OA4BF,SAAcA,GACZ,IAAI9E,EAAO8E,EAAK9E,MAAQ,GAExB,GAAI2C,EAAIrC,KAAKN,EAAM,UAAY2C,EAAIrC,KAAKN,EAAM,gBAAkB2C,EAAIrC,KAAKN,EAAM,aAC7E,OAAO,EAGT,MAAO,UAAW8E,EAnCdlG,CAAKkG,GACAD,EAAE8T,QAAQ7T,EAAM8O,EAAE,OAAQ9O,EAAKrG,QAGjCoG,EAAEC,EAAM,MAAO+O,EAAIhP,EAAGC,IAkC/B,SAAS4iC,EAAW7iC,EAAGC,GACrB,IAAIuJ,EAEJ,OAAIvJ,EAAKU,WACP6I,EAAQ9P,OAAOG,OAAO,GAAIoG,IACpBU,SAAWqO,EAAIhP,EAAGC,GACjBuJ,GAGFvJ,I,kCCxDTjD,EAAOxD,QAAUgjC,EAEjB,IAAIN,EAAU,EAAQ,QAElBvN,EAAQ,EAAQ,QASpB,SAAS6N,EAAannB,EAAMtR,EAAM64B,EAASC,GACzC,IAAIxP,EACAnI,EAEgB,mBAATnhB,GAA0C,mBAAZ64B,IACvCC,EAAUD,EACVA,EAAU74B,EACVA,EAAO,MAGTmhB,EAAKgX,EAAQn4B,GACbspB,EAAOwP,GAAW,EAAI,EAGtB,SAAS3pB,EAAQjT,EAAM3E,EAAOwhC,GAC5B,IACI1/B,EADAxD,EAAwB,iBAATqG,GAA8B,OAATA,EAAgBA,EAAO,GAGrC,iBAAfrG,EAAMmC,OACfqB,EAAgC,iBAAlBxD,EAAM4W,QAAuB5W,EAAM4W,QAAgC,iBAAf5W,EAAMwD,KAAoBxD,EAAMwD,UAAOzB,EACzGyZ,EAAMjC,YAAc,SAAWwb,EAAM/0B,EAAMmC,MAAQqB,EAAO,IAAMA,EAAO,IAAM,KAAO,KAGtF,OAAOgY,EAEP,SAASA,IACP,IAEI2tB,EACAlmC,EAHAmmC,EAAelG,EAAQp+B,OAAOuB,GAC9BO,EAAS,GAIb,KAAKuD,GAAQmhB,EAAGjlB,EAAM3E,EAAOwhC,EAAQA,EAAQvhC,OAAS,IAAM,SApCvD,KAqCHiF,EA0BR,SAAkB5G,GAChB,GAAc,OAAVA,GAAmC,iBAAVA,GAAsB,WAAYA,EAC7D,OAAOA,EAGT,GAAqB,iBAAVA,EACT,MAAO,EAvEI,EAuEOA,GAGpB,MAAO,CAACA,GAnCOqpC,CAASrG,EAAQ38B,EAAM68B,KAErB,GACT,OAAOt8B,EAIX,GAAIP,EAAKU,UA7CJ,SA6CgBH,EAAO,GAG1B,IAFA3D,GAAUggC,EAAU58B,EAAKU,SAASpF,QAAU,GAAK8xB,EAE1CxwB,GAAU,GAAKA,EAASoD,EAAKU,SAASpF,QAAQ,CAGnD,IAlDC,KAgDDwnC,EAAY7vB,EAAQjT,EAAKU,SAAS9D,GAASA,EAAQmmC,EAAvC9vB,IAEE,GACZ,OAAO6vB,EAGTlmC,EAAiC,iBAAjBkmC,EAAU,GAAkBA,EAAU,GAAKlmC,EAASwwB,EAIxE,OAAO7sB,GAzCX0S,CAAQmC,EAAM,KAAM,GAApBnC,GAhBFspB,EAAaC,UAHE,EAIfD,EAAaE,KAHF,OAIXF,EAAaG,MAHF,G,kCCRX,IAAIuG,EAAS,cAsFblmC,EAAOxD,QApFP,WACE,IAGI2pC,EAHAtoC,GAAQ,EACR+B,EAAS,EACT0E,EAAS,GAEb,OAEA,SAAsB1H,EAAOwpC,EAAUpnC,GACrC,IACIqf,EACAjc,EACAwd,EACAymB,EACAtoC,EALAmB,EAAS,GAMbtC,EAAQ0H,EAAS1H,EAAMuO,SAASi7B,GAChCxmB,EAAgB,EAChBtb,EAAS,GAELzG,IAC0B,QAAxBjB,EAAM8C,WAAW,IACnBkgB,IAGF/hB,OAAQc,GAGV,KAAOihB,EAAgBhjB,EAAM2B,QAAQ,CAMnC,GALA2nC,EAAOI,UAAY1mB,EACnBvB,EAAQ6nB,EAAOlnB,KAAKpiB,GACpBypC,EAAchoB,EAAQA,EAAM/f,MAAQ1B,EAAM2B,OAC1CR,EAAOnB,EAAM8C,WAAW2mC,IAEnBhoB,EAAO,CACV/Z,EAAS1H,EAAMiG,MAAM+c,GACrB,MAGF,GAAa,KAAT7hB,GAAe6hB,IAAkBymB,GAAeF,EAClDjnC,EAAO4D,MAAM,GACbqjC,OAAmBxnC,OAYnB,GAVIwnC,IACFjnC,EAAO4D,MAAM,GACbqjC,OAAmBxnC,GAGjBihB,EAAgBymB,IAClBnnC,EAAO4D,KAAKlG,EAAMiG,MAAM+c,EAAeymB,IACvCzmC,GAAUymC,EAAczmB,GAGb,IAAT7hB,EACFmB,EAAO4D,KAAK,OACZlD,SACK,GAAa,IAAT7B,EAIT,IAHAqE,EAA+B,EAAxBmX,KAAKgtB,KAAK3mC,EAAS,GAC1BV,EAAO4D,MAAM,GAENlD,IAAWwC,GAChBlD,EAAO4D,MAAM,QAEG,KAAT/E,GACTmB,EAAO4D,MAAM,GACblD,EAAS,IAGPumC,GAAmB,EACnBvmC,EAAS,GAIfggB,EAAgBymB,EAAc,EAG5BrnC,IACEmnC,GAAkBjnC,EAAO4D,MAAM,GAC/BwB,GAAQpF,EAAO4D,KAAKwB,GACxBpF,EAAO4D,KAAK,OAGd,OAAO5D,K,kCClFX,IAAI6B,EAAiB,EAAQ,QAEzB0H,EAAgB,EAAQ,QAExBlH,EAAW,EAAQ,QAavB,SAASilC,EAAUx0B,EAAKw0B,GACtB,IAAIC,EACAlkB,EACAC,EACAzkB,EAEJ,IAAK0oC,KAAQD,EAIX,IAAKzoC,KAHLwkB,EAAOxhB,EAAetC,KAAKuT,EAAKy0B,GAAQz0B,EAAIy0B,GAAQz0B,EAAIy0B,GAAQ,GAChEjkB,EAAQgkB,EAAUC,GAGhBlkB,EAAKxkB,GAAQL,EAAW6D,EAASihB,EAAMzkB,IAAQgD,EAAetC,KAAK8jB,EAAMxkB,GAAQwkB,EAAKxkB,GAAQ,IAKpG,SAASL,EAAWW,EAAMqoC,GAIxB,IAHA,IAAIpoC,GAAS,EACTmc,EAAS,KAEJnc,EAAQD,EAAKE,SAEC,UAApBF,EAAKC,GAAO+hB,IAAkBqmB,EAAWjsB,GAAQ3X,KAAKzE,EAAKC,IAI9D,OADAmK,EAAci+B,EAAU,EAAG,EAAGjsB,GACvBisB,EAGT1mC,EAAOxD,QAxCP,SAA2BmF,GAIzB,IAHA,IAAIqQ,EAAM,GACN1T,GAAS,IAEJA,EAAQqD,EAAWpD,QAC1BioC,EAAUx0B,EAAKrQ,EAAWrD,IAG5B,OAAO0T,I,kCCdThS,EAAOxD,QAIP,SAAcwG,EAAGC,GACf,IAKIlF,EALAnB,EAAQqG,EAAKrG,MAAQqG,EAAKrG,MAAQ,KAAO,GAGzC6rB,EAAOxlB,EAAKwlB,MAAQxlB,EAAKwlB,KAAKpK,MAAM,uBACpCnb,EAAQ,GAGRulB,IACFvlB,EAAMgM,UAAY,CAAC,YAAcuZ,IAGnC1qB,EAAOiF,EAAEC,EAAM,OAAQC,EAAO,CAAC6O,EAAE,OAAQnV,KAErCqG,EAAKghB,OACPlmB,EAAKI,KAAO,CACV8lB,KAAMhhB,EAAKghB,OAIf,OAAOjhB,EAAEC,EAAKjC,SAAU,MAAO,CAACjD,KAtBlC,IAAIgU,EAAI,EAAQ,S,kCCEhB/R,EAAOxD,QAJP,SAAkBI,GAChB,OAAOA,QAAwC,GAAK,WAAYA,EAAQA,EAAQ,CAACA,K,kCCDnF,IAEI05B,EAFa,EAAQ,OAEFxlB,CAAW,kBAClC9Q,EAAOxD,QAAU85B,G,kCCHjB,IAAI5d,EAAO,EAAQ,QAEf8L,EAAQ,EAAQ,QAEpBxkB,EAAOxD,QAAU4a,EACjBA,EAAYnM,UAAY,IAAIyN,EAC5BtB,EAAYnM,UAAUxJ,SAAU,EAChC,IAAI49B,EAAS,CAAC,UAAW,aAAc,oBAAqB,SAAU,iBAAkB,iBAAkB,yBACtGsH,EAAetH,EAAO9gC,OAE1B,SAAS6Y,EAAY3D,EAAUsC,EAAW6wB,EAAMhzB,GAC9C,IACInM,EADAnJ,GAAS,EAKb,IAHAuoC,EAAKppC,KAAM,QAASmW,GACpB8E,EAAKja,KAAKhB,KAAMgW,EAAUsC,KAEjBzX,EAAQqoC,GAEfE,EAAKppC,KADLgK,EAAQ43B,EAAO/gC,IACIsoC,EAAOpiB,EAAM/c,MAAY+c,EAAM/c,IAItD,SAASo/B,EAAKjjC,EAAQ8H,EAAK9O,GACrBA,IACFgH,EAAO8H,GAAO9O,K,kCCxBlB,IAAIsD,EAAqB,EAAQ,QAE7BgH,EAAa,EAAQ,QAErB3E,EAAc,EAAQ,QAEtBR,EAAe,EAAQ,QAGvBb,EAAU,CACZ5D,SAgBF,SAAyBC,EAAS8C,GAChC,IAAI7B,EACJ,OAEA,SAAeT,GAKb,OAJAR,EAAQU,MAAM,WACdO,EAAWjB,EAAQU,MAAM,eAAgB,CACvCkE,YAAa,YAERhE,EAAKJ,IAGd,SAASI,EAAKJ,GACZ,OAAa,OAATA,EACKmZ,EAAWnZ,GAGhBmC,EAAmBnC,GACdR,EAAQkK,MAAMq/B,EAAuB5iB,EAAiBhN,EAAtD3Z,CAAkEQ,IAI3ER,EAAQW,QAAQH,GACTI,GAGT,SAAS+Y,EAAWnZ,GAGlB,OAFAR,EAAQa,KAAK,gBACbb,EAAQa,KAAK,WACNiC,EAAGtC,GAGZ,SAASmmB,EAAgBnmB,GAOvB,OANAR,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,gBACbI,EAAWA,EAAS4D,KAAO7E,EAAQU,MAAM,eAAgB,CACvDkE,YAAa,UACb3D,SAAUA,IAELL,IAtDTwC,QAUF,SAAwB9B,GAEtB,OADA0D,EAAY1D,GACLA,GAXP+7B,eAAe,EACfnxB,MAAM,GAEJq9B,EAAwB,CAC1BxpC,SAqDF,SAA8BC,EAAS8C,EAAIC,GACzC,IAAI9C,EAAOC,KACX,OAEA,SAAwBM,GAItB,OAHAR,EAAQU,MAAM,cACdV,EAAQW,QAAQH,GAChBR,EAAQa,KAAK,cACN2D,EAAaxE,EAASwpC,EAAU,eAGzC,SAASA,EAAShpC,GAChB,OAAa,OAATA,GAAiBmC,EAAmBnC,GAC/BuC,EAAIvC,GAGTP,EAAKG,OAAOD,WAAWyI,QAAQC,KAAKC,QAAQ,iBAAmB,GAAKa,EAAW1J,EAAKqB,OAAQ,cAAgB,EACvGtB,EAAQoK,UAAUnK,EAAKG,OAAOD,WAAW0D,KAAMd,EAAKD,EAApD9C,CAAwDQ,GAG1DsC,EAAGtC,KAxEZwK,SAAS,GA4EXvI,EAAOxD,QAAU0E,G,kCC5FflB,EAAOxD,QAAU,EAAQ,S,oCCD3B,IAAI2b,EAAe,EAAQ,QAU3BnY,EAAOxD,QARP,SAAoBwqC,GAClB,OAEA,SAAejpC,GACb,OAAOipC,EAAMjgC,KAAKoR,EAAapa,O,kCCNnCiC,EAAOxD,QAAU,EAAQ,S,kCCAzB,IAAI26B,EAAI,EAAQ,QAEZ8P,EAAO,EAAQ,QAEf3iC,EAAS,EAAQ,QAErBtE,EAAOxD,QAAU0mB,EACjB,IAAIpiB,EAAM,GAAGC,eAITmmC,EAAQ,CAAC,UAAW,OAAQ,WAAY,OAAQ,UAAW,WA4B/D,SAAShkB,EAAM1hB,GACb,IAAI8T,EACAhX,EAEJ,GAAKkD,GAEE,GAAuB,iBAAZA,GAAwB8C,EAAO9C,GAC/CA,EAAU,CACRiQ,SAAUjQ,QAEP,GAAI,YAAaA,GAAW,aAAcA,EAC/C,OAAOA,OANPA,EAAU,GASZ,KAAM/D,gBAAgBylB,GACpB,OAAO,IAAIA,EAAM1hB,GAUnB,IAPA/D,KAAKU,KAAO,GACZV,KAAK+lB,SAAW,GAChB/lB,KAAK0pC,QAAU,GACf1pC,KAAKhB,IAAMwqC,EAAKxqC,MAEhB6B,GAAS,IAEAA,EAAQ4oC,EAAM3oC,QACrB+W,EAAO4xB,EAAM5oC,GAETwC,EAAIrC,KAAK+C,EAAS8T,KACpB7X,KAAK6X,GAAQ9T,EAAQ8T,IAKzB,IAAKA,KAAQ9T,EACP0lC,EAAM7gC,QAAQiP,GAAQ,IACxB7X,KAAK6X,GAAQ9T,EAAQ8T,IA2E3B,SAAS8xB,EAAWC,EAAMjnC,GACxB,GAAIinC,GAAQA,EAAKhhC,QAAQ8wB,EAAEmQ,MAAQ,EACjC,MAAM,IAAIpvB,MAAM,IAAM9X,EAAO,uCAAyC+2B,EAAEmQ,IAAM,KAKlF,SAASC,EAAeF,EAAMjnC,GAC5B,IAAKinC,EACH,MAAM,IAAInvB,MAAM,IAAM9X,EAAO,qBAKjC,SAASonC,EAAWnkB,EAAMjjB,GACxB,IAAKijB,EACH,MAAM,IAAInL,MAAM,YAAc9X,EAAO,mCA1JzC8iB,EAAMjY,UAAUE,SAqIhB,SAAkBi7B,GAChB,OAAQ3oC,KAAKgU,UAAY,IAAItG,SAASi7B,IApIxC1pC,OAAOC,eAAeumB,EAAMjY,UAAW,OAAQ,CAC7Cw8B,IAiEF,WACE,OAAOhqC,KAAK0pC,QAAQ1pC,KAAK0pC,QAAQ5oC,OAAS,IAjE1CmpC,IAoEF,SAAiBrkB,GACfkkB,EAAelkB,EAAM,QAEjB5lB,KAAK4lB,OAASA,GAChB5lB,KAAK0pC,QAAQrkC,KAAKugB,MArEtB3mB,OAAOC,eAAeumB,EAAMjY,UAAW,UAAW,CAChDw8B,IAwEF,WACE,MAA4B,iBAAdhqC,KAAK4lB,KAAoB8T,EAAEwQ,QAAQlqC,KAAK4lB,WAAQ1kB,GAxE9D+oC,IA2EF,SAAoBC,GAClBH,EAAW/pC,KAAK4lB,KAAM,WACtB5lB,KAAK4lB,KAAO8T,EAAEljB,KAAK0zB,GAAW,GAAIlqC,KAAKmqC,aA1EzClrC,OAAOC,eAAeumB,EAAMjY,UAAW,WAAY,CACjDw8B,IA4EF,WACE,MAA4B,iBAAdhqC,KAAK4lB,KAAoB8T,EAAEyQ,SAASnqC,KAAK4lB,WAAQ1kB,GA5E/D+oC,IA+EF,SAAqBE,GACnBL,EAAeK,EAAU,YACzBR,EAAWQ,EAAU,YACrBnqC,KAAK4lB,KAAO8T,EAAEljB,KAAKxW,KAAKkqC,SAAW,GAAIC,MA/EzClrC,OAAOC,eAAeumB,EAAMjY,UAAW,UAAW,CAChDw8B,IAiFF,WACE,MAA4B,iBAAdhqC,KAAK4lB,KAAoB8T,EAAE0Q,QAAQpqC,KAAK4lB,WAAQ1kB,GAjF9D+oC,IAoFF,SAAoBG,GAIlB,GAHAT,EAAWS,EAAS,WACpBL,EAAW/pC,KAAK4lB,KAAM,WAElBwkB,EAAS,CACX,GAA8B,KAA1BA,EAAQnoC,WAAW,GAGnB,MAAM,IAAIwY,MAAM,iCAGpB,GAAI2vB,EAAQxhC,QAAQ,IAAK,IAAM,EAC7B,MAAM,IAAI6R,MAAM,0CAIpBza,KAAK4lB,KAAO8T,EAAEljB,KAAKxW,KAAKkqC,QAASlqC,KAAKqqC,MAAQD,GAAW,QAjG3DnrC,OAAOC,eAAeumB,EAAMjY,UAAW,OAAQ,CAC7Cw8B,IAmGF,WACE,MAA4B,iBAAdhqC,KAAK4lB,KAAoB8T,EAAEyQ,SAASnqC,KAAK4lB,KAAM5lB,KAAKoqC,cAAWlpC,GAnG7E+oC,IAsGF,SAAiBI,GACfP,EAAeO,EAAM,QACrBV,EAAWU,EAAM,QACjBrqC,KAAK4lB,KAAO8T,EAAEljB,KAAKxW,KAAKkqC,SAAW,GAAIG,GAAQrqC,KAAKoqC,SAAW,S,kCC7IjE,IAEIhD,EAFa,EAAQ,OAED/zB,CAAW,MACnC9Q,EAAOxD,QAAUqoC,G,oCC6PjB,SAAS9hC,EAAUsgB,GACjB,IAAI0kB,EACAnrC,EAkBJ,OAjBA4qC,EAAWnkB,GACX0kB,EAAkC,KAAvB1kB,EAAK3jB,WAAW,IAI3B9C,EAgBF,SAAyBymB,EAAM2kB,GAC7B,IAKIjqC,EACAkqC,EANAzkC,EAAS,GACT0kC,EAAoB,EACpBC,GAAa,EACbC,EAAO,EACP9pC,GAAS,EAIb,OAASA,GAAS+kB,EAAK9kB,QAAQ,CAC7B,GAAID,EAAQ+kB,EAAK9kB,OACfR,EAAOslB,EAAK3jB,WAAWpB,OAClB,IAAa,KAATP,EAGP,MAEFA,EAAO,GAIT,GAAa,KAATA,EAEF,CACE,GAAIoqC,IAAc7pC,EAAQ,GAAc,IAAT8pC,QACxB,GAAID,IAAc7pC,EAAQ,GAAc,IAAT8pC,EAAY,CAChD,GAAI5kC,EAAOjF,OAAS,GAA2B,IAAtB2pC,GAAoE,KAAzC1kC,EAAO9D,WAAW8D,EAAOjF,OAAS,IAE1C,KAAzCiF,EAAO9D,WAAW8D,EAAOjF,OAAS,GAGjC,GAAIiF,EAAOjF,OAAS,GAIlB,IAHA0pC,EAAiBzkC,EAAO8a,YAAY,QAGb9a,EAAOjF,OAAS,EAAG,CACpC0pC,EAAiB,GACnBzkC,EAAS,GACT0kC,EAAoB,IAEpB1kC,EAASA,EAAOX,MAAM,EAAGolC,GACzBC,EAAoB1kC,EAAOjF,OAAS,EAAIiF,EAAO8a,YAAY,MAG7D6pB,EAAY7pC,EACZ8pC,EAAO,EACP,eAEG,GAAI5kC,EAAOjF,OAAQ,CACxBiF,EAAS,GACT0kC,EAAoB,EACpBC,EAAY7pC,EACZ8pC,EAAO,EACP,SAIFJ,IACFxkC,EAASA,EAAOjF,OAASiF,EAAS,MAAQ,KAC1C0kC,EAAoB,QAGlB1kC,EAAOjF,OACTiF,GAAU,IAAM6f,EAAKxgB,MAAMslC,EAAY,EAAG7pC,GAE1CkF,EAAS6f,EAAKxgB,MAAMslC,EAAY,EAAG7pC,GAGrC4pC,EAAoB5pC,EAAQ6pC,EAAY,EAG1CA,EAAY7pC,EACZ8pC,EAAO,OACW,KAATrqC,GAEVqqC,GAAQ,EACTA,IAEAA,GAAQ,EAIZ,OAAO5kC,EAlGC6kC,CAAgBhlB,GAAO0kB,IAEpBxpC,QAAWwpC,IACpBnrC,EAAQ,KAGNA,EAAM2B,QAA+C,KAArC8kB,EAAK3jB,WAAW2jB,EAAK9kB,OAAS,KAG9C3B,GAAS,KAGNmrC,EAAW,IAAMnrC,EAAQA,EAyFlC,SAAS4qC,EAAWnkB,GAClB,GAAoB,iBAATA,EACT,MAAM,IAAIxU,UAAU,mCAAqCy5B,KAAK7yB,UAAU4N,IA9T5E7mB,EAAQorC,SAMR,SAAkBvkB,EAAMklB,GACtB,IAEIjqC,EACAkqC,EACAC,EACAC,EALA7qC,EAAQ,EACRmB,GAAO,EAMX,QAAYL,IAAR4pC,GAAoC,iBAARA,EAC9B,MAAM,IAAI15B,UAAU,mCAMtB,GAHA24B,EAAWnkB,GACX/kB,EAAQ+kB,EAAK9kB,YAEDI,IAAR4pC,IAAsBA,EAAIhqC,QAAUgqC,EAAIhqC,OAAS8kB,EAAK9kB,OAAQ,CAChE,KAAOD,KACL,GAA+B,KAA3B+kB,EAAK3jB,WAAWpB,IAKhB,GAAImqC,EAAc,CAChB5qC,EAAQS,EAAQ,EAChB,YAEOU,EAAM,IAGjBypC,GAAe,EACfzpC,EAAMV,EAAQ,GAIlB,OAAOU,EAAM,EAAI,GAAKqkB,EAAKxgB,MAAMhF,EAAOmB,GAG1C,GAAIupC,IAAQllB,EACV,MAAO,GAGTmlB,GAAoB,EACpBE,EAAWH,EAAIhqC,OAAS,EAExB,KAAOD,KACL,GAA+B,KAA3B+kB,EAAK3jB,WAAWpB,IAKhB,GAAImqC,EAAc,CAChB5qC,EAAQS,EAAQ,EAChB,YAGAkqC,EAAmB,IAGrBC,GAAe,EACfD,EAAmBlqC,EAAQ,GAGzBoqC,GAAY,IAEVrlB,EAAK3jB,WAAWpB,KAAWiqC,EAAI7oC,WAAWgpC,KACxCA,EAAW,IAGb1pC,EAAMV,IAKRoqC,GAAY,EACZ1pC,EAAMwpC,IAMV3qC,IAAUmB,EACZA,EAAMwpC,EACGxpC,EAAM,IACfA,EAAMqkB,EAAK9kB,QAGb,OAAO8kB,EAAKxgB,MAAMhF,EAAOmB,IA3F3BxC,EAAQmrC,QA8FR,SAAiBtkB,GACf,IAAIrkB,EACA2pC,EACArqC,EAGJ,GAFAkpC,EAAWnkB,IAENA,EAAK9kB,OACR,MAAO,IAGTS,GAAO,EACPV,EAAQ+kB,EAAK9kB,OAEb,OAASD,GACP,GAA+B,KAA3B+kB,EAAK3jB,WAAWpB,IAGhB,GAAIqqC,EAAgB,CAClB3pC,EAAMV,EACN,YAEQqqC,IAEZA,GAAiB,GAIrB,OAAO3pC,EAAM,EAA2B,KAAvBqkB,EAAK3jB,WAAW,GAE/B,IAAM,IAAc,IAARV,GAAoC,KAAvBqkB,EAAK3jB,WAAW,GAEzC,KAAO2jB,EAAKxgB,MAAM,EAAG7D,IA5HzBxC,EAAQqrC,QA+HR,SAAiBxkB,GACf,IAMIslB,EACA5qC,EACAO,EARAsqC,GAAY,EACZC,EAAY,EACZ7pC,GAAO,EAGP8pC,EAAc,EAIlBtB,EAAWnkB,GACX/kB,EAAQ+kB,EAAK9kB,OAEb,KAAOD,KAGL,GAAa,MAFbP,EAAOslB,EAAK3jB,WAAWpB,IAenBU,EAAM,IAGR2pC,GAAiB,EACjB3pC,EAAMV,EAAQ,GAGH,KAATP,EAII6qC,EAAW,EACbA,EAAWtqC,EACc,IAAhBwqC,IACTA,EAAc,GAEPF,GAAY,IAGvBE,GAAe,QA3Bb,GAAIH,EAAgB,CAClBE,EAAYvqC,EAAQ,EACpB,MA6BR,GAAIsqC,EAAW,GAAK5pC,EAAM,GACV,IAAhB8pC,GACgB,IAAhBA,GAAqBF,IAAa5pC,EAAM,GAAK4pC,IAAaC,EAAY,EACpE,MAAO,GAGT,OAAOxlB,EAAKxgB,MAAM+lC,EAAU5pC,IAxL9BxC,EAAQyX,KA2LR,WACE,IACI80B,EADAzqC,GAAS,EAGb,OAASA,EAAQmO,UAAUlO,QACzBipC,EAAW/6B,UAAUnO,IAEjBmO,UAAUnO,KACZyqC,OAAoBpqC,IAAXoqC,EAAuBt8B,UAAUnO,GAASyqC,EAAS,IAAMt8B,UAAUnO,IAIhF,YAAkBK,IAAXoqC,EAAuB,IAAMhmC,EAAUgmC,IAtMhDvsC,EAAQ8qC,IAAM,K,kCCrDdtnC,EAAOxD,QAEP,SAAuBwG,EAAGC,GACxB,OAAOD,EAAEC,EAAM,Q,kCCHjBjD,EAAOxD,QAIP,SAAegF,GACb,IAAIhE,EAAOC,KACXA,KAAKk/B,OAEL,SAAeD,GACb,OAAOsM,EAAatM,EAAKhgC,OAAOG,OAAO,GAAIW,EAAKW,KAAK,YAAaqD,EAAS,CAIzEG,WAAYnE,EAAKW,KAAK,wBAA0B,GAChD8qC,gBAAiBzrC,EAAKW,KAAK,2BAA6B,QAZ9D,IAAI6qC,EAAe,EAAQ,S,kCCF3BhpC,EAAOxD,QAEP,SAAgC+a,EAAYxB,GAC1C,OAAOA,KAAawB,EAAaA,EAAWxB,GAAaA,I,kCCH3DvZ,EAAQsQ,MAMR,SAAelQ,GACb,IAKIwiB,EALAxb,EAAS,GACT2Q,EAAQrD,OAAOtU,GAJT,IAKN0B,EAAQiW,EAAMlO,QAPR,KAQNigC,EAAY,EACZtnC,GAAM,EAGV,MAAQA,IACS,IAAXV,IACFA,EAAQiW,EAAMhW,OACdS,GAAM,KAGRogB,EAAM7K,EAAM1R,MAAMyjC,EAAWhoC,GAAO0f,SAExBhf,GACV4E,EAAOd,KAAKsc,GAGdknB,EAAYhoC,EAAQ,EACpBA,EAAQiW,EAAMlO,QAzBN,IAyBqBigC,GAG/B,OAAO1iC,GA7BTpH,EAAQiZ,UAmCR,SAAmB7R,EAAQpC,GACzB,IAAIwgB,EAAWxgB,GAAW,GACtB+gB,GAA4B,IAArBP,EAASknB,QAlCV,GADA,IAoCN1mB,EAAQR,EAASmnB,SApCX,IACA,QAqCNvlC,EAAOA,EAAOrF,OAAS,KACzBqF,EAASA,EAAOlC,OAtCR,KAyCV,OAAOkC,EAAOqQ,KAAKuO,EA3CT,IA2CyBD,GAAMvE,S,mBCzC3Che,EAAOxD,QAAU,SAAkBiP,GACjC,OAAc,MAAPA,GAAkC,MAAnBA,EAAII,aAA2D,mBAA7BJ,EAAII,YAAYy3B,UAA2B73B,EAAII,YAAYy3B,SAAS73B,K,kCCL9HzL,EAAOxD,QAIP,SAAoBwG,EAAGC,GACrB,IAAIrG,EAAQqG,EAAKrG,MAAMkH,QAAQ,YAAa,KAC5C,OAAOd,EAAEC,EAAM,OAAQ,CAAC8O,EAAE,OAAQnV,MAJpC,IAAImV,EAAI,EAAQ,S,kCCFhB/R,EAAOxD,QAsBP,SAAsBI,EAAOwpC,EAAU5kC,GACb,iBAAb4kC,IACT5kC,EAAU4kC,EACVA,OAAWznC,GAGb,OAIF,SAAkB6C,GAChB,IAAIwgB,EAAWxgB,GAAW,GACtB4nC,EA6sBN,SAAmBA,EAAQznC,GACzB,IAAIrD,GAAS,EAEb,OAASA,EAAQqD,EAAWpD,QAC1BioC,EAAU4C,EAAQznC,EAAWrD,IAG/B,OAAO8qC,EAptBMC,CAAU,CACrBC,WAAY,GACZC,eAAgB,CAAC,WAAY,WAAY,UAAW,YAAa,UACjEtrC,MAAO,CACLkU,SAAUq3B,EAAOrX,GACjBsX,iBAAkBC,EAClBC,cAAeD,EACfE,WAAYJ,EAAOzuB,GACnBsZ,WAAYmV,GAukBhB,WACE,MAAO,CACLzqC,KAAM,aACN4E,SAAU,OAzkBV2wB,gBAAiBoV,EACjB7iC,mBAAoB6iC,EACpBhmB,WAAY8lB,EAAOK,GACnBC,oBAAqBxlC,EACrBylC,oBAAqBzlC,EACrBuc,aAAc2oB,EAAOK,EAAUvlC,GAC/BnE,SAAUqpC,GAglBd,WACE,MAAO,CACLzqC,KAAM,aACNnC,MAAO,MAnlBoB0H,GAC3B0lC,aAAcN,EACdvrC,KAAMurC,EACNO,cAAeP,EACfryB,WAAYmyB,GAmlBhB,WACE,MAAO,CACLzqC,KAAM,aACNkS,WAAY,GACZa,MAAO,KACPxO,MAAO,KACPF,IAAK,OAxlBL8mC,4BAA6B5lC,EAC7B6lC,sBAAuB7lC,EACvB8lC,sBAAuB9lC,EACvB+5B,SAAUmL,GAylBd,WACE,MAAO,CACLzqC,KAAM,WACN4E,SAAU,OA3lBV4wB,gBAAiBiV,EAAOa,GACxBC,kBAAmBd,EAAOa,GAC1BnvB,SAAUsuB,EAAOv8B,EAAM3I,GACvBimC,aAAcb,EACdrlC,SAAUmlC,EAAOv8B,EAAM3I,GACvBkmC,aAAcd,EACdlL,MAAOgL,GA8mBX,WACE,MAAO,CACLzqC,KAAM,QACNuE,MAAO,KACPF,IAAK,GACLC,IAAK,SAlnBLyO,MAAOxN,EACP6tB,KAAMqX,EAAOrX,GACbwM,SAAU6K,GAuoBd,SAAkBjqC,GAChB,MAAO,CACLR,KAAM,WACN+lC,OAAQvlC,EAAMkrC,QACdh2B,QAAS,KACT9Q,SAAU,OA3oBV+mC,cA+TJ,SAA8BnrC,GACxBorC,EAAQ,iCACVltC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAGV,MAAQwW,SAAS5W,KAAKwJ,eAAe1H,GAAQ,IAC/EqrC,EAAQ,iCAjURC,YAAarB,EAAOnrC,GA0TxB,WACEusC,EAAQ,+BAA+B,MA1TrCE,cAAetB,EAAOnrC,GACtBwc,UAAW2uB,GA4oBf,WACE,MAAO,CACLzqC,KAAM,YACN4E,SAAU,OA9oBVonC,UA2fJ,WACEH,EAAQ,gBAAiB,cA3fvBI,gBAAiB1mC,EACjB2mC,0BAA2B3mC,EAC3B4mC,oBAAqB5mC,EACrB6mC,cAAe3B,EAAOzuB,GACtB8jB,OAAQ2K,GA6oBZ,WACE,MAAO,CACLzqC,KAAM,SACN4E,SAAU,OA/oBVI,cAAeylC,GA0pBnB,WACE,MAAO,CACLzqC,KAAM,qBA1pBRX,KAAM,CACJwrC,WAAYwB,IACZC,mBAqWJ,SAAkC9rC,GAC3B9B,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAGsW,QACrCpX,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAGsW,MAAQpX,KAAKwJ,eAAe1H,GAAOhB,SAtWrE4T,SAAUi5B,IACVzB,cAqhBJ,SAA6BpqC,GAC3B+rC,EAAW7sC,KAAKhB,KAAM8B,GACtB9B,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG6E,IAAM,UAAY3F,KAAKwJ,eAAe1H,IAthBtEkqC,iBA+gBJ,SAAgClqC,GAC9B+rC,EAAW7sC,KAAKhB,KAAM8B,GACtB9B,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG6E,IAAM3F,KAAKwJ,eAAe1H,IAhhB1D80B,WAAY+W,IACZG,qBAAsBD,EACtBE,oCAAqCC,EACrCC,gCAAiCD,EACjCE,wBAwfJ,SAAuCpsC,GACrC,IAEI3C,EACA8U,EAHAvT,EAAOV,KAAKwJ,eAAe1H,GAC3BR,EAAO4rC,EAAQ,0BAIf5rC,GACFnC,EAAQgvC,EAAYztC,EAAe,oCAATY,EAA6C,GAAK,IAC5E6rC,EAAQ,2BAERhuC,EAAQivC,EAAO1tC,IAGjBuT,EAAOjU,KAAKsL,MAAMI,OACbvM,OAASA,EACd8U,EAAK1Q,SAAShC,IAAMiB,EAAMV,EAAMP,MAtgB9B0kB,WAAY0nB,GAgUhB,WACE,IAAIjtC,EAAOV,KAAKquC,SAChBruC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG3B,MAAQuB,EAAK2F,QAAQ,2BAA4B,IACnF8mC,EAAQ,qBAlUNmB,gBAwTJ,WAEE,GAAIpB,EAAQ,kBAAmB,OAC/BltC,KAAK6G,SACLsmC,EAAQ,kBAAkB,IA3TxBd,oBA6SJ,WACE,IAAI3rC,EAAOV,KAAKquC,SAChBruC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAGkqB,KAAOtqB,GA9SvC4rC,oBAiTJ,WACE,IAAI5rC,EAAOV,KAAKquC,SAChBruC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG0lB,KAAO9lB,GAlTvC8rC,cAAeqB,EACfzqB,aAAcuqB,GAiUlB,WACE,IAAIjtC,EAAOV,KAAKquC,SAChBruC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG3B,MAAQuB,KAlUxCgC,SAAUirC,GA2Zd,WACE,IAAIjtC,EAAOV,KAAKquC,SAChBruC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG3B,MAAQuB,KA5ZxC6rC,aAAcsB,EACdntC,KAAMmtC,EACNj0B,WAAY+zB,IACZlB,4BA6UJ,WACE,IAAI/rC,EAAOV,KAAKquC,SAChBruC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG6E,IAAMjF,GA9UtCgsC,sBAgUJ,SAAqC5qC,GAEnC,IAAIuS,EAAQrU,KAAKquC,SACjBruC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAGuT,MAAQA,EAC1CrU,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG0S,WAAaiJ,EAAoBzc,KAAKwJ,eAAe1H,IAAQ8W,eAnU7F+zB,sBAsUJ,WACE,IAAIjsC,EAAOV,KAAKquC,SAChBruC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG+E,MAAQnF,GAvUxCkgC,SAAU+M,IACV7W,gBAAiB6W,EAAOY,GACxB1B,kBAAmBc,EAAOY,GAC1B9wB,SAAUkwB,GAuYd,WACE,IAAIjtC,EAAOV,KAAKquC,SAChBruC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG3B,MAAQuB,KAxYxCosC,aAAce,EACdjnC,SAAU+mC,GA0Yd,WACE,IAAIjtC,EAAOV,KAAKquC,SAChBruC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG3B,MAAQuB,KA3YxCqsC,aAAcc,EACd9M,MAAO4M,GAmaX,WACE,IAAItsC,EAAUrB,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAEzCosC,EAAQ,gBACV7rC,EAAQC,MAAQ,YAChBD,EAAQ8S,cAAgB+4B,EAAQ,kBAAoB,kBAC7C7rC,EAAQsE,WACRtE,EAAQwE,eAERxE,EAAQmS,kBACRnS,EAAQgT,aACRhT,EAAQ8S,eAGjBg5B,EAAQ,oBAhbN94B,MAubJ,WACE,IAAIm6B,EAAWxuC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAC1C3B,EAAQa,KAAKquC,SACjBruC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAGuT,MAAQlV,EAE1CguC,EAAQ,eAAe,GAEwB,SAA3CntC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAGQ,KACpCtB,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAGoF,SAAWsoC,EAAStoC,SAEtDlG,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG8E,IAAMzG,GAhcxCsvC,UAkbJ,SAAyB3sC,GACvB9B,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG0S,WAAaiJ,EAAoBzc,KAAKwJ,eAAe1H,IAAQ8W,eAlb7Fme,WA6WJ,SAA0Bj1B,GACxB,IAAIT,EAAUrB,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAE7C,GAAIosC,EAAQ,eAGV,OAFA7rC,EAAQ6E,SAAS7E,EAAQ6E,SAASpF,OAAS,GAAGyC,SAAShC,IAAMiB,EAAMV,EAAMP,UACzE4rC,EAAQ,gBAILD,EAAQ,iCAAmCvB,EAAOG,eAAeljC,QAAQvH,EAAQC,OAAS,IAC7F2qC,EAAYjrC,KAAKhB,KAAM8B,GACvB+rC,EAAW7sC,KAAKhB,KAAM8B,KAvXtB4yB,KAAMiZ,GA8YV,WACE,IAAItsC,EAAUrB,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAEzCosC,EAAQ,gBACV7rC,EAAQC,MAAQ,YAChBD,EAAQ8S,cAAgB+4B,EAAQ,kBAAoB,kBAC7C7rC,EAAQsE,WACRtE,EAAQwE,eAERxE,EAAQmS,kBACRnS,EAAQgT,aACRhT,EAAQ8S,eAGjBg5B,EAAQ,oBA3ZNjM,SAAUyM,IACVP,YAAaO,IACbN,cAAeM,IACfvwB,UAAWuwB,IACXJ,gBA+cJ,SAA+BzrC,GAC7B,IAAIuS,EAAQrU,KAAKquC,SACjBruC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAGuT,MAAQA,EAC1CrU,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG0S,WAAaiJ,EAAoBzc,KAAKwJ,eAAe1H,IAAQ8W,cAC/Fu0B,EAAQ,gBAAiB,SAldvBK,0BA4bJ,WACE,IAAI9sC,EAAOV,KAAKquC,SAChBruC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG6E,IAAMjF,GA7btC+sC,oBAgcJ,WACE,IAAI/sC,EAAOV,KAAKquC,SAChBruC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAG+E,MAAQnF,GAjcxCguC,SAocJ,WACEvB,EAAQ,gBApcNO,cAAeC,GAyUnB,WACER,EAAQ,mCAzUNwB,0BAoUJ,SAAyC7sC,GACvC9B,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAGsW,MAAqD,KAA7CpX,KAAKwJ,eAAe1H,GAAOG,WAAW,GAAY,EAAI,GApU9F2sC,kBA+TJ,WACEzB,EAAQ,gCAAgC,IA/TtC/L,OAAQuM,IACRrnC,cAAeqnC,MAEhBppB,EAASinB,iBAAmB,IAC3B9qC,EAAO,GACX,OAEA,SAAiBU,GACf,IAQIytC,EACAC,EATAl0B,EAAO,CACTtZ,KAAM,OACN4E,SAAU,IAGR6oC,EAAa,GACbC,EAAY,GACZnuC,GAAS,EAGTQ,EAAU,CACZiK,MAPU,CAACsP,GAQXm0B,WAAYA,EACZpD,OAAQA,EACRnrC,MAAOA,EACPG,KAAMA,EACNkG,OAAQA,EACRwnC,OAAQA,EACRlB,QAASA,EACTD,QAASA,GAGX,OAASrsC,EAAQO,EAAON,QAGQ,gBAA1BM,EAAOP,GAAO,GAAGS,MAAoD,kBAA1BF,EAAOP,GAAO,GAAGS,OACrC,UAArBF,EAAOP,GAAO,GAChBmuC,EAAU3pC,KAAKxE,IAEfiuC,EAAYE,EAAUtjC,IAAI7K,GAC1BA,EAAQouC,EAAY7tC,EAAQ0tC,EAAWjuC,KAK7CA,GAAS,EAET,OAASA,EAAQO,EAAON,QACtB+tC,EAAUlD,EAAOvqC,EAAOP,GAAO,IAE3BwC,EAAIrC,KAAK6tC,EAASztC,EAAOP,GAAO,GAAGS,OACrCutC,EAAQztC,EAAOP,GAAO,GAAGS,MAAMN,KAAK5B,EAAO,CACzCoK,eAAgBpI,EAAOP,GAAO,GAAG2I,gBAChCnI,GAAUD,EAAOP,GAAO,IAI/B,GAAIkuC,EAAWjuC,OACb,MAAM,IAAI2Z,MAAM,oCAAsCs0B,EAAWA,EAAWjuC,OAAS,GAAGQ,KAAO,MAAQ4tC,EAAkB,CACvH9uC,MAAO2uC,EAAWA,EAAWjuC,OAAS,GAAGV,MACzCmB,IAAKwtC,EAAWA,EAAWjuC,OAAS,GAAGS,MACpC,mBAIPqZ,EAAKrX,SAAW,CACdnD,MAAOoC,EAAMpB,EAAON,OAASM,EAAO,GAAG,GAAGhB,MAAQ,CAChD8B,KAAM,EACNC,OAAQ,EACRC,OAAQ,IAEVb,IAAKiB,EAAMpB,EAAON,OAASM,EAAOA,EAAON,OAAS,GAAG,GAAGS,IAAM,CAC5DW,KAAM,EACNC,OAAQ,EACRC,OAAQ,KAGZvB,GAAS,EAET,OAASA,EAAQ8qC,EAAOE,WAAW/qC,QACjC8Z,EAAO+wB,EAAOE,WAAWhrC,GAAO+Z,IAASA,EAG3C,OAAOA,GAGT,SAASq0B,EAAY7tC,EAAQhB,EAAOU,GAYlC,IAXA,IAGIogC,EACAiO,EACArsB,EACAssB,EACAvsB,EACAwsB,EACAplC,EATApJ,EAAQT,EAAQ,EAChBkvC,GAAoB,EACpBC,GAAa,IASR1uC,GAASC,GAwBhB,GArBsB,mBAFtB+hB,EAAQzhB,EAAOP,IAEL,GAAGS,MAA8C,gBAAlBuhB,EAAM,GAAGvhB,MAA4C,eAAlBuhB,EAAM,GAAGvhB,MAClE,UAAbuhB,EAAM,GACRysB,IAEAA,IAGFrlC,OAAW/I,GACgB,oBAAlB2hB,EAAM,GAAGvhB,KACD,UAAbuhB,EAAM,MACJqe,GAAaj3B,GAAaqlC,GAAqBD,IACjDA,EAAsBxuC,GAGxBoJ,OAAW/I,GAEc,eAAlB2hB,EAAM,GAAGvhB,MAA2C,kBAAlBuhB,EAAM,GAAGvhB,MAA8C,mBAAlBuhB,EAAM,GAAGvhB,MAA+C,mBAAlBuhB,EAAM,GAAGvhB,MAA+C,6BAAlBuhB,EAAM,GAAGvhB,OAErK2I,OAAW/I,IAGRouC,GAAiC,UAAbzsB,EAAM,IAAoC,mBAAlBA,EAAM,GAAGvhB,OAAmD,IAAtBguC,GAAwC,SAAbzsB,EAAM,KAAoC,kBAAlBA,EAAM,GAAGvhB,MAA8C,gBAAlBuhB,EAAM,GAAGvhB,MAAyB,CAC/M,GAAI4/B,EAAU,CAIZ,IAHAiO,EAAYtuC,EACZiiB,OAAY5hB,EAELiuC,KAGL,GAA0B,gBAF1BC,EAAYhuC,EAAO+tC,IAEL,GAAG7tC,MAA+C,oBAAtB8tC,EAAU,GAAG9tC,KAA4B,CACjF,GAAqB,SAAjB8tC,EAAU,GAAe,SAEzBtsB,IACF1hB,EAAO0hB,GAAW,GAAGxhB,KAAO,kBAC5BiuC,GAAa,GAGfH,EAAU,GAAG9tC,KAAO,aACpBwhB,EAAYqsB,OACP,GAA0B,eAAtBC,EAAU,GAAG9tC,MAA+C,qBAAtB8tC,EAAU,GAAG9tC,MAAqD,+BAAtB8tC,EAAU,GAAG9tC,MAA+D,qBAAtB8tC,EAAU,GAAG9tC,MAAqD,mBAAtB8tC,EAAU,GAAG9tC,KAE1M,MAIA+tC,KAAyBvsB,GAAausB,EAAsBvsB,KAC9Doe,EAAS8L,SAAU,GAIrB9L,EAAS3/B,IAAMiB,EAAMsgB,EAAY1hB,EAAO0hB,GAAW,GAAG1iB,MAAQyiB,EAAM,GAAGthB,KACvEH,EAAOI,OAAOshB,GAAajiB,EAAO,EAAG,CAAC,OAAQqgC,EAAUre,EAAM,KAC9DhiB,IACAC,IAIoB,mBAAlB+hB,EAAM,GAAGvhB,OACX4/B,EAAW,CACT5/B,KAAM,WACN0rC,SAAS,EACT5sC,MAAOoC,EAAMqgB,EAAM,GAAGziB,QAExBgB,EAAOI,OAAOX,EAAO,EAAG,CAAC,QAASqgC,EAAUre,EAAM,KAClDhiB,IACAC,IACAuuC,OAAsBnuC,EACtB+I,GAAW,GAMjB,OADA7I,EAAOhB,GAAO,GAAG4sC,QAAUuC,EACpBzuC,EAGT,SAASqsC,EAAQl/B,EAAK9O,GACpBuB,EAAKuN,GAAO9O,EAGd,SAAS+tC,EAAQj/B,GACf,OAAOvN,EAAKuN,GAGd,SAASzL,EAAMiV,GACb,MAAO,CACLvV,KAAMuV,EAAEvV,KACRC,OAAQsV,EAAEtV,OACVC,OAAQqV,EAAErV,QAId,SAAS2pC,EAAO5nC,EAAQqrC,GACtB,OAEA,SAAc1tC,GACZtB,EAAMQ,KAAKhB,KAAMmE,EAAOrC,GAAQA,GAC5B0tC,GAAKA,EAAIxuC,KAAKhB,KAAM8B,IAI5B,SAAS+E,IACP7G,KAAKsL,MAAMjG,KAAK,CACd/D,KAAM,WACN4E,SAAU,KAId,SAAS1F,EAAMgF,EAAM1D,GAOnB,OANA9B,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAGoF,SAASb,KAAKG,GAChDxF,KAAKsL,MAAMjG,KAAKG,GAChBxF,KAAK+uC,WAAW1pC,KAAKvD,GACrB0D,EAAKjC,SAAW,CACdnD,MAAOoC,EAAMV,EAAM1B,QAEdoF,EAGT,SAASmoC,EAAO6B,GACd,OAEA,SAAe1tC,GACT0tC,GAAKA,EAAIxuC,KAAKhB,KAAM8B,GACxBnB,EAAKK,KAAKhB,KAAM8B,IAIpB,SAASnB,EAAKmB,GACZ,IAAI0D,EAAOxF,KAAKsL,MAAMI,MAClB3E,EAAO/G,KAAK+uC,WAAWrjC,MAE3B,IAAK3E,EACH,MAAM,IAAI0T,MAAM,iBAAmB3Y,EAAMR,KAAO,MAAQ4tC,EAAkB,CACxE9uC,MAAO0B,EAAM1B,MACbmB,IAAKO,EAAMP,MACR,oBACA,GAAIwF,EAAKzF,OAASQ,EAAMR,KAC7B,MAAM,IAAImZ,MAAM,iBAAmB3Y,EAAMR,KAAO,MAAQ4tC,EAAkB,CACxE9uC,MAAO0B,EAAM1B,MACbmB,IAAKO,EAAMP,MACR,0BAA4BwF,EAAKzF,KAAO,MAAQ4tC,EAAkB,CACrE9uC,MAAO2G,EAAK3G,MACZmB,IAAKwF,EAAKxF,MACP,aAIP,OADAiE,EAAKjC,SAAShC,IAAMiB,EAAMV,EAAMP,KACzBiE,EAGT,SAAS6oC,IACP,OAAO3gC,EAAS1N,KAAKsL,MAAMI,OAgF7B,SAASugC,EAAYnqC,GACnB,IAAI2tC,EAAWzvC,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAGoF,SAC7C+N,EAAOw7B,EAASA,EAAS3uC,OAAS,GAEjCmT,GAAsB,SAAdA,EAAK3S,QAEhB2S,EAmRK,CACL3S,KAAM,OACNnC,MAAO,KApRFoE,SAAW,CACdnD,MAAOoC,EAAMV,EAAM1B,QAErBJ,KAAKsL,MAAMtL,KAAKsL,MAAMxK,OAAS,GAAGoF,SAASb,KAAK4O,IAGlDjU,KAAKsL,MAAMjG,KAAK4O,GAGlB,SAAS45B,EAAW/rC,GAClB,IAAImS,EAAOjU,KAAKsL,MAAMI,MACtBuI,EAAK9U,OAASa,KAAKwJ,eAAe1H,GAClCmS,EAAK1Q,SAAShC,IAAMiB,EAAMV,EAAMP,KAkBlC,SAASgtC,IACPpB,EAAQ,eAAe,GA+FzB,SAASa,EAA+BlsC,GACtCqrC,EAAQ,yBAA0BrrC,EAAMR,MAyC1C,SAAS8qC,IACP,MAAO,CACL9qC,KAAM,OACN0pB,KAAM,KACNxE,KAAM,KACNrnB,MAAO,IA4BX,SAASme,IACP,MAAO,CACLhc,KAAM,UACN8V,WAAOlW,EACPgF,SAAU,IAId,SAAS0mC,IACP,MAAO,CACLtrC,KAAM,SAIV,SAASkO,IACP,MAAO,CACLlO,KAAM,OACNnC,MAAO,IAaX,SAASu1B,IACP,MAAO,CACLpzB,KAAM,OACNuE,MAAO,KACPF,IAAK,GACLO,SAAU,IAId,SAAStF,EAAKkB,GACZ,MAAO,CACLR,KAAM,OACN6V,QAAwB,gBAAfrV,EAAMR,KACflB,MAAO,KACPinC,OAAQvlC,EAAMkrC,QACd9mC,SAAU,KA1qBPwpC,CAAS3rC,EAAT2rC,CAAkBC,EAAYzvC,EAAO6D,GAASL,WAAWwI,MAAM0jC,IAAezwC,EAAOwpC,GAAU,OA1BxG,IAAIj7B,EAAW,EAAQ,QAEnBtO,EAAS,EAAQ,QAEjBiE,EAAM,EAAQ,QAEdoZ,EAAsB,EAAQ,QAE9B0xB,EAAc,EAAQ,QAEtBjuC,EAAS,EAAQ,QAEjB0vC,EAAe,EAAQ,QAEvBD,EAAc,EAAQ,QAEtBvB,EAAS,EAAQ,QAEjBc,EAAoB,EAAQ,QAquBhC,SAASnG,EAAU4C,EAAQ5C,GACzB,IAAI96B,EACA6W,EAEJ,IAAK7W,KAAO86B,EACVjkB,EAAOzhB,EAAIrC,KAAK2qC,EAAQ19B,GAAO09B,EAAO19B,GAAO09B,EAAO19B,GAAO,GAE/C,mBAARA,GAAoC,eAARA,EAC9B09B,EAAO19B,GAAO,GAAGhK,OAAO6gB,EAAMikB,EAAU96B,IAExChP,OAAOG,OAAO0lB,EAAMikB,EAAU96B,M,kCCnwBpC,IAAI4hC,EAAc,GAwClB,SAASC,EAAOtwC,EAAQuwC,EAASC,GAC/B,IAAI/gC,EACAuqB,EACAl5B,EACA2vC,EACAtwB,EACA5Z,EAAS,GAcb,IAZuB,iBAAZgqC,IAETC,EAAcD,EACdA,EAAUD,EAAOI,mBAGQ,IAAhBF,IACTA,GAAc,GAGhBrwB,EAtDF,SAAwBowB,GACtB,IAAI9gC,EACAkhC,EACAxwB,EAAQkwB,EAAYE,GAExB,GAAIpwB,EACF,OAAOA,EAKT,IAFAA,EAAQkwB,EAAYE,GAAW,GAE1B9gC,EAAI,EAAGA,EAAI,IAAKA,IACnBkhC,EAAK18B,OAAOiH,aAAazL,GAErB,cAAc3F,KAAK6mC,GAErBxwB,EAAMta,KAAK8qC,GAEXxwB,EAAMta,KAAK,KAAO,IAAM4J,EAAEvB,SAAS,IAAI8K,eAAepT,OAAO,IAIjE,IAAK6J,EAAI,EAAGA,EAAI8gC,EAAQjvC,OAAQmO,IAC9B0Q,EAAMowB,EAAQ9tC,WAAWgN,IAAM8gC,EAAQ9gC,GAGzC,OAAO0Q,EA4BCywB,CAAeL,GAElB9gC,EAAI,EAAGuqB,EAAIh6B,EAAOsB,OAAQmO,EAAIuqB,EAAGvqB,IAGpC,GAFA3O,EAAOd,EAAOyC,WAAWgN,GAErB+gC,GAAwB,KAAT1vC,GAEhB2O,EAAI,EAAIuqB,GACL,iBAAiBlwB,KAAK9J,EAAO4F,MAAM6J,EAAI,EAAGA,EAAI,IAChDlJ,GAAUvG,EAAO4F,MAAM6J,EAAGA,EAAI,GAC9BA,GAAK,OAKT,GAAI3O,EAAO,IACTyF,GAAU4Z,EAAMrf,QAIlB,GAAIA,GAAQ,OAAUA,GAAQ,MAA9B,CACE,GAAIA,GAAQ,OAAUA,GAAQ,OAAU2O,EAAI,EAAIuqB,IAC9CyW,EAAWzwC,EAAOyC,WAAWgN,EAAI,KAEjB,OAAUghC,GAAY,MAAQ,CAC5ClqC,GAAUsqC,mBAAmB7wC,EAAOyP,GAAKzP,EAAOyP,EAAI,IACpDA,IACA,SAIJlJ,GAAU,iBAIZA,GAAUsqC,mBAAmB7wC,EAAOyP,IAGtC,OAAOlJ,EAGT+pC,EAAOI,aAAe,uBACtBJ,EAAOQ,eAAiB,YACxB/tC,EAAOxD,QAAU+wC,G,kCCrGjB,IAAIvzB,EAAO,EAAQ,QAEnBha,EAAOxD,QAAUo/B,EACjBA,EAAO5hB,KAAOA,EACd,IAAInX,EAAQ,GAAGA,MAEf,SAAS+4B,IACP,IAAIoS,EAAM,GACNC,EAAa,CACjB,IAIA,WACE,IAAI3vC,GAAS,EACTiW,EAAQ1R,EAAMpE,KAAKgO,UAAW,GAAI,GAClCqL,EAAOrL,UAAUA,UAAUlO,OAAS,GAExC,GAAoB,mBAATuZ,EACT,MAAM,IAAII,MAAM,2CAA6CJ,GAK/D,SAAS1V,EAAK2X,GACZ,IAAIrC,EAAKs2B,IAAM1vC,GACXuZ,EAAShV,EAAMpE,KAAKgO,UAAW,GAC/B7I,EAASiU,EAAOhV,MAAM,GACtBtE,EAASgW,EAAMhW,OACf0C,GAAO,EAEX,GAAI8Y,EACFjC,EAAKiC,OADP,CAMA,OAAS9Y,EAAM1C,GACO,OAAhBqF,EAAO3C,SAAiCtC,IAAhBiF,EAAO3C,KACjC2C,EAAO3C,GAAOsT,EAAMtT,IAIxBsT,EAAQ3Q,EAEJ8T,EACFsC,EAAKtC,EAAItV,GAAM2V,MAAM,KAAMxD,GAE3BuD,EAAKC,MAAM,KAAM,CAAC,MAAMrW,OAAO6S,KA1BnCnS,EAAK2V,MAAM,KAAM,CAAC,MAAMrW,OAAO6S,KAZjC,IA4CA,SAAamD,GACX,GAAkB,mBAAPA,EACT,MAAM,IAAIQ,MAAM,uCAAyCR,GAI3D,OADAs2B,EAAIlrC,KAAK4U,GACFu2B,IAjDT,OAAOA,I,kCCXT,IAAIC,EAAyB,EAAQ,QAErCluC,EAAOxD,QAEP,SAAkC+a,EAAY9D,GAC5C,OAAOy6B,EAAuB32B,EAAY9D,EAAS4C,iB,kCCLrD,IAAIhU,EAAgB,EAAQ,QA2B5BrC,EAAOxD,QAzBP,SAAsBe,EAAS8C,EAAItB,EAAM+H,GACvC,IAAIu+B,EAAQv+B,EAAMA,EAAM,EAAI22B,IACxBp+B,EAAO,EACX,OAEA,SAAetB,GACb,GAAIsE,EAActE,GAEhB,OADAR,EAAQU,MAAMc,GACPg1B,EAAOh2B,GAGhB,OAAOsC,EAAGtC,IAGZ,SAASg2B,EAAOh2B,GACd,OAAIsE,EAActE,IAASsB,IAASgmC,GAClC9nC,EAAQW,QAAQH,GACTg2B,IAGTx2B,EAAQa,KAAKW,GACNsB,EAAGtC,O,kCCvBdiC,EAAOxD,QAMP,SAAoBwG,EAAGC,GACrB,OAAOD,EAAEC,EAAM,aAAc+W,EAAKhI,EAAIhP,EAAGC,IAAO,KALlD,IAAI+W,EAAO,EAAQ,QAEfhI,EAAM,EAAQ,S,kCCJlB,IAAIm8B,EAAQ,EAAQ,QAEhBh3B,EAAS,EAAQ,QAErBnX,EAAOxD,QAEP,SAAe2lB,GACb,IAII7Y,EACAsK,EALArV,EAAS4jB,EAAY5jB,OACrBkV,EAAW,GACXgE,EAAS,GACTnZ,GAAS,EAIb,OAASA,EAAQC,GACf+K,EAAO6Y,EAAY7jB,GACnBmV,EAAS3Q,KAAKwG,EAAKmK,UACnBgE,EAAO3U,KAAKwG,EAAKmO,QACjB7D,EAAQtK,EAAKsK,MAGf,OAAO,IAAIuD,EAAOg3B,EAAMp2B,MAAM,KAAMtE,GAAW06B,EAAMp2B,MAAM,KAAMN,GAAS7D,K,kCCrB5E,IAAI4Q,EAAQ,EAAQ,QAEhB5iB,EAAS,EAAQ,QAEjBssC,EAAyB,EAAQ,QAEjCz0B,EAAU+K,EAAM/K,QAChBG,EAAS4K,EAAM5K,OACfC,EAAiB2K,EAAM3K,eACvBrE,EAAiBgP,EAAMhP,eACvBsE,EAAwB0K,EAAM1K,sBAClC9Z,EAAOxD,QAAUoF,EAAO,CACtBgS,MAAO,MACP2D,WAAY,CACV62B,aAAc,gBACdC,kBAAmB,qBACnBC,WAAY,cACZC,cAAe,iBACfC,UAAW,aACXt/B,UAAW,QACXu/B,SAAU,YACVC,SAAU,YACVC,mBAAoB,sBACpBC,0BAA2B,8BAC3BC,aAAc,gBACdC,eAAgB,kBAChBxoB,YAAa,cACbyoB,SAAU,WACVC,iBAAkB,oBAClBC,iBAAkB,oBAClBC,YAAa,eACbC,SAAU,YACVC,WAAY,cACZC,aAAc,gBACdC,WAAY,cACZC,SAAU,YACVC,eAAgB,mBAChBC,YAAa,eACbC,UAAW,aACXC,YAAa,eACbC,WAAY,cACZC,UAAW,aACXC,2BAA4B,+BAC5BC,yBAA0B,6BAC1BpoB,SAAU,WACVqoB,UAAW,cACXC,aAAc,iBACdC,aAAc,iBACdC,eAAgB,kBAChBC,cAAe,iBACfC,cAAe,iBACfC,UAAW,aACXC,UAAW,aACXC,YAAa,eACbC,QAAS,WACTC,YAAa,gBACbC,aAAc,iBACdC,QAAS,WACTC,QAAS,WACTC,QAAS,WACTC,SAAU,YACVC,MAAO,SACPC,UAAW,cACXC,WAAY,eACZ1nB,QAAS,UACT2nB,WAAY,aACZ1nB,aAAc,eACdE,cAAe,gBACfynB,QAAS,UACTtnB,SAAU,WACVC,UAAW,YACXC,iBAAkB,mBAClBC,SAAU,WACVC,QAAS,UACTC,QAAS,UACTE,OAAQ,SACRC,YAAa,cACbC,MAAO,QACPC,WAAY,aACZC,OAAQ,SACRC,UAAW,YACXC,YAAa,cACbC,WAAY,aACZC,YAAa,cACbC,WAAY,aACZC,YAAa,cACbC,OAAQ,SACRC,iBAAkB,mBAClBC,UAAW,YACXmmB,MAAO,QACPlmB,QAAS,UACTC,QAAS,UACTC,QAAS,UACTimB,UAAW,YACXC,WAAY,aACZhmB,aAAc,eACdC,QAAS,UACTC,UAAW,YACXC,UAAW,YACXC,WAAY,aACZC,QAAS,UACTE,OAAQ,SACRC,aAAc,eACdC,iBAAkB,mBAClBE,YAAa,cACbC,UAAW,YACXE,YAAa,cACbC,aAAc,eACdC,aAAc,eACdC,YAAa,cACbC,WAAY,aACZC,YAAa,cACbC,UAAW,YACX6kB,aAAc,eACd5kB,UAAW,YACXC,SAAU,WACVC,WAAY,aACZC,WAAY,aACZC,QAAS,UACTC,QAAS,UACTC,OAAQ,SACRC,UAAW,YACXC,WAAY,aACZC,WAAY,aACZC,aAAc,eACdmkB,SAAU,WACVjkB,QAAS,UACTC,SAAU,WACVC,SAAU,WACVE,SAAU,WACVC,UAAW,YACXC,SAAU,WACV4jB,OAAQ,SACR1jB,UAAW,YACXC,UAAW,YACXC,SAAU,WACVC,UAAW,YACXC,aAAc,eACdC,SAAU,WACVE,SAAU,WACVC,eAAgB,iBAChBC,UAAW,YACXkjB,OAAQ,SACRC,iBAAkB,oBAClBC,kBAAmB,qBACnBC,WAAY,cACZC,QAAS,WACTC,cAAe,iBACf7iB,eAAgB,iBAChB8iB,gBAAiB,mBACjBC,eAAgB,kBAChBC,UAAW,aACXC,YAAa,eACbC,sBAAuB,yBACvBC,uBAAwB,0BACxBC,gBAAiB,mBACjBC,iBAAkB,oBAClBC,cAAe,iBACfC,eAAgB,kBAChBC,iBAAkB,oBAClBC,cAAe,iBACfC,YAAa,eACbviB,SAAU,WACVwiB,WAAY,cACZC,eAAgB,kBAChBC,cAAe,iBACfjZ,OAAQ,SACRkZ,kBAAmB,qBACnBC,mBAAoB,sBACpBC,YAAa,eACbC,aAAc,gBACdC,WAAY,eACZC,YAAa,eACbC,SAAU,YACVC,aAAc,gBACdC,cAAe,iBACfC,aAAc,gBACdC,SAAU,aACVC,YAAa,gBACbC,YAAa,gBACbC,YAAa,eACbC,YAAa,eACbC,QAAS,WAETC,cAAe,gBACfC,cAAe,iBAEjB18B,UAAW02B,EACXv6B,WAAY,CACVwgC,MAAOr6B,EACPs0B,aAAcx0B,EACdw6B,WAAY,KACZC,SAAU,KACVhG,kBAAmB,KACnBiG,WAAY16B,EACZ26B,UAAW36B,EACX00B,WAAY,KACZkG,OAAQ56B,EACR66B,cAAe,KACfC,cAAe,KACfC,QAAS/6B,EACTg7B,UAAW,KACXrG,cAAe,KACfsG,cAAe,KACfC,YAAa,KACbC,KAAM,KACNC,MAAO,KACPC,KAAMr7B,EACNs7B,GAAI,KACJC,SAAU,KACV3G,UAAW50B,EACX1K,UAAW2K,EACXu7B,KAAM,KACN3G,SAAU,KACV4G,cAAe,KACf3G,SAAU,KACV/c,MAAO,KACPgd,mBAAoB,KACpBC,0BAA2B,KAC3BC,aAAc,KACdC,eAAgB,KAChB5tC,QAAS,KACTo0C,kBAAmB,KACnBC,iBAAkB,KAClBjvB,YAAa,KACbkvB,OAAQ,KACRC,GAAI,KACJC,GAAI,KACJxgC,EAAG,KACH65B,SAAU,KACV4G,cAAe,KACfC,QAASh8B,EACTi8B,gBAAiBj8B,EACjBk8B,UAAW,KACXC,QAAS,KACTC,IAAK,KACLC,QAASr8B,EACTo1B,iBAAkB,KAClBnoB,SAAUpN,EACVy8B,GAAI,KACJC,GAAI,KACJC,SAAU,KACVC,SAAU,KACVC,UAAW18B,EACXq1B,iBAAkB,KAClBjwC,IAAK,KACLshB,MAAO,KACPi2B,SAAU38B,EACV48B,0BAA2B,KAC3BC,KAAM,KACNvH,YAAat1B,EACbu1B,SAAU,KACVjiC,OAAQ,KACRwpC,UAAW,KACXC,YAAa,KACbvH,WAAY,KACZC,aAAc,KACduH,UAAW,KACXC,eAAgB,KAChBvH,WAAY,KACZC,SAAU,KACVC,eAAgB,KAChBC,YAAa,KACbC,UAAW,KACXC,YAAa,KACbC,WAAY,KACZkH,OAAQ,KACRC,GAAI,KACJj1C,KAAM,KACNk1C,GAAI,KACJC,GAAI,KACJC,GAAI1hC,EACJ2hC,GAAI3hC,EACJq6B,UAAWr6B,EACXs6B,2BAA4B,KAC5BC,yBAA0B,KAC1BqH,SAAU,KACVC,kBAAmB,KACnBC,cAAe,KACfhL,QAAS,KACTiL,QAAS39B,EACT49B,kBAAmB,KACnBC,WAAY,KACZjwB,OAAQ,KACRtT,KAAM,KACNyT,SAAU,KACVqoB,UAAWp2B,EACXq2B,aAAcr2B,EACds2B,aAAct2B,EACdlM,GAAI,KACJgqC,YAAa99B,EACbu2B,eAAgB,KAChBwH,kBAAmB,KACnBC,GAAI,KACJC,IAAK,KACLC,UAAWl+B,EACXjE,EAAGiE,EACHm+B,GAAIn+B,EACJo+B,GAAIp+B,EACJq+B,GAAIr+B,EACJs+B,GAAIt+B,EACJu+B,aAAcr+B,EACds+B,iBAAkB,KAClBC,UAAW,KAEXC,WAAY,KAEZC,SAAU,KAEVC,QAAS,KACT/vB,KAAM,KACNgwB,aAAc,KACdrI,cAAe,KACfC,cAAe,KACfqI,kBAAmB9+B,EACnB++B,MAAO,KACPrI,UAAW,KACXC,UAAW,KACXC,YAAa,KACboI,aAAc,KACdC,YAAa,KACbC,YAAa,KACblS,KAAM,KACNmS,iBAAkB,KAClBC,UAAW,KACXC,aAAc,KACdnyC,IAAK,KACL4a,MAAO,KACPw3B,uBAAwB,KACxBC,sBAAuB,KACvBC,UAAWx/B,EACXy/B,UAAW,KACXrwB,OAAQ,KACRC,IAAK,KACLqwB,KAAM,KACNl5C,KAAM,KACNqwC,QAAS,KACTC,YAAa,KACbC,aAAc,KACdC,QAAS,KACTC,QAAS,KACTC,QAAS,KACTC,SAAU,KACVC,MAAO,KACPC,UAAW,KACXC,WAAY,KACZqI,WAAY,KACZC,SAAU,KACV35C,OAAQ,KACR2pB,QAAS,KACT2nB,WAAY,KACZ1nB,aAAc,KACdE,cAAe,KACfynB,QAAS,KACTtnB,SAAU,KACVC,UAAW,KACXC,iBAAkB,KAClBC,SAAU,KACVC,QAAS,KACTC,QAAS,KACTE,OAAQ,KACRC,YAAa,KACbC,MAAO,KACPC,WAAY,KACZC,OAAQ,KACRC,UAAW,KACXC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,OAAQ,KACRC,iBAAkB,KAClBC,UAAW,KACXmmB,MAAO,KACPlmB,QAAS,KACTC,QAAS,KACTC,QAAS,KACTimB,UAAW,KACXC,WAAY,KACZhmB,aAAc,KACdC,QAAS,KACTC,UAAW,KACXC,UAAW,KACXC,WAAY,KACZC,QAAS,KACTE,OAAQ,KACRC,aAAc,KACdC,iBAAkB,KAClBE,YAAa,KACbC,UAAW,KACXE,YAAa,KACbC,aAAc,KACdC,aAAc,KACdC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,UAAW,KACX6kB,aAAc,KACd5kB,UAAW,KACXC,SAAU,KACVC,WAAY,KACZC,WAAY,KACZC,QAAS,KACTC,QAAS,KACTC,OAAQ,KACRC,UAAW,KACXC,WAAY,KACZC,WAAY,KACZC,aAAc,KACdmkB,SAAU,KACVjkB,QAAS,KACTC,SAAU,KACVC,SAAU,KACVE,SAAU,KACVC,UAAW,KACXC,SAAU,KACV4jB,OAAQ,KACR1jB,UAAW,KACXC,UAAW,KACXC,SAAU,KACVC,UAAW,KACXC,aAAc,KACdC,SAAU,KACVE,SAAU,KACVC,eAAgB,KAChBC,UAAW,KACXkjB,OAAQ,KACR8H,QAAS,KACTC,SAAU,KACVxS,MAAO,KACPyS,OAAQ,KACRC,YAAa,KACbx2B,OAAQ,KACRy2B,SAAU,KACVC,QAAS,KACTlI,iBAAkBh4B,EAClBi4B,kBAAmBj4B,EACnBk4B,WAAY,KACZC,QAAS,KACT1uB,KAAM,KACN02B,WAAYngC,EACZogC,oBAAqB,KACrBC,iBAAkB,KAClBC,aAAc,KACdC,MAAO,KACPtrB,KAAMhV,EACNugC,MAAO,KACPnG,cAAe,KACfjC,cAAe,KACfqI,OAAQ,KACRC,UAAW1gC,EACX2gC,UAAW3gC,EACX4gC,UAAW5gC,EACX6gC,cAAe,KACfC,oBAAqB,KACrBC,eAAgB,KAChBC,UAAW,KACXnnC,SAAUqG,EACVud,EAAG,KACHwjB,OAAQ,KACR1rB,eAAgB,KAChB2rB,KAAM,KACNC,KAAM,KACN3rB,IAAKtV,EACLgZ,IAAKhZ,EACLm4B,gBAAiB,KACjB+I,YAAa,KACbC,UAAW,KACXC,mBAAoBphC,EACpBqhC,iBAAkBrhC,EAClBshC,cAAethC,EACfuhC,gBAAiBvhC,EACjBqyB,SAAU,KACVmP,QAAS,KACT93C,OAAQ,KACR+3C,OAAQ,KACRC,GAAI,KACJC,GAAI,KACJC,MAAO,KACPC,KAAM,KACNzJ,eAAgB,KAChB0J,KAAM,KACNC,MAAO,KACPC,aAAc,KACdC,iBAAkBniC,EAClBoiC,iBAAkBpiC,EAClBqiC,aAAc,KACdC,QAAS,KACTC,YAAa,KACbC,aAAc,KACdC,MAAO,KACPC,MAAO,KACPC,YAAa,KACbpK,UAAW,KACXC,YAAa,KACbC,sBAAuBz4B,EACvB04B,uBAAwB14B,EACxB3c,OAAQ,KACRu/C,OAAQ,KACRjK,gBAAiBz4B,EACjB04B,iBAAkB,KAClBC,cAAe,KACfC,eAAgB,KAChBC,iBAAkB/4B,EAClBg5B,cAAeh5B,EACfi5B,YAAa,KACb5/B,MAAO,KACPwpC,aAAc7iC,EACd8iC,aAAc,KACdC,oBAAqB,KACrBC,WAAY,KACZC,cAAe,KACfC,qBAAsB,KACtBC,eAAgBjjC,EAChBwW,SAAU1W,EACVojC,YAAa,KACbjxC,OAAQ,KACRkxC,QAASrjC,EACTsjC,QAAStjC,EACTk5B,WAAY,KACZC,eAAgB,KAChBC,cAAe,KACfmK,WAAY,KACZjJ,cAAe,KACf5wC,MAAO,KACP85C,kBAAmB,KACnBr+C,KAAM,KACNg7B,OAAQjgB,EACRrM,GAAI,KACJ+J,UAAW,KACX6lC,GAAI,KACJC,GAAI,KACJrK,kBAAmBr5B,EACnBs5B,mBAAoBt5B,EACpB2jC,QAAS,KACTpK,YAAa,KACbC,aAAc,KACdC,WAAYz5B,EACZhW,OAAQ,KACR0vC,YAAa15B,EACb65B,cAAe75B,EACf85B,aAAc,KACdH,SAAU35B,EACV45B,aAAc55B,EACd0Z,QAAS,KACTqgB,SAAU/5B,EACVg6B,YAAah6B,EACbi6B,YAAaj6B,EACb4jC,QAAS,KACTC,WAAY,KACZC,WAAY,KACZhtB,MAAO,KACPitB,OAAQ,KACR7J,YAAa,KACbC,YAAa,KACbtc,EAAG,KACHmmB,GAAI,KACJC,GAAI,KACJC,iBAAkB,KAClB9J,QAASp6B,EACT8d,EAAG,KACHqmB,GAAI,KACJC,GAAI,KACJC,iBAAkB,KAClBnmB,EAAG,KACHomB,WAAY","file":"d916624685150dd17d1c0253818dbc2a908ebb08-3f653e4e31550ad5178d.js","sourcesContent":["'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}","'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'; // 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\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 own = {}.hasOwnProperty;\nmodule.exports = stringify;\n\nfunction stringify(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return '';\n  } // Node.\n\n\n  if (own.call(value, 'position') || own.call(value, 'type')) {\n    return position(value.position);\n  } // Position.\n\n\n  if (own.call(value, 'start') || own.call(value, 'end')) {\n    return position(value);\n  } // Point.\n\n\n  if (own.call(value, 'line') || own.call(value, 'column')) {\n    return point(value);\n  } // ?\n\n\n  return '';\n}\n\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {};\n  }\n\n  return index(point.line) + ':' + index(point.column);\n}\n\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {};\n  }\n\n  return point(pos.start) + '-' + point(pos.end);\n}\n\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1;\n}","'use strict';\n\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 splice = [].splice;\nmodule.exports = splice;","'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\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 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\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 normalize = require('mdurl/encode');\n\nmodule.exports = image;\n\nfunction image(h, node) {\n  var props = {\n    src: normalize(node.url),\n    alt: node.alt\n  };\n\n  if (node.title !== null && node.title !== undefined) {\n    props.title = node.title;\n  }\n\n  return h(node, 'img', props);\n}","'use strict';\n\nfunction markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\nmodule.exports = markdownSpace;","'use strict';\n\nmodule.exports = all;\n\nvar one = require('./one');\n\nfunction all(h, parent) {\n  var nodes = parent.children || [];\n  var length = nodes.length;\n  var values = [];\n  var index = -1;\n  var result;\n  var head;\n\n  while (++index < length) {\n    result = one(h, nodes[index], parent);\n\n    if (result) {\n      if (index && nodes[index - 1].type === 'break') {\n        if (result.value) {\n          result.value = result.value.replace(/^\\s+/, '');\n        }\n\n        head = result.children && result.children[0];\n\n        if (head && head.value) {\n          head.value = head.value.replace(/^\\s+/, '');\n        }\n      }\n\n      values = values.concat(result);\n    }\n  }\n\n  return values;\n}","'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 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 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 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 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\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};","'use strict';\n\nvar React = require('react');\n\nvar unified = require('unified');\n\nvar parse = require('remark-parse');\n\nvar remarkRehype = require('remark-rehype');\n\nvar PropTypes = require('prop-types'); // @ts-ignore remove when typed\n\n\nvar html = require('property-information/html');\n\nvar filter = require('./rehype-filter');\n\nvar uriTransformer = require('./uri-transformer');\n\nvar childrenToReact = require('./ast-to-react.js').hastChildrenToReact;\n/**\n * @typedef {import('react').ReactNode} ReactNode\n * @typedef {import('react').ReactElement<{}>} ReactElement\n * @typedef {import('unified').PluggableList} PluggableList\n * @typedef {import('hast').Root} Root\n * @typedef {import('./rehype-filter.js').RehypeFilterOptions} FilterOptions\n * @typedef {import('./ast-to-react.js').TransformOptions} TransformOptions\n *\n * @typedef {Object} CoreOptions\n * @property {string} children\n *\n * @typedef {Object} PluginOptions\n * @property {PluggableList} [plugins=[]] **deprecated**: use `remarkPlugins` instead\n * @property {PluggableList} [remarkPlugins=[]]\n * @property {PluggableList} [rehypePlugins=[]]\n *\n * @typedef {Object} LayoutOptions\n * @property {string} [className]\n *\n * @typedef {CoreOptions & PluginOptions & LayoutOptions & FilterOptions & TransformOptions} ReactMarkdownOptions\n */\n\n\nmodule.exports = ReactMarkdown;\nvar own = {}.hasOwnProperty;\nvar changelog = 'https://github.com/remarkjs/react-markdown/blob/main/changelog.md';\n/**\n * @typedef {Object} Deprecation\n * @property {string} id\n * @property {string} [to]\n */\n\n/**\n * @type {Object.<string, Deprecation>}\n */\n\nvar deprecated = {\n  renderers: {\n    to: 'components',\n    id: 'change-renderers-to-components'\n  },\n  astPlugins: {\n    id: 'remove-buggy-html-in-markdown-parser'\n  },\n  allowDangerousHtml: {\n    id: 'remove-buggy-html-in-markdown-parser'\n  },\n  escapeHtml: {\n    id: 'remove-buggy-html-in-markdown-parser'\n  },\n  source: {\n    to: 'children',\n    id: 'change-source-to-children'\n  },\n  allowNode: {\n    to: 'allowElement',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  allowedTypes: {\n    to: 'allowedElements',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  disallowedTypes: {\n    to: 'disallowedElements',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  includeNodeIndex: {\n    to: 'includeElementIndex',\n    id: 'change-includenodeindex-to-includeelementindex'\n  }\n};\n/**\n * @param {ReactMarkdownOptions} options\n * @returns {ReactElement}\n */\n\nfunction ReactMarkdown(options) {\n  for (var key in deprecated) {\n    if (own.call(deprecated, key) && own.call(options, key)) {\n      /** @type {Deprecation} */\n      var deprecation = deprecated[key];\n      console.warn(\"[react-markdown] Warning: please \".concat(deprecation.to ? \"use `\".concat(deprecation.to, \"` instead of\") : 'remove', \" `\").concat(key, \"` (see <\").concat(changelog, \"#\").concat(deprecation.id, \"> for more info)\"));\n      delete deprecated[key];\n    }\n  }\n\n  var processor = unified().use(parse) // TODO: deprecate `plugins` in v7.0.0.\n  .use(options.remarkPlugins || options.plugins || []).use(remarkRehype, {\n    allowDangerousHtml: true\n  }).use(options.rehypePlugins || []).use(filter, options);\n  /** @type {Root} */\n  // @ts-ignore we’ll throw if it isn’t a root next.\n\n  var hastNode = processor.runSync(processor.parse(options.children || ''));\n\n  if (hastNode.type !== 'root') {\n    throw new TypeError('Expected a `root` node');\n  }\n  /** @type {ReactElement} */\n\n\n  var result = React.createElement(React.Fragment, {}, childrenToReact({\n    options: options,\n    schema: html,\n    listDepth: 0\n  }, hastNode));\n\n  if (options.className) {\n    result = React.createElement('div', {\n      className: options.className\n    }, result);\n  }\n\n  return result;\n}\n\nReactMarkdown.defaultProps = {\n  transformLinkUri: uriTransformer\n};\nReactMarkdown.propTypes = {\n  // Core options:\n  children: PropTypes.string,\n  // Layout options:\n  className: PropTypes.string,\n  // Filter options:\n  allowElement: PropTypes.func,\n  allowedElements: PropTypes.arrayOf(PropTypes.string),\n  disallowedElements: PropTypes.arrayOf(PropTypes.string),\n  unwrapDisallowed: PropTypes.bool,\n  // Plugin options:\n  // type-coverage:ignore-next-line\n  remarkPlugins: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.object, PropTypes.func]))])),\n  // type-coverage:ignore-next-line\n  rehypePlugins: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.object, PropTypes.func]))])),\n  // Transform options:\n  sourcePos: PropTypes.bool,\n  rawSourcePos: PropTypes.bool,\n  skipHtml: PropTypes.bool,\n  includeElementIndex: PropTypes.bool,\n  transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n  linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  transformImageUri: PropTypes.func,\n  components: PropTypes.object\n};\nReactMarkdown.uriTransformer = uriTransformer;","'use strict';\n\nvar merge = require('./lib/util/merge');\n\nvar xlink = require('./lib/xlink');\n\nvar xml = require('./lib/xml');\n\nvar xmlns = require('./lib/xmlns');\n\nvar aria = require('./lib/aria');\n\nvar html = require('./lib/html');\n\nmodule.exports = merge([xml, xlink, xmlns, aria, html]);","'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 regexCheck = require('../util/regex-check.js');\n\nvar asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\nmodule.exports = asciiAtext;","'use strict';\n\nmodule.exports = footnote;\n\nvar footnoteReference = require('./footnote-reference');\n\nfunction footnote(h, node) {\n  var footnoteById = h.footnoteById;\n  var footnoteOrder = h.footnoteOrder;\n  var identifier = 1;\n\n  while (identifier in footnoteById) {\n    identifier++;\n  }\n\n  identifier = String(identifier); // No need to check if `identifier` exists in `footnoteOrder`, it’s guaranteed\n  // to not exist because we just generated it.\n\n  footnoteOrder.push(identifier);\n  footnoteById[identifier] = {\n    type: 'footnoteDefinition',\n    identifier: identifier,\n    children: [{\n      type: 'paragraph',\n      children: node.children\n    }],\n    position: node.position\n  };\n  return footnoteReference(h, {\n    type: 'footnoteReference',\n    identifier: identifier,\n    position: node.position\n  });\n}","'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 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\nmodule.exports = revert;\n\nvar u = require('unist-builder');\n\nvar all = require('./all'); // Return the content of a reference without definition as Markdown.\n\n\nfunction revert(h, node) {\n  var subtype = node.referenceType;\n  var suffix = ']';\n  var contents;\n  var head;\n  var tail;\n\n  if (subtype === 'collapsed') {\n    suffix += '[]';\n  } else if (subtype === 'full') {\n    suffix += '[' + (node.label || node.identifier) + ']';\n  }\n\n  if (node.type === 'imageReference') {\n    return u('text', '![' + node.alt + suffix);\n  }\n\n  contents = all(h, node);\n  head = contents[0];\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value;\n  } else {\n    contents.unshift(u('text', '['));\n  }\n\n  tail = contents[contents.length - 1];\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix;\n  } else {\n    contents.push(u('text', suffix));\n  }\n\n  return contents;\n}","'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 React = require('react');\n\nvar ReactIs = require('react-is'); // @ts-ignore remove when typed\n\n\nvar svg = require('property-information/svg'); // @ts-ignore remove when typed\n\n\nvar find = require('property-information/find'); // @ts-ignore remove when typed\n\n\nvar hastToReact = require('property-information/hast-to-react.json'); // @ts-ignore remove when typed\n\n\nvar spaces = require('space-separated-tokens'); // @ts-ignore remove when typed\n\n\nvar commas = require('comma-separated-tokens');\n\nvar style = require('style-to-object');\n\nexports.hastToReact = toReact;\nexports.hastChildrenToReact = childrenToReact;\n/**\n * @typedef {JSX.IntrinsicElements} IntrinsicElements\n * @typedef {import('react').ReactNode} ReactNode\n * @typedef {import('unist').Position} Position\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').DocType} Doctype\n */\n\n/**\n * @typedef {Object} Info\n * @property {string?} space\n * @property {string?} attribute\n * @property {string?} property\n * @property {boolean} boolean\n * @property {boolean} booleanish\n * @property {boolean} overloadedBoolean\n * @property {boolean} number\n * @property {boolean} commaSeparated\n * @property {boolean} spaceSeparated\n * @property {boolean} commaOrSpaceSeparated\n * @property {boolean} mustUseProperty\n * @property {boolean} defined\n *\n * @typedef {Object} Schema\n * @property {Object.<string, Info>} property\n * @property {Object.<string, string>} normal\n * @property {string?} space\n *\n * @typedef {Object} Raw\n * @property {'raw'} type\n * @property {string} value\n *\n * @typedef {Object} Context\n * @property {TransformOptions} options\n * @property {Schema} schema\n * @property {number} listDepth\n *\n * @callback TransformLink\n * @param {string} href\n * @param {Array.<Comment|Element|Text>} children\n * @param {string?} title\n * @returns {string}\n *\n * @callback TransformImage\n * @param {string} src\n * @param {string} alt\n * @param {string?} title\n * @returns {string}\n *\n * @callback TransformLinkTarget\n * @param {string} href\n * @param {Array.<Comment|Element|Text>} children\n * @param {string?} title\n * @returns {string}\n *\n * @typedef {keyof IntrinsicElements} ReactMarkdownNames\n *\n * @typedef {Object.<string, unknown>} ReactBaseProps\n *\n * To do: is `data-sourcepos` typeable?\n *\n * @typedef {Object} ReactMarkdownProps\n * @property {Element} node\n * @property {string} key\n * @property {ReactNode[]} children\n * @property {Position?} [sourcePosition] Passed when `options.rawSourcePos` is given\n * @property {number} [index] Passed when `options.includeElementIndex` is given\n * @property {number} [siblingCount] Passed when `options.includeElementIndex` is given\n *\n * @callback NormalComponent\n * @param {ReactBaseProps & ReactMarkdownProps} props\n * @returns {ReactNode}\n *\n * @callback CodeComponent\n * @param {ReactBaseProps & ReactMarkdownProps & {inline?: boolean}} props\n * @returns {ReactNode}\n *\n * @callback HeadingComponent\n * @param {ReactBaseProps & ReactMarkdownProps & {level: number}} props\n * @returns {ReactNode}\n *\n * @callback LiComponent\n * @param {ReactBaseProps & ReactMarkdownProps & {checked: boolean|null, index: number, ordered: boolean}} props\n * @returns {ReactNode}\n *\n * @callback OrderedListComponent\n * @param {ReactBaseProps & ReactMarkdownProps & {depth: number, ordered: true}} props\n * @returns {ReactNode}\n *\n * @callback TableCellComponent\n * @param {ReactBaseProps & ReactMarkdownProps & {style?: Object.<string, unknown>, isHeader: boolean}} props\n * @returns {ReactNode}\n *\n * @callback TableRowComponent\n * @param {ReactBaseProps & ReactMarkdownProps & {isHeader: boolean}} props\n * @returns {ReactNode}\n *\n * @callback UnorderedListComponent\n * @param {ReactBaseProps & ReactMarkdownProps & {depth: number, ordered: false}} props\n * @returns {ReactNode}\n *\n * @typedef {Object} SpecialComponents\n * @property {CodeComponent|ReactMarkdownNames} code\n * @property {HeadingComponent|ReactMarkdownNames} h1\n * @property {HeadingComponent|ReactMarkdownNames} h2\n * @property {HeadingComponent|ReactMarkdownNames} h3\n * @property {HeadingComponent|ReactMarkdownNames} h4\n * @property {HeadingComponent|ReactMarkdownNames} h5\n * @property {HeadingComponent|ReactMarkdownNames} h6\n * @property {LiComponent|ReactMarkdownNames} li\n * @property {OrderedListComponent|ReactMarkdownNames} ol\n * @property {TableCellComponent|ReactMarkdownNames} td\n * @property {TableCellComponent|ReactMarkdownNames} th\n * @property {TableRowComponent|ReactMarkdownNames} tr\n * @property {UnorderedListComponent|ReactMarkdownNames} ul\n *\n * @typedef {Record<Exclude<ReactMarkdownNames, keyof SpecialComponents>, NormalComponent|ReactMarkdownNames>} NormalComponents\n * @typedef {Partial<NormalComponents & SpecialComponents>} Components\n */\n\n/**\n * @typedef {Object} TransformOptions\n * @property {boolean} [sourcePos=false]\n * @property {boolean} [rawSourcePos=false]\n * @property {boolean} [skipHtml=false]\n * @property {boolean} [includeElementIndex=false]\n * @property {false|TransformLink} [transformLinkUri]\n * @property {TransformImage} [transformImageUri]\n * @property {string|TransformLinkTarget} [linkTarget]\n * @property {Components} [components]\n */\n\nvar own = {}.hasOwnProperty; // The table-related elements that must not contain whitespace text according\n// to React.\n\nvar tableElements = new Set(['table', 'thead', 'tbody', 'tfoot', 'tr']);\n/**\n * @param {Context} context\n * @param {Element|Root} node\n */\n\nfunction childrenToReact(context, node) {\n  /** @type {Array.<ReactNode>} */\n  var children = [];\n  var childIndex = -1;\n  /** @type {Comment|Doctype|Element|Raw|Text} */\n\n  var child;\n\n  while (++childIndex < node.children.length) {\n    child = node.children[childIndex];\n\n    if (child.type === 'element') {\n      children.push(toReact(context, child, childIndex, node));\n    } else if (child.type === 'text') {\n      // React does not permit whitespace text elements as children of table:\n      // cf. https://github.com/remarkjs/react-markdown/issues/576\n      if (node.type !== 'element' || !tableElements.has(node.tagName) || child.value !== '\\n') {\n        children.push(child.value);\n      }\n    } // @ts-ignore `raw` nodes are non-standard\n    else if (child.type === 'raw' && !context.options.skipHtml) {\n        // Default behavior is to show (encoded) HTML.\n        // @ts-ignore `raw` nodes are non-standard\n        children.push(child.value);\n      }\n  }\n\n  return children;\n}\n/**\n * @param {Context} context\n * @param {Element} node\n * @param {number} index\n * @param {Element|Root} parent\n */\n\n\nfunction toReact(context, node, index, parent) {\n  var options = context.options;\n  var parentSchema = context.schema;\n  /** @type {ReactMarkdownNames} */\n  // @ts-ignore assume a known HTML/SVG element.\n\n  var name = node.tagName;\n  /** @type {Object.<string, unknown>} */\n\n  var properties = {};\n  var schema = parentSchema;\n  /** @type {string} */\n\n  var property;\n\n  if (parentSchema.space === 'html' && name === 'svg') {\n    schema = svg;\n    context.schema = schema;\n  }\n\n  for (property in node.properties) {\n    /* istanbul ignore else - prototype polution. */\n    if (own.call(node.properties, property)) {\n      addProperty(properties, property, node.properties[property], context);\n    }\n  }\n\n  if (name === 'ol' || name === 'ul') {\n    context.listDepth++;\n  }\n\n  var children = childrenToReact(context, node);\n\n  if (name === 'ol' || name === 'ul') {\n    context.listDepth--;\n  } // Restore parent schema.\n\n\n  context.schema = parentSchema; // Nodes created by plugins do not have positional info, in which case we use\n  // an object that matches the positon interface.\n\n  var position = 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  /** @type {NormalComponent|SpecialComponents[keyof SpecialComponents]|ReactMarkdownNames} */\n\n  var component = options.components && own.call(options.components, name) ? options.components[name] : name;\n  var basic = typeof component === 'string' || component === React.Fragment;\n\n  if (!ReactIs.isValidElementType(component)) {\n    throw new TypeError(\"Component for name `\".concat(name, \"` not defined or is not renderable\"));\n  }\n\n  properties.key = [name, position.start.line, position.start.column, index].join('-');\n\n  if (name === 'a' && options.linkTarget) {\n    properties.target = typeof options.linkTarget === 'function' ? // @ts-ignore assume `href` is a string\n    options.linkTarget(properties.href, node.children, properties.title) : options.linkTarget;\n  }\n\n  if (name === 'a' && options.transformLinkUri) {\n    properties.href = options.transformLinkUri( // @ts-ignore assume `href` is a string\n    properties.href, node.children, properties.title);\n  }\n\n  if (!basic && name === 'code' && parent.tagName !== 'pre') {\n    properties.inline = true;\n  }\n\n  if (!basic && (name === 'h1' || name === 'h2' || name === 'h3' || name === 'h4' || name === 'h5' || name === 'h6')) {\n    properties.level = parseInt(name.charAt(1), 10);\n  }\n\n  if (name === 'img' && options.transformImageUri) {\n    properties.src = options.transformImageUri( // @ts-ignore assume `src` is a string\n    properties.src, properties.alt, properties.title);\n  }\n\n  if (!basic && name === 'li') {\n    var input = getInputElement(node);\n    properties.checked = input ? Boolean(input.properties.checked) : null;\n    properties.index = getElementsBeforeCount(parent, node);\n    properties.ordered = parent.tagName === 'ol';\n  }\n\n  if (!basic && (name === 'ol' || name === 'ul')) {\n    properties.ordered = name === 'ol';\n    properties.depth = context.listDepth;\n  }\n\n  if (name === 'td' || name === 'th') {\n    if (properties.align) {\n      if (!properties.style) properties.style = {}; // @ts-ignore assume `style` is an object\n\n      properties.style.textAlign = properties.align;\n      delete properties.align;\n    }\n\n    if (!basic) {\n      properties.isHeader = name === 'th';\n    }\n  }\n\n  if (!basic && name === 'tr') {\n    properties.isHeader = Boolean(parent.tagName === 'thead');\n  } // If `sourcePos` is given, pass source information (line/column info from markdown source).\n\n\n  if (options.sourcePos) {\n    properties['data-sourcepos'] = flattenPosition(position);\n  }\n\n  if (!basic && options.rawSourcePos) {\n    properties.sourcePosition = node.position;\n  } // If `includeElementIndex` is given, pass node index info to components.\n\n\n  if (!basic && options.includeElementIndex) {\n    properties.index = getElementsBeforeCount(parent, node);\n    properties.siblingCount = getElementsBeforeCount(parent);\n  }\n\n  if (!basic) {\n    properties.node = node;\n  } // Ensure no React warnings are emitted for void elements w/ children.\n\n\n  return children.length > 0 ? React.createElement(component, properties, children) : React.createElement(component, properties);\n}\n/**\n * @param {Element|Root} node\n * @returns {Element?}\n */\n\n\nfunction getInputElement(node) {\n  var index = -1;\n\n  while (++index < node.children.length) {\n    var child = node.children[index];\n\n    if (child.type === 'element' && child.tagName === 'input') {\n      return child;\n    }\n  }\n\n  return null;\n}\n/**\n * @param {Element|Root} parent\n * @param {Element} [node]\n * @returns {number}\n */\n\n\nfunction getElementsBeforeCount(parent, node) {\n  var index = -1;\n  var count = 0;\n\n  while (++index < parent.children.length) {\n    if (parent.children[index] === node) break;\n    if (parent.children[index].type === 'element') count++;\n  }\n\n  return count;\n}\n/**\n * @param {Object.<string, unknown>} props\n * @param {string} prop\n * @param {unknown} value\n * @param {Context} ctx\n */\n\n\nfunction addProperty(props, prop, value, ctx) {\n  /** @type {Info} */\n  var info = find(ctx.schema, prop);\n  var result = value; // Ignore nullish and `NaN` values.\n  // eslint-disable-next-line no-self-compare\n\n  if (result === null || result === undefined || result !== result) {\n    return;\n  } // Accept `array`.\n  // Most props are space-separated.\n\n\n  if (result && typeof result === 'object' && 'length' in result) {\n    // type-coverage:ignore-next-line remove when typed.\n    result = (info.commaSeparated ? commas : spaces).stringify(result);\n  }\n\n  if (info.property === 'style' && typeof result === 'string') {\n    result = parseStyle(result);\n  }\n\n  if (info.space) {\n    props[own.call(hastToReact, info.property) ? hastToReact[info.property] : info.property] = result;\n  } else {\n    props[info.attribute] = result;\n  }\n}\n/**\n * @param {string} value\n * @returns {Object.<string, string>}\n */\n\n\nfunction parseStyle(value) {\n  /** @type {Object.<string, string>} */\n  var result = {};\n\n  try {\n    style(value, iterator);\n  } catch (\n  /** @type {Error} */\n  _) {// Silent.\n  }\n\n  return result;\n  /**\n   * @param {string} name\n   * @param {string} v\n   */\n\n  function iterator(name, v) {\n    var k = name.slice(0, 4) === '-ms-' ? \"ms-\".concat(name.slice(4)) : name;\n    result[k.replace(/-([a-z])/g, styleReplacer)] = v;\n  }\n}\n/**\n * @param {unknown} _\n * @param {string} $1\n */\n\n\nfunction styleReplacer(_, $1) {\n  return $1.toUpperCase();\n}\n/**\n * @param {Position} pos\n * @returns {string}\n */\n\n\nfunction flattenPosition(pos) {\n  return [pos.start.line, ':', pos.start.column, '-', pos.end.line, ':', pos.end.column].map(function (d) {\n    return String(d);\n  }).join('');\n}","'use strict';\n\nvar start = factory('start');\nvar end = factory('end');\nmodule.exports = position;\nposition.start = start;\nposition.end = end;\n\nfunction position(node) {\n  return {\n    start: start(node),\n    end: end(node)\n  };\n}\n\nfunction factory(type) {\n  point.displayName = type;\n  return point;\n\n  function point(node) {\n    var point = node && node.position && node.position[type] || {};\n    return {\n      line: point.line || null,\n      column: point.column || null,\n      offset: isNaN(point.offset) ? null : point.offset\n    };\n  }\n}","'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 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;","var parse = require('inline-style-parser');\n/**\n * Parses inline style to object.\n *\n * @example\n * // returns { 'line-height': '42' }\n * StyleToObject('line-height: 42;');\n *\n * @param  {String}      style      - The inline style.\n * @param  {Function}    [iterator] - The iterator function.\n * @return {null|Object}\n */\n\n\nfunction StyleToObject(style, iterator) {\n  var output = null;\n\n  if (!style || typeof style !== 'string') {\n    return output;\n  }\n\n  var declaration;\n  var declarations = parse(style);\n  var hasIterator = typeof iterator === 'function';\n  var property;\n  var value;\n\n  for (var i = 0, len = declarations.length; i < len; i++) {\n    declaration = declarations[i];\n    property = declaration.property;\n    value = declaration.value;\n\n    if (hasIterator) {\n      iterator(property, value, declaration);\n    } else if (value) {\n      output || (output = {});\n      output[property] = value;\n    }\n  }\n\n  return output;\n}\n\nmodule.exports = StyleToObject;","'use strict';\n\nmodule.exports = html;\n\nvar u = require('unist-builder'); // Return either a `raw` node in dangerous mode, otherwise nothing.\n\n\nfunction html(h, node) {\n  return h.dangerous ? h.augment(node, u('raw', node.value)) : null;\n}","'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 normalize = require('../../normalize');\n\nvar Schema = require('./schema');\n\nvar DefinedInfo = require('./defined-info');\n\nmodule.exports = create;\n\nfunction create(definition) {\n  var space = definition.space;\n  var mustUseProperty = definition.mustUseProperty || [];\n  var attributes = definition.attributes || {};\n  var props = definition.properties;\n  var transform = definition.transform;\n  var property = {};\n  var normal = {};\n  var prop;\n  var info;\n\n  for (prop in props) {\n    info = new DefinedInfo(prop, transform(attributes, prop), props[prop], space);\n\n    if (mustUseProperty.indexOf(prop) !== -1) {\n      info.mustUseProperty = true;\n    }\n\n    property[prop] = info;\n    normal[normalize(prop)] = prop;\n    normal[normalize(info.attribute)] = prop;\n  }\n\n  return new Schema(property, normal, space);\n}","'use strict';\n\nfunction markdownLineEnding(code) {\n  return code < -2;\n}\n\nmodule.exports = markdownLineEnding;","'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\nvar fromCharCode = String.fromCharCode;\nmodule.exports = fromCharCode;","var visit = require('unist-util-visit');\n\nvar splice = [].splice;\nmodule.exports = rehypeFilter;\n/**\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Element} Element\n *\n * @callback AllowElement\n * @param {Element} element\n * @param {number} index\n * @param {Element|Root} parent\n * @returns {boolean}\n *\n * @typedef {Object} RehypeFilterOptions\n * @property {Array.<string>} [allowedElements]\n * @property {Array.<string>} [disallowedElements=[]]\n * @property {AllowElement} [allowElement]\n * @property {boolean} [unwrapDisallowed=false]\n */\n\n/**\n * @param {RehypeFilterOptions} options\n */\n\nfunction rehypeFilter(options) {\n  if (options.allowedElements && options.disallowedElements) {\n    throw new TypeError('Only one of `allowedElements` and `disallowedElements` should be defined');\n  }\n\n  return options.allowedElements || options.disallowedElements || options.allowElement ? transform : undefined;\n  /**\n   * @param {Root} tree\n   */\n\n  function transform(tree) {\n    visit(tree, 'element', onelement);\n  }\n  /**\n   * @param {Element} node\n   * @param {number} index\n   * @param {Element|Root} parent\n   * @returns {number|void}\n   */\n\n\n  function onelement(node, index, parent) {\n    /** @type {boolean} */\n    var remove;\n\n    if (options.allowedElements) {\n      remove = !options.allowedElements.includes(node.tagName);\n    } else if (options.disallowedElements) {\n      remove = options.disallowedElements.includes(node.tagName);\n    }\n\n    if (!remove && options.allowElement) {\n      remove = !options.allowElement(node, index, parent);\n    }\n\n    if (remove) {\n      /** @type {Array.<unknown>} */\n      var parameters = [index, 1];\n\n      if (options.unwrapDisallowed && node.children) {\n        parameters = parameters.concat(node.children);\n      }\n\n      splice.apply(parent.children, parameters);\n      return index;\n    }\n\n    return undefined;\n  }\n}","'use strict';\n\nmodule.exports = require('./lib');","'use strict';\n\nmodule.exports = heading;\n\nvar all = require('../all');\n\nfunction heading(h, node) {\n  return h(node, 'h' + node.depth, all(h, node));\n}","'use strict';\n\nvar normalize = require('./normalize');\n\nvar DefinedInfo = require('./lib/util/defined-info');\n\nvar Info = require('./lib/util/info');\n\nvar data = 'data';\nmodule.exports = find;\nvar valid = /^data[-\\w.:]+$/i;\nvar dash = /-[a-z]/g;\nvar cap = /[A-Z]/g;\n\nfunction find(schema, value) {\n  var normal = normalize(value);\n  var prop = value;\n  var Type = Info;\n\n  if (normal in schema.normal) {\n    return schema.property[schema.normal[normal]];\n  }\n\n  if (normal.length > 4 && normal.slice(0, 4) === data && valid.test(value)) {\n    // Attribute or property.\n    if (value.charAt(4) === '-') {\n      prop = datasetToProperty(value);\n    } else {\n      value = datasetToAttribute(value);\n    }\n\n    Type = DefinedInfo;\n  }\n\n  return new Type(prop, value);\n}\n\nfunction datasetToProperty(attribute) {\n  var value = attribute.slice(5).replace(dash, camelcase);\n  return data + value.charAt(0).toUpperCase() + value.slice(1);\n}\n\nfunction datasetToAttribute(property) {\n  var value = property.slice(4);\n\n  if (dash.test(value)) {\n    return property;\n  }\n\n  value = value.replace(cap, kebab);\n\n  if (value.charAt(0) !== '-') {\n    value = '-' + value;\n  }\n\n  return data + value;\n}\n\nfunction kebab($0) {\n  return '-' + $0.toLowerCase();\n}\n\nfunction camelcase($0) {\n  return $0.charAt(1).toUpperCase();\n}","'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;","module.exports = identity;\n\nfunction identity(d) {\n  return d;\n}","'use strict';\n\nvar powers = 0;\nexports.boolean = increment();\nexports.booleanish = increment();\nexports.overloadedBoolean = increment();\nexports.number = increment();\nexports.spaceSeparated = increment();\nexports.commaSeparated = increment();\nexports.commaOrSpaceSeparated = increment();\n\nfunction increment() {\n  return Math.pow(2, ++powers);\n}","'use strict';\n\nmodule.exports = bail;\n\nfunction bail(err) {\n  if (err) {\n    throw err;\n  }\n}","'use strict';\n\nmodule.exports = root;\n\nvar u = require('unist-builder');\n\nvar wrap = require('../wrap');\n\nvar all = require('../all');\n\nfunction root(h, node) {\n  return h.augment(node, u('root', wrap(all(h, node))));\n}","'use strict';\n\nvar chunkedSplice = require('./chunked-splice.js');\n\nfunction chunkedPush(list, items) {\n  if (list.length) {\n    chunkedSplice(list, list.length, 0, items);\n    return list;\n  }\n\n  return items;\n}\n\nmodule.exports = chunkedPush;","'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\nmodule.exports = strikethrough;\n\nvar all = require('../all');\n\nfunction strikethrough(h, node) {\n  return h(node, 'del', all(h, node));\n}","'use strict';\n\nvar merge = require('./lib/util/merge');\n\nvar xlink = require('./lib/xlink');\n\nvar xml = require('./lib/xml');\n\nvar xmlns = require('./lib/xmlns');\n\nvar aria = require('./lib/aria');\n\nvar svg = require('./lib/svg');\n\nmodule.exports = merge([xml, xlink, xmlns, aria, svg]);","'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\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 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'; // 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 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\nmodule.exports = table;\n\nvar position = require('unist-util-position');\n\nvar wrap = require('../wrap');\n\nvar all = require('../all');\n\nfunction table(h, node) {\n  var rows = node.children;\n  var index = rows.length;\n  var align = node.align || [];\n  var alignLength = align.length;\n  var result = [];\n  var pos;\n  var row;\n  var out;\n  var name;\n  var cell;\n\n  while (index--) {\n    row = rows[index].children;\n    name = index === 0 ? 'th' : 'td';\n    pos = alignLength || row.length;\n    out = [];\n\n    while (pos--) {\n      cell = row[pos];\n      out[pos] = h(cell, name, {\n        align: align[pos]\n      }, cell ? all(h, cell) : []);\n    }\n\n    result[index] = h(rows[index], 'tr', wrap(out, true));\n  }\n\n  return h(node, 'table', wrap([h(result[0].position, 'thead', wrap([result[0]], true))].concat(result[1] ? h({\n    start: position.start(result[1]),\n    end: position.end(result[result.length - 1])\n  }, 'tbody', wrap(result.slice(1), true)) : []), true));\n}","'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\nmodule.exports = require('./dist');","'use strict';\n\nvar visit = require('unist-util-visit');\n\nmodule.exports = getDefinitionFactory;\nvar own = {}.hasOwnProperty; // Get a definition in `node` by `identifier`.\n\nfunction getDefinitionFactory(node, options) {\n  return getterFactory(gather(node, options));\n} // Gather all definitions in `node`\n\n\nfunction gather(node) {\n  var cache = {};\n\n  if (!node || !node.type) {\n    throw new Error('mdast-util-definitions expected node');\n  }\n\n  visit(node, 'definition', ondefinition);\n  return cache;\n\n  function ondefinition(definition) {\n    var id = normalise(definition.identifier);\n\n    if (!own.call(cache, id)) {\n      cache[id] = definition;\n    }\n  }\n} // Factory to get a node from the given definition-cache.\n\n\nfunction getterFactory(cache) {\n  return getter; // Get a node from the bound definition-cache.\n\n  function getter(identifier) {\n    var id = identifier && normalise(identifier);\n    return id && own.call(cache, id) ? cache[id] : null;\n  }\n}\n\nfunction normalise(identifier) {\n  return identifier.toUpperCase();\n}","// http://www.w3.org/TR/CSS21/grammar.html\n// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027\nvar COMMENT_REGEX = /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//g;\nvar NEWLINE_REGEX = /\\n/g;\nvar WHITESPACE_REGEX = /^\\s*/; // declaration\n\nvar PROPERTY_REGEX = /^(\\*?[-#/*\\\\\\w]+(\\[[0-9a-z_-]+\\])?)\\s*/;\nvar COLON_REGEX = /^:\\s*/;\nvar VALUE_REGEX = /^((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^)]*?\\)|[^};])+)/;\nvar SEMICOLON_REGEX = /^[;\\s]*/; // https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim#Polyfill\n\nvar TRIM_REGEX = /^\\s+|\\s+$/g; // strings\n\nvar NEWLINE = '\\n';\nvar FORWARD_SLASH = '/';\nvar ASTERISK = '*';\nvar EMPTY_STRING = ''; // types\n\nvar TYPE_COMMENT = 'comment';\nvar TYPE_DECLARATION = 'declaration';\n/**\n * @param {String} style\n * @param {Object} [options]\n * @return {Object[]}\n * @throws {TypeError}\n * @throws {Error}\n */\n\nmodule.exports = function (style, options) {\n  if (typeof style !== 'string') {\n    throw new TypeError('First argument must be a string');\n  }\n\n  if (!style) return [];\n  options = options || {};\n  /**\n   * Positional.\n   */\n\n  var lineno = 1;\n  var column = 1;\n  /**\n   * Update lineno and column based on `str`.\n   *\n   * @param {String} str\n   */\n\n  function updatePosition(str) {\n    var lines = str.match(NEWLINE_REGEX);\n    if (lines) lineno += lines.length;\n    var i = str.lastIndexOf(NEWLINE);\n    column = ~i ? str.length - i : column + str.length;\n  }\n  /**\n   * Mark position and patch `node.position`.\n   *\n   * @return {Function}\n   */\n\n\n  function position() {\n    var start = {\n      line: lineno,\n      column: column\n    };\n    return function (node) {\n      node.position = new Position(start);\n      whitespace();\n      return node;\n    };\n  }\n  /**\n   * Store position information for a node.\n   *\n   * @constructor\n   * @property {Object} start\n   * @property {Object} end\n   * @property {undefined|String} source\n   */\n\n\n  function Position(start) {\n    this.start = start;\n    this.end = {\n      line: lineno,\n      column: column\n    };\n    this.source = options.source;\n  }\n  /**\n   * Non-enumerable source string.\n   */\n\n\n  Position.prototype.content = style;\n  var errorsList = [];\n  /**\n   * Error `msg`.\n   *\n   * @param {String} msg\n   * @throws {Error}\n   */\n\n  function error(msg) {\n    var err = new Error(options.source + ':' + lineno + ':' + column + ': ' + msg);\n    err.reason = msg;\n    err.filename = options.source;\n    err.line = lineno;\n    err.column = column;\n    err.source = style;\n\n    if (options.silent) {\n      errorsList.push(err);\n    } else {\n      throw err;\n    }\n  }\n  /**\n   * Match `re` and return captures.\n   *\n   * @param {RegExp} re\n   * @return {undefined|Array}\n   */\n\n\n  function match(re) {\n    var m = re.exec(style);\n    if (!m) return;\n    var str = m[0];\n    updatePosition(str);\n    style = style.slice(str.length);\n    return m;\n  }\n  /**\n   * Parse whitespace.\n   */\n\n\n  function whitespace() {\n    match(WHITESPACE_REGEX);\n  }\n  /**\n   * Parse comments.\n   *\n   * @param {Object[]} [rules]\n   * @return {Object[]}\n   */\n\n\n  function comments(rules) {\n    var c;\n    rules = rules || [];\n\n    while (c = comment()) {\n      if (c !== false) {\n        rules.push(c);\n      }\n    }\n\n    return rules;\n  }\n  /**\n   * Parse comment.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n\n\n  function comment() {\n    var pos = position();\n    if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;\n    var i = 2;\n\n    while (EMPTY_STRING != style.charAt(i) && (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))) {\n      ++i;\n    }\n\n    i += 2;\n\n    if (EMPTY_STRING === style.charAt(i - 1)) {\n      return error('End of comment missing');\n    }\n\n    var str = style.slice(2, i - 2);\n    column += 2;\n    updatePosition(str);\n    style = style.slice(i);\n    column += 2;\n    return pos({\n      type: TYPE_COMMENT,\n      comment: str\n    });\n  }\n  /**\n   * Parse declaration.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n\n\n  function declaration() {\n    var pos = position(); // prop\n\n    var prop = match(PROPERTY_REGEX);\n    if (!prop) return;\n    comment(); // :\n\n    if (!match(COLON_REGEX)) return error(\"property missing ':'\"); // val\n\n    var val = match(VALUE_REGEX);\n    var ret = pos({\n      type: TYPE_DECLARATION,\n      property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),\n      value: val ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING)) : EMPTY_STRING\n    }); // ;\n\n    match(SEMICOLON_REGEX);\n    return ret;\n  }\n  /**\n   * Parse declarations.\n   *\n   * @return {Object[]}\n   */\n\n\n  function declarations() {\n    var decls = [];\n    comments(decls); // declarations\n\n    var decl;\n\n    while (decl = declaration()) {\n      if (decl !== false) {\n        decls.push(decl);\n        comments(decls);\n      }\n    }\n\n    return decls;\n  }\n\n  whitespace();\n  return declarations();\n};\n/**\n * Trim `str`.\n *\n * @param {String} str\n * @return {String}\n */\n\n\nfunction trim(str) {\n  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;\n}","'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\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\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 assign = Object.assign;\nmodule.exports = assign;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\nmodule.exports = asciiAlphanumeric;","'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 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\nmodule.exports = toHast;\n\nvar u = require('unist-builder');\n\nvar visit = require('unist-util-visit');\n\nvar position = require('unist-util-position');\n\nvar generated = require('unist-util-generated');\n\nvar definitions = require('mdast-util-definitions');\n\nvar one = require('./one');\n\nvar footer = require('./footer');\n\nvar handlers = require('./handlers');\n\nvar own = {}.hasOwnProperty;\nvar deprecationWarningIssued = false; // Factory to transform.\n\nfunction factory(tree, options) {\n  var settings = options || {}; // Issue a warning if the deprecated tag 'allowDangerousHTML' is used\n\n  if (settings.allowDangerousHTML !== undefined && !deprecationWarningIssued) {\n    deprecationWarningIssued = true;\n    console.warn('mdast-util-to-hast: deprecation: `allowDangerousHTML` is nonstandard, use `allowDangerousHtml` instead');\n  }\n\n  var dangerous = settings.allowDangerousHtml || settings.allowDangerousHTML;\n  var footnoteById = {};\n  h.dangerous = dangerous;\n  h.definition = definitions(tree);\n  h.footnoteById = footnoteById;\n  h.footnoteOrder = [];\n  h.augment = augment;\n  h.handlers = Object.assign({}, handlers, settings.handlers);\n  h.unknownHandler = settings.unknownHandler;\n  h.passThrough = settings.passThrough;\n  visit(tree, 'footnoteDefinition', onfootnotedefinition);\n  return h; // Finalise the created `right`, a hast node, from `left`, an mdast node.\n\n  function augment(left, right) {\n    var data;\n    var ctx; // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n\n    if (left && left.data) {\n      data = left.data;\n\n      if (data.hName) {\n        if (right.type !== 'element') {\n          right = {\n            type: 'element',\n            tagName: '',\n            properties: {},\n            children: []\n          };\n        }\n\n        right.tagName = data.hName;\n      }\n\n      if (right.type === 'element' && data.hProperties) {\n        right.properties = Object.assign({}, right.properties, data.hProperties);\n      }\n\n      if (right.children && data.hChildren) {\n        right.children = data.hChildren;\n      }\n    }\n\n    ctx = left && left.position ? left : {\n      position: left\n    };\n\n    if (!generated(ctx)) {\n      right.position = {\n        start: position.start(ctx),\n        end: position.end(ctx)\n      };\n    }\n\n    return right;\n  } // Create an element for `node`.\n\n\n  function h(node, tagName, props, children) {\n    if ((children === undefined || children === null) && typeof props === 'object' && 'length' in props) {\n      children = props;\n      props = {};\n    }\n\n    return augment(node, {\n      type: 'element',\n      tagName: tagName,\n      properties: props || {},\n      children: children || []\n    });\n  }\n\n  function onfootnotedefinition(definition) {\n    var id = String(definition.identifier).toUpperCase(); // Mimick CM behavior of link definitions.\n    // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/8290999/index.js#L26>.\n\n    if (!own.call(footnoteById, id)) {\n      footnoteById[id] = definition;\n    }\n  }\n} // Transform `tree`, which is an mdast node, to a hast node.\n\n\nfunction toHast(tree, options) {\n  var h = factory(tree, options);\n  var node = one(h, tree);\n  var foot = footer(h);\n\n  if (foot) {\n    node.children = node.children.concat(u('text', '\\n'), foot);\n  }\n\n  return node;\n}","'use strict';\n\nmodule.exports = imageReference;\n\nvar normalize = require('mdurl/encode');\n\nvar revert = require('../revert');\n\nfunction imageReference(h, node) {\n  var def = h.definition(node.identifier);\n  var props;\n\n  if (!def) {\n    return revert(h, node);\n  }\n\n  props = {\n    src: normalize(def.url || ''),\n    alt: node.alt\n  };\n\n  if (def.title !== null && def.title !== undefined) {\n    props.title = def.title;\n  }\n\n  return h(node, 'img', props);\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';\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\nfunction markdownLineEndingOrSpace(code) {\n  return code < 0 || code === 32;\n}\n\nmodule.exports = markdownLineEndingOrSpace;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\nmodule.exports = asciiHexDigit;","'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;","var protocols = ['http', 'https', 'mailto', 'tel'];\nmodule.exports = uriTransformer;\n/**\n * @param {string} uri\n * @returns {string}\n */\n\nfunction 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 index = -1;\n\n  while (++index < protocols.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 types = require('./util/types');\n\nvar create = require('./util/create');\n\nvar caseInsensitiveTransform = require('./util/case-insensitive-transform');\n\nvar boolean = types.boolean;\nvar overloadedBoolean = types.overloadedBoolean;\nvar booleanish = types.booleanish;\nvar number = types.number;\nvar spaceSeparated = types.spaceSeparated;\nvar commaSeparated = types.commaSeparated;\nmodule.exports = create({\n  space: 'html',\n  attributes: {\n    acceptcharset: 'accept-charset',\n    classname: 'class',\n    htmlfor: 'for',\n    httpequiv: 'http-equiv'\n  },\n  transform: caseInsensitiveTransform,\n  mustUseProperty: ['checked', 'multiple', 'muted', 'selected'],\n  properties: {\n    // Standard Properties.\n    abbr: null,\n    accept: commaSeparated,\n    acceptCharset: spaceSeparated,\n    accessKey: spaceSeparated,\n    action: null,\n    allow: null,\n    allowFullScreen: boolean,\n    allowPaymentRequest: boolean,\n    allowUserMedia: boolean,\n    alt: null,\n    as: null,\n    async: boolean,\n    autoCapitalize: null,\n    autoComplete: spaceSeparated,\n    autoFocus: boolean,\n    autoPlay: boolean,\n    capture: boolean,\n    charSet: null,\n    checked: boolean,\n    cite: null,\n    className: spaceSeparated,\n    cols: number,\n    colSpan: null,\n    content: null,\n    contentEditable: booleanish,\n    controls: boolean,\n    controlsList: spaceSeparated,\n    coords: number | commaSeparated,\n    crossOrigin: null,\n    data: null,\n    dateTime: null,\n    decoding: null,\n    default: boolean,\n    defer: boolean,\n    dir: null,\n    dirName: null,\n    disabled: boolean,\n    download: overloadedBoolean,\n    draggable: booleanish,\n    encType: null,\n    enterKeyHint: null,\n    form: null,\n    formAction: null,\n    formEncType: null,\n    formMethod: null,\n    formNoValidate: boolean,\n    formTarget: null,\n    headers: spaceSeparated,\n    height: number,\n    hidden: boolean,\n    high: number,\n    href: null,\n    hrefLang: null,\n    htmlFor: spaceSeparated,\n    httpEquiv: spaceSeparated,\n    id: null,\n    imageSizes: null,\n    imageSrcSet: commaSeparated,\n    inputMode: null,\n    integrity: null,\n    is: null,\n    isMap: boolean,\n    itemId: null,\n    itemProp: spaceSeparated,\n    itemRef: spaceSeparated,\n    itemScope: boolean,\n    itemType: spaceSeparated,\n    kind: null,\n    label: null,\n    lang: null,\n    language: null,\n    list: null,\n    loading: null,\n    loop: boolean,\n    low: number,\n    manifest: null,\n    max: null,\n    maxLength: number,\n    media: null,\n    method: null,\n    min: null,\n    minLength: number,\n    multiple: boolean,\n    muted: boolean,\n    name: null,\n    nonce: null,\n    noModule: boolean,\n    noValidate: boolean,\n    onAbort: null,\n    onAfterPrint: null,\n    onAuxClick: null,\n    onBeforePrint: null,\n    onBeforeUnload: null,\n    onBlur: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onContextMenu: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFormData: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLanguageChange: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadEnd: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMessageError: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRejectionHandled: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onSecurityPolicyViolation: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onSlotChange: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnhandledRejection: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onWheel: null,\n    open: boolean,\n    optimum: number,\n    pattern: null,\n    ping: spaceSeparated,\n    placeholder: null,\n    playsInline: boolean,\n    poster: null,\n    preload: null,\n    readOnly: boolean,\n    referrerPolicy: null,\n    rel: spaceSeparated,\n    required: boolean,\n    reversed: boolean,\n    rows: number,\n    rowSpan: number,\n    sandbox: spaceSeparated,\n    scope: null,\n    scoped: boolean,\n    seamless: boolean,\n    selected: boolean,\n    shape: null,\n    size: number,\n    sizes: null,\n    slot: null,\n    span: number,\n    spellCheck: booleanish,\n    src: null,\n    srcDoc: null,\n    srcLang: null,\n    srcSet: commaSeparated,\n    start: number,\n    step: null,\n    style: null,\n    tabIndex: number,\n    target: null,\n    title: null,\n    translate: null,\n    type: null,\n    typeMustMatch: boolean,\n    useMap: null,\n    value: booleanish,\n    width: number,\n    wrap: null,\n    // Legacy.\n    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis\n    align: null,\n    // Several. Use CSS `text-align` instead,\n    aLink: null,\n    // `<body>`. Use CSS `a:active {color}` instead\n    archive: spaceSeparated,\n    // `<object>`. List of URIs to archives\n    axis: null,\n    // `<td>` and `<th>`. Use `scope` on `<th>`\n    background: null,\n    // `<body>`. Use CSS `background-image` instead\n    bgColor: null,\n    // `<body>` and table elements. Use CSS `background-color` instead\n    border: number,\n    // `<table>`. Use CSS `border-width` instead,\n    borderColor: null,\n    // `<table>`. Use CSS `border-color` instead,\n    bottomMargin: number,\n    // `<body>`\n    cellPadding: null,\n    // `<table>`\n    cellSpacing: null,\n    // `<table>`\n    char: null,\n    // Several table elements. When `align=char`, sets the character to align on\n    charOff: null,\n    // Several table elements. When `char`, offsets the alignment\n    classId: null,\n    // `<object>`\n    clear: null,\n    // `<br>`. Use CSS `clear` instead\n    code: null,\n    // `<object>`\n    codeBase: null,\n    // `<object>`\n    codeType: null,\n    // `<object>`\n    color: null,\n    // `<font>` and `<hr>`. Use CSS instead\n    compact: boolean,\n    // Lists. Use CSS to reduce space between items instead\n    declare: boolean,\n    // `<object>`\n    event: null,\n    // `<script>`\n    face: null,\n    // `<font>`. Use CSS instead\n    frame: null,\n    // `<table>`\n    frameBorder: null,\n    // `<iframe>`. Use CSS `border` instead\n    hSpace: number,\n    // `<img>` and `<object>`\n    leftMargin: number,\n    // `<body>`\n    link: null,\n    // `<body>`. Use CSS `a:link {color: *}` instead\n    longDesc: null,\n    // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`\n    lowSrc: null,\n    // `<img>`. Use a `<picture>`\n    marginHeight: number,\n    // `<body>`\n    marginWidth: number,\n    // `<body>`\n    noResize: boolean,\n    // `<frame>`\n    noHref: boolean,\n    // `<area>`. Use no href instead of an explicit `nohref`\n    noShade: boolean,\n    // `<hr>`. Use background-color and height instead of borders\n    noWrap: boolean,\n    // `<td>` and `<th>`\n    object: null,\n    // `<applet>`\n    profile: null,\n    // `<head>`\n    prompt: null,\n    // `<isindex>`\n    rev: null,\n    // `<link>`\n    rightMargin: number,\n    // `<body>`\n    rules: null,\n    // `<table>`\n    scheme: null,\n    // `<meta>`\n    scrolling: booleanish,\n    // `<frame>`. Use overflow in the child context\n    standby: null,\n    // `<object>`\n    summary: null,\n    // `<table>`\n    text: null,\n    // `<body>`. Use CSS `color` instead\n    topMargin: number,\n    // `<body>`\n    valueType: null,\n    // `<param>`\n    version: null,\n    // `<html>`. Use a doctype.\n    vAlign: null,\n    // Several. Use CSS `vertical-align` instead\n    vLink: null,\n    // `<body>`. Use CSS `a:visited {color}` instead\n    vSpace: number,\n    // `<img>` and `<object>`\n    // Non-standard Properties.\n    allowTransparency: null,\n    autoCorrect: null,\n    autoSave: null,\n    disablePictureInPicture: boolean,\n    disableRemotePlayback: boolean,\n    prefix: null,\n    property: null,\n    results: number,\n    security: null,\n    unselectable: null\n  }\n});","'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\nmodule.exports = footnoteReference;\n\nvar u = require('unist-builder');\n\nfunction footnoteReference(h, node) {\n  var footnoteOrder = h.footnoteOrder;\n  var identifier = String(node.identifier);\n\n  if (footnoteOrder.indexOf(identifier) === -1) {\n    footnoteOrder.push(identifier);\n  }\n\n  return h(node.position, 'sup', {\n    id: 'fnref-' + identifier\n  }, [h(node, 'a', {\n    href: '#fn-' + identifier,\n    className: ['footnote-ref']\n  }, [u('text', node.label || identifier)])]);\n}","'use strict';\n\nvar assign = require('../constant/assign.js');\n\nfunction shallow(object) {\n  return assign({}, object);\n}\n\nmodule.exports = shallow;","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = own;","'use strict';\n\nexports.parse = parse;\nexports.stringify = stringify;\nvar empty = '';\nvar space = ' ';\nvar whiteSpace = /[ \\t\\n\\r\\f]+/g;\n\nfunction parse(value) {\n  var input = String(value || empty).trim();\n  return input === empty ? [] : input.split(whiteSpace);\n}\n\nfunction stringify(values) {\n  return values.join(space).trim();\n}","'use strict';\n\nmodule.exports = paragraph;\n\nvar all = require('../all');\n\nfunction paragraph(h, node) {\n  return h(node, 'p', all(h, node));\n}","'use strict';\n\nmodule.exports = hardBreak;\n\nvar u = require('unist-builder');\n\nfunction hardBreak(h, node) {\n  return [h(node, 'br'), u('text', '\\n')];\n}","module.exports = extend;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n  var target = {};\n\n  for (var i = 0; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n}","'use strict';\n\nmodule.exports = wrap;\n\nvar u = require('unist-builder'); // Wrap `nodes` with line feeds between each entry.\n// Optionally adds line feeds at the start and end.\n\n\nfunction wrap(nodes, loose) {\n  var result = [];\n  var index = -1;\n  var length = nodes.length;\n\n  if (loose) {\n    result.push(u('text', '\\n'));\n  }\n\n  while (++index < length) {\n    if (index) {\n      result.push(u('text', '\\n'));\n    }\n\n    result.push(nodes[index]);\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push(u('text', '\\n'));\n  }\n\n  return result;\n}","'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\nmodule.exports = Info;\nvar proto = Info.prototype;\nproto.space = null;\nproto.attribute = null;\nproto.property = null;\nproto.boolean = false;\nproto.booleanish = false;\nproto.overloadedBoolean = false;\nproto.number = false;\nproto.commaSeparated = false;\nproto.spaceSeparated = false;\nproto.commaOrSpaceSeparated = false;\nproto.mustUseProperty = false;\nproto.defined = false;\n\nfunction Info(property, attribute) {\n  this.property = property;\n  this.attribute = attribute;\n}","'use strict';\n\nmodule.exports = linkReference;\n\nvar normalize = require('mdurl/encode');\n\nvar revert = require('../revert');\n\nvar all = require('../all');\n\nfunction linkReference(h, node) {\n  var def = h.definition(node.identifier);\n  var props;\n\n  if (!def) {\n    return revert(h, node);\n  }\n\n  props = {\n    href: normalize(def.url || '')\n  };\n\n  if (def.title !== null && def.title !== undefined) {\n    props.title = def.title;\n  }\n\n  return h(node, 'a', props, all(h, node));\n}","'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\nmodule.exports = generated;\n\nfunction generated(node) {\n  return !node || !node.position || !node.position.start || !node.position.start.line || !node.position.start.column || !node.position.end || !node.position.end.line || !node.position.end.column;\n}","'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/* 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\nmodule.exports = list;\n\nvar wrap = require('../wrap');\n\nvar all = require('../all');\n\nfunction list(h, node) {\n  var props = {};\n  var name = node.ordered ? 'ol' : 'ul';\n  var items;\n  var index = -1;\n  var length;\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    props.start = node.start;\n  }\n\n  items = all(h, node);\n  length = items.length; // Like GitHub, add a class for custom styling.\n\n  while (++index < length) {\n    if (items[index].properties.className && items[index].properties.className.indexOf('task-list-item') !== -1) {\n      props.className = ['contains-task-list'];\n      break;\n    }\n  }\n\n  return h(node, name, props, wrap(items, true));\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}","/** @license React v17.0.2\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';\n\nvar b = 60103,\n    c = 60106,\n    d = 60107,\n    e = 60108,\n    f = 60114,\n    g = 60109,\n    h = 60110,\n    k = 60112,\n    l = 60113,\n    m = 60120,\n    n = 60115,\n    p = 60116,\n    q = 60121,\n    r = 60122,\n    u = 60117,\n    v = 60129,\n    w = 60131;\n\nif (\"function\" === typeof Symbol && Symbol.for) {\n  var x = Symbol.for;\n  b = x(\"react.element\");\n  c = x(\"react.portal\");\n  d = x(\"react.fragment\");\n  e = x(\"react.strict_mode\");\n  f = x(\"react.profiler\");\n  g = x(\"react.provider\");\n  h = x(\"react.context\");\n  k = x(\"react.forward_ref\");\n  l = x(\"react.suspense\");\n  m = x(\"react.suspense_list\");\n  n = x(\"react.memo\");\n  p = x(\"react.lazy\");\n  q = x(\"react.block\");\n  r = x(\"react.server.block\");\n  u = x(\"react.fundamental\");\n  v = x(\"react.debug_trace_mode\");\n  w = x(\"react.legacy_hidden\");\n}\n\nfunction y(a) {\n  if (\"object\" === typeof a && null !== a) {\n    var t = a.$$typeof;\n\n    switch (t) {\n      case b:\n        switch (a = a.type, a) {\n          case d:\n          case f:\n          case e:\n          case l:\n          case m:\n            return a;\n\n          default:\n            switch (a = a && a.$$typeof, a) {\n              case h:\n              case k:\n              case p:\n              case n:\n              case g:\n                return a;\n\n              default:\n                return t;\n            }\n\n        }\n\n      case c:\n        return t;\n    }\n  }\n}\n\nvar z = g,\n    A = b,\n    B = k,\n    C = d,\n    D = p,\n    E = n,\n    F = c,\n    G = f,\n    H = e,\n    I = l;\nexports.ContextConsumer = h;\nexports.ContextProvider = z;\nexports.Element = A;\nexports.ForwardRef = B;\nexports.Fragment = C;\nexports.Lazy = D;\nexports.Memo = E;\nexports.Portal = F;\nexports.Profiler = G;\nexports.StrictMode = H;\nexports.Suspense = I;\n\nexports.isAsyncMode = function () {\n  return !1;\n};\n\nexports.isConcurrentMode = function () {\n  return !1;\n};\n\nexports.isContextConsumer = function (a) {\n  return y(a) === h;\n};\n\nexports.isContextProvider = function (a) {\n  return y(a) === g;\n};\n\nexports.isElement = function (a) {\n  return \"object\" === typeof a && null !== a && a.$$typeof === b;\n};\n\nexports.isForwardRef = function (a) {\n  return y(a) === k;\n};\n\nexports.isFragment = function (a) {\n  return y(a) === d;\n};\n\nexports.isLazy = function (a) {\n  return y(a) === p;\n};\n\nexports.isMemo = function (a) {\n  return y(a) === n;\n};\n\nexports.isPortal = function (a) {\n  return y(a) === c;\n};\n\nexports.isProfiler = function (a) {\n  return y(a) === f;\n};\n\nexports.isStrictMode = function (a) {\n  return y(a) === e;\n};\n\nexports.isSuspense = function (a) {\n  return y(a) === l;\n};\n\nexports.isValidElementType = function (a) {\n  return \"string\" === typeof a || \"function\" === typeof a || a === d || a === f || a === v || a === e || a === l || a === m || a === w || \"object\" === typeof a && null !== a && (a.$$typeof === p || a.$$typeof === n || a.$$typeof === g || a.$$typeof === h || a.$$typeof === k || a.$$typeof === u || a.$$typeof === q || a[0] === r) ? !0 : !1;\n};\n\nexports.typeOf = y;","'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\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\nvar normalize = require('mdurl/encode');\n\nvar all = require('../all');\n\nmodule.exports = link;\n\nfunction link(h, node) {\n  var props = {\n    href: normalize(node.url)\n  };\n\n  if (node.title !== null && node.title !== undefined) {\n    props.title = node.title;\n  }\n\n  return h(node, 'a', props, all(h, node));\n}","'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 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\nmodule.exports = {\n  blockquote: require('./blockquote'),\n  break: require('./break'),\n  code: require('./code'),\n  delete: require('./delete'),\n  emphasis: require('./emphasis'),\n  footnoteReference: require('./footnote-reference'),\n  footnote: require('./footnote'),\n  heading: require('./heading'),\n  html: require('./html'),\n  imageReference: require('./image-reference'),\n  image: require('./image'),\n  inlineCode: require('./inline-code'),\n  linkReference: require('./link-reference'),\n  link: require('./link'),\n  listItem: require('./list-item'),\n  list: require('./list'),\n  paragraph: require('./paragraph'),\n  root: require('./root'),\n  strong: require('./strong'),\n  table: require('./table'),\n  text: require('./text'),\n  thematicBreak: require('./thematic-break'),\n  toml: ignore,\n  yaml: ignore,\n  definition: ignore,\n  footnoteDefinition: ignore\n}; // Return nothing for nodes that are ignored.\n\nfunction ignore() {\n  return null;\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\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 = normalize;\n\nfunction normalize(value) {\n  return value.toLowerCase();\n}","'use strict';\n\nvar types = require('./util/types');\n\nvar create = require('./util/create');\n\nvar booleanish = types.booleanish;\nvar number = types.number;\nvar spaceSeparated = types.spaceSeparated;\nmodule.exports = create({\n  transform: ariaTransform,\n  properties: {\n    ariaActiveDescendant: null,\n    ariaAtomic: booleanish,\n    ariaAutoComplete: null,\n    ariaBusy: booleanish,\n    ariaChecked: booleanish,\n    ariaColCount: number,\n    ariaColIndex: number,\n    ariaColSpan: number,\n    ariaControls: spaceSeparated,\n    ariaCurrent: null,\n    ariaDescribedBy: spaceSeparated,\n    ariaDetails: null,\n    ariaDisabled: booleanish,\n    ariaDropEffect: spaceSeparated,\n    ariaErrorMessage: null,\n    ariaExpanded: booleanish,\n    ariaFlowTo: spaceSeparated,\n    ariaGrabbed: booleanish,\n    ariaHasPopup: null,\n    ariaHidden: booleanish,\n    ariaInvalid: null,\n    ariaKeyShortcuts: null,\n    ariaLabel: null,\n    ariaLabelledBy: spaceSeparated,\n    ariaLevel: number,\n    ariaLive: null,\n    ariaModal: booleanish,\n    ariaMultiLine: booleanish,\n    ariaMultiSelectable: booleanish,\n    ariaOrientation: null,\n    ariaOwns: spaceSeparated,\n    ariaPlaceholder: null,\n    ariaPosInSet: number,\n    ariaPressed: booleanish,\n    ariaReadOnly: booleanish,\n    ariaRelevant: null,\n    ariaRequired: booleanish,\n    ariaRoleDescription: spaceSeparated,\n    ariaRowCount: number,\n    ariaRowIndex: number,\n    ariaRowSpan: number,\n    ariaSelected: booleanish,\n    ariaSetSize: number,\n    ariaSort: null,\n    ariaValueMax: number,\n    ariaValueMin: number,\n    ariaValueNow: number,\n    ariaValueText: null,\n    role: null\n  }\n});\n\nfunction ariaTransform(_, prop) {\n  return prop === 'role' ? prop : 'aria-' + prop.slice(4).toLowerCase();\n}","/*!\n * 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\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\nmodule.exports = Schema;\nvar proto = Schema.prototype;\nproto.space = null;\nproto.normal = {};\nproto.property = {};\n\nfunction Schema(property, normal, space) {\n  this.property = property;\n  this.normal = normal;\n\n  if (space) {\n    this.space = space;\n  }\n}","'use strict';\n\nvar create = require('./util/create');\n\nvar caseInsensitiveTransform = require('./util/case-insensitive-transform');\n\nmodule.exports = create({\n  space: 'xmlns',\n  attributes: {\n    xmlnsxlink: 'xmlns:xlink'\n  },\n  transform: caseInsensitiveTransform,\n  properties: {\n    xmlns: null,\n    xmlnsXLink: null\n  }\n});","'use strict';\n\nmodule.exports = generateFootnotes;\n\nvar thematicBreak = require('./handlers/thematic-break');\n\nvar list = require('./handlers/list');\n\nvar wrap = require('./wrap');\n\nfunction generateFootnotes(h) {\n  var footnoteById = h.footnoteById;\n  var footnoteOrder = h.footnoteOrder;\n  var length = footnoteOrder.length;\n  var index = -1;\n  var listItems = [];\n  var def;\n  var backReference;\n  var content;\n  var tail;\n\n  while (++index < length) {\n    def = footnoteById[footnoteOrder[index].toUpperCase()];\n\n    if (!def) {\n      continue;\n    }\n\n    content = def.children.concat();\n    tail = content[content.length - 1];\n    backReference = {\n      type: 'link',\n      url: '#fnref-' + def.identifier,\n      data: {\n        hProperties: {\n          className: ['footnote-backref']\n        }\n      },\n      children: [{\n        type: 'text',\n        value: '↩'\n      }]\n    };\n\n    if (!tail || tail.type !== 'paragraph') {\n      tail = {\n        type: 'paragraph',\n        children: []\n      };\n      content.push(tail);\n    }\n\n    tail.children.push(backReference);\n    listItems.push({\n      type: 'listItem',\n      data: {\n        hProperties: {\n          id: 'fn-' + def.identifier\n        }\n      },\n      children: content,\n      position: def.position\n    });\n  }\n\n  if (listItems.length === 0) {\n    return null;\n  }\n\n  return h(null, 'div', {\n    className: ['footnotes']\n  }, wrap([thematicBreak(h), list(h, {\n    type: 'list',\n    ordered: true,\n    children: listItems\n  })], true));\n}","'use strict';\n\nvar create = require('./util/create');\n\nmodule.exports = create({\n  space: 'xlink',\n  transform: xlinkTransform,\n  properties: {\n    xLinkActuate: null,\n    xLinkArcRole: null,\n    xLinkHref: null,\n    xLinkRole: null,\n    xLinkShow: null,\n    xLinkTitle: null,\n    xLinkType: null\n  }\n});\n\nfunction xlinkTransform(_, prop) {\n  return 'xlink:' + prop.slice(5).toLowerCase();\n}","'use strict';\n\nmodule.exports = strong;\n\nvar all = require('../all');\n\nfunction strong(h, node) {\n  return h(node, 'strong', all(h, node));\n}","'use strict';\n\nmodule.exports = u;\n\nfunction u(type, props, value) {\n  var node;\n\n  if ((value === null || value === undefined) && (typeof props !== 'object' || Array.isArray(props))) {\n    value = props;\n    props = {};\n  }\n\n  node = Object.assign({\n    type: String(type)\n  }, props);\n\n  if (Array.isArray(value)) {\n    node.children = value;\n  } else if (value !== null && value !== undefined) {\n    node.value = String(value);\n  }\n\n  return node;\n}","'use strict';\n\nvar create = require('./util/create');\n\nmodule.exports = create({\n  space: 'xml',\n  transform: xmlTransform,\n  properties: {\n    xmlLang: null,\n    xmlBase: null,\n    xmlSpace: null\n  }\n});\n\nfunction xmlTransform(_, prop) {\n  return 'xml:' + prop.slice(3).toLowerCase();\n}","'use strict';\n\nvar mdast2hast = require('mdast-util-to-hast');\n\nmodule.exports = remark2rehype; // Attacher.\n// If a destination is given, runs the destination with the new hast tree\n// (bridge mode).\n// Without destination, returns the tree: further plugins run on that tree\n// (mutate mode).\n\nfunction remark2rehype(destination, options) {\n  if (destination && !destination.process) {\n    options = destination;\n    destination = null;\n  }\n\n  return destination ? bridge(destination, options) : mutate(options);\n} // Bridge mode.\n// Runs the destination with the new hast tree.\n\n\nfunction bridge(destination, options) {\n  return transformer;\n\n  function transformer(node, file, next) {\n    destination.run(mdast2hast(node, options), file, done);\n\n    function done(error) {\n      next(error);\n    }\n  }\n} // Mutate-mode.\n// Further transformers run on the hast tree.\n\n\nfunction mutate(options) {\n  return transformer;\n\n  function transformer(node) {\n    return mdast2hast(node, options);\n  }\n}","'use strict';\n\nvar factorySpace = require('./factory-space.js');\n\nvar lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\n\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n\n  function start(code) {\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, ok, 'linePrefix');\n  }\n}\n\nmodule.exports = lineEnding;","'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\nmodule.exports = listItem;\n\nvar u = require('unist-builder');\n\nvar all = require('../all');\n\nfunction listItem(h, node, parent) {\n  var result = all(h, node);\n  var head = result[0];\n  var loose = parent ? listLoose(parent) : listItemLoose(node);\n  var props = {};\n  var wrapped = [];\n  var length;\n  var index;\n  var child;\n\n  if (typeof node.checked === 'boolean') {\n    if (!head || head.tagName !== 'p') {\n      head = h(null, 'p', []);\n      result.unshift(head);\n    }\n\n    if (head.children.length > 0) {\n      head.children.unshift(u('text', ' '));\n    }\n\n    head.children.unshift(h(null, 'input', {\n      type: 'checkbox',\n      checked: node.checked,\n      disabled: true\n    })); // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n\n    props.className = ['task-list-item'];\n  }\n\n  length = result.length;\n  index = -1;\n\n  while (++index < length) {\n    child = result[index]; // Add eols before nodes, except if this is a loose, first paragraph.\n\n    if (loose || index !== 0 || child.tagName !== 'p') {\n      wrapped.push(u('text', '\\n'));\n    }\n\n    if (child.tagName === 'p' && !loose) {\n      wrapped = wrapped.concat(child.children);\n    } else {\n      wrapped.push(child);\n    }\n  } // Add a final eol.\n\n\n  if (length && (loose || child.tagName !== 'p')) {\n    wrapped.push(u('text', '\\n'));\n  }\n\n  return h(node, 'li', props, wrapped);\n}\n\nfunction listLoose(node) {\n  var loose = node.spread;\n  var children = node.children;\n  var length = children.length;\n  var index = -1;\n\n  while (!loose && ++index < length) {\n    loose = listItemLoose(children[index]);\n  }\n\n  return loose;\n}\n\nfunction listItemLoose(node) {\n  var spread = node.spread;\n  return spread === undefined || spread === null ? node.children.length > 1 : spread;\n}","'use strict';\n\nmodule.exports = text;\n\nvar u = require('unist-builder');\n\nfunction text(h, node) {\n  return h.augment(node, u('text', String(node.value).replace(/[ \\t]*(\\r?\\n|\\r)[ \\t]*/g, '$1')));\n}","'use strict';\n\nvar markdownLineEnding = require('../character/markdown-line-ending.js');\n\nvar hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  function start(code) {\n    effects.enter('hardBreakEscape');\n    effects.enter('escapeMarker');\n    effects.consume(code);\n    return open;\n  }\n\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker');\n      effects.exit('hardBreakEscape');\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n\nmodule.exports = hardBreakEscape;","'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 regexCheck = require('../util/regex-check.js');\n\nvar asciiAlpha = regexCheck(/[A-Za-z]/);\nmodule.exports = asciiAlpha;","'use strict';\n\nmodule.exports = emphasis;\n\nvar all = require('../all');\n\nfunction emphasis(h, node) {\n  return h(node, 'em', all(h, node));\n}","'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\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 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 regexCheck = require('../util/regex-check.js');\n\nvar asciiDigit = regexCheck(/\\d/);\nmodule.exports = asciiDigit;","'use strict';\n\nmodule.exports = one;\n\nvar u = require('unist-builder');\n\nvar all = require('./all');\n\nvar own = {}.hasOwnProperty; // Transform an unknown node.\n\nfunction unknown(h, node) {\n  if (text(node)) {\n    return h.augment(node, u('text', node.value));\n  }\n\n  return h(node, 'div', all(h, node));\n} // Visit a node.\n\n\nfunction one(h, node, parent) {\n  var type = node && node.type;\n  var fn; // Fail on non-nodes.\n\n  if (!type) {\n    throw new Error('Expected node, got `' + node + '`');\n  }\n\n  if (own.call(h.handlers, type)) {\n    fn = h.handlers[type];\n  } else if (h.passThrough && h.passThrough.indexOf(type) > -1) {\n    fn = returnNode;\n  } else {\n    fn = h.unknownHandler;\n  }\n\n  return (typeof fn === 'function' ? fn : unknown)(h, node, parent);\n} // Check if the node should be renderered as a text node.\n\n\nfunction text(node) {\n  var data = node.data || {};\n\n  if (own.call(data, 'hName') || own.call(data, 'hProperties') || own.call(data, 'hChildren')) {\n    return false;\n  }\n\n  return 'value' in node;\n}\n\nfunction returnNode(h, node) {\n  var clone;\n\n  if (node.children) {\n    clone = Object.assign({}, node);\n    clone.children = all(h, node);\n    return clone;\n  }\n\n  return node;\n}","'use strict';\n\nmodule.exports = visitParents;\n\nvar convert = require('unist-util-is/convert');\n\nvar color = require('./color');\n\nvar CONTINUE = true;\nvar SKIP = 'skip';\nvar EXIT = false;\nvisitParents.CONTINUE = CONTINUE;\nvisitParents.SKIP = SKIP;\nvisitParents.EXIT = EXIT;\n\nfunction visitParents(tree, test, visitor, reverse) {\n  var step;\n  var is;\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n\n  is = convert(test);\n  step = reverse ? -1 : 1;\n  factory(tree, null, [])();\n\n  function factory(node, index, parents) {\n    var value = typeof node === 'object' && node !== null ? node : {};\n    var name;\n\n    if (typeof value.type === 'string') {\n      name = typeof value.tagName === 'string' ? value.tagName : typeof value.name === 'string' ? value.name : undefined;\n      visit.displayName = 'node (' + color(value.type + (name ? '<' + name + '>' : '')) + ')';\n    }\n\n    return visit;\n\n    function visit() {\n      var grandparents = parents.concat(node);\n      var result = [];\n      var subresult;\n      var offset;\n\n      if (!test || is(node, index, parents[parents.length - 1] || null)) {\n        result = toResult(visitor(node, parents));\n\n        if (result[0] === EXIT) {\n          return result;\n        }\n      }\n\n      if (node.children && result[0] !== SKIP) {\n        offset = (reverse ? node.children.length : -1) + step;\n\n        while (offset > -1 && offset < node.children.length) {\n          subresult = factory(node.children[offset], offset, grandparents)();\n\n          if (subresult[0] === EXIT) {\n            return subresult;\n          }\n\n          offset = typeof subresult[1] === 'number' ? subresult[1] : offset + step;\n        }\n      }\n\n      return result;\n    }\n  }\n}\n\nfunction toResult(value) {\n  if (value !== null && typeof value === 'object' && 'length' in value) {\n    return value;\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value];\n  }\n\n  return [value];\n}","'use strict';\n\nvar 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 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\nmodule.exports = code;\n\nvar u = require('unist-builder');\n\nfunction code(h, node) {\n  var value = node.value ? node.value + '\\n' : ''; // To do: next major, use `node.lang` w/o regex, the splitting’s been going\n  // on for years in remark now.\n\n  var lang = node.lang && node.lang.match(/^[^ \\t]+(?=[ \\t]|$)/);\n  var props = {};\n  var code;\n\n  if (lang) {\n    props.className = ['language-' + lang];\n  }\n\n  code = h(node, 'code', props, [u('text', value)]);\n\n  if (node.meta) {\n    code.data = {\n      meta: node.meta\n    };\n  }\n\n  return h(node.position, 'pre', [code]);\n}","'use strict';\n\nfunction miniflat(value) {\n  return value === null || value === undefined ? [] : 'length' in value ? value : [value];\n}\n\nmodule.exports = miniflat;","'use strict';\n\nvar regexCheck = require('../util/regex-check.js');\n\nvar asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\nmodule.exports = asciiPunctuation;","'use strict';\n\nvar Info = require('./info');\n\nvar types = require('./types');\n\nmodule.exports = DefinedInfo;\nDefinedInfo.prototype = new Info();\nDefinedInfo.prototype.defined = true;\nvar checks = ['boolean', 'booleanish', 'overloadedBoolean', 'number', 'commaSeparated', 'spaceSeparated', 'commaOrSpaceSeparated'];\nvar checksLength = checks.length;\n\nfunction DefinedInfo(property, attribute, mask, space) {\n  var index = -1;\n  var check;\n  mark(this, 'space', space);\n  Info.call(this, property, attribute);\n\n  while (++index < checksLength) {\n    check = checks[index];\n    mark(this, check, (mask & types[check]) === types[check]);\n  }\n}\n\nfunction mark(values, key, value) {\n  if (value) {\n    values[key] = value;\n  }\n}","'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\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}","'use strict';\n\nvar 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\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 regexCheck = require('../util/regex-check.js');\n\nvar unicodeWhitespace = regexCheck(/\\s/);\nmodule.exports = unicodeWhitespace;","'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';\n\nmodule.exports = thematicBreak;\n\nfunction thematicBreak(h, node) {\n  return h(node, 'hr');\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\nmodule.exports = caseSensitiveTransform;\n\nfunction caseSensitiveTransform(attributes, attribute) {\n  return attribute in attributes ? attributes[attribute] : attribute;\n}","'use strict';\n\nexports.parse = parse;\nexports.stringify = stringify;\nvar comma = ',';\nvar space = ' ';\nvar empty = ''; // Parse comma-separated tokens to an array.\n\nfunction parse(value) {\n  var values = [];\n  var input = String(value || empty);\n  var index = input.indexOf(comma);\n  var lastIndex = 0;\n  var end = false;\n  var val;\n\n  while (!end) {\n    if (index === -1) {\n      index = input.length;\n      end = true;\n    }\n\n    val = input.slice(lastIndex, index).trim();\n\n    if (val || !end) {\n      values.push(val);\n    }\n\n    lastIndex = index + 1;\n    index = input.indexOf(comma, lastIndex);\n  }\n\n  return values;\n} // Compile an array to comma-separated tokens.\n// `options.padLeft` (default: `true`) pads a space left of each token, and\n// `options.padRight` (default: `false`) pads a space to the right of each token.\n\n\nfunction stringify(values, options) {\n  var settings = options || {};\n  var left = settings.padLeft === false ? empty : space;\n  var right = settings.padRight ? space : empty; // Ensure the last empty entry is seen.\n\n  if (values[values.length - 1] === empty) {\n    values = values.concat(empty);\n  }\n\n  return values.join(right + comma + left).trim();\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 = inlineCode;\n\nvar u = require('unist-builder');\n\nfunction inlineCode(h, node) {\n  var value = node.value.replace(/\\r?\\n|\\r/g, ' ');\n  return h(node, 'code', [u('text', value)]);\n}","'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\nvar encodeCache = {}; // Create a lookup array where anything but characters in `chars` string\n// and alphanumeric chars is percent-encoded.\n//\n\nfunction getEncodeCache(exclude) {\n  var i,\n      ch,\n      cache = encodeCache[exclude];\n\n  if (cache) {\n    return cache;\n  }\n\n  cache = encodeCache[exclude] = [];\n\n  for (i = 0; i < 128; i++) {\n    ch = String.fromCharCode(i);\n\n    if (/^[0-9a-z]$/i.test(ch)) {\n      // always allow unencoded alphanumeric characters\n      cache.push(ch);\n    } else {\n      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));\n    }\n  }\n\n  for (i = 0; i < exclude.length; i++) {\n    cache[exclude.charCodeAt(i)] = exclude[i];\n  }\n\n  return cache;\n} // Encode unsafe characters with percent-encoding, skipping already\n// encoded sequences.\n//\n//  - string       - string to encode\n//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)\n//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)\n//\n\n\nfunction encode(string, exclude, keepEscaped) {\n  var i,\n      l,\n      code,\n      nextCode,\n      cache,\n      result = '';\n\n  if (typeof exclude !== 'string') {\n    // encode(string, keepEscaped)\n    keepEscaped = exclude;\n    exclude = encode.defaultChars;\n  }\n\n  if (typeof keepEscaped === 'undefined') {\n    keepEscaped = true;\n  }\n\n  cache = getEncodeCache(exclude);\n\n  for (i = 0, l = string.length; i < l; i++) {\n    code = string.charCodeAt(i);\n\n    if (keepEscaped && code === 0x25\n    /* % */\n    && i + 2 < l) {\n      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {\n        result += string.slice(i, i + 3);\n        i += 2;\n        continue;\n      }\n    }\n\n    if (code < 128) {\n      result += cache[code];\n      continue;\n    }\n\n    if (code >= 0xD800 && code <= 0xDFFF) {\n      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {\n        nextCode = string.charCodeAt(i + 1);\n\n        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {\n          result += encodeURIComponent(string[i] + string[i + 1]);\n          i++;\n          continue;\n        }\n      }\n\n      result += '%EF%BF%BD';\n      continue;\n    }\n\n    result += encodeURIComponent(string[i]);\n  }\n\n  return result;\n}\n\nencode.defaultChars = \";/?:@&=+$,-_.!~*'()#\";\nencode.componentChars = \"-_.!~*'()\";\nmodule.exports = encode;","'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 caseSensitiveTransform = require('./case-sensitive-transform');\n\nmodule.exports = caseInsensitiveTransform;\n\nfunction caseInsensitiveTransform(attributes, property) {\n  return caseSensitiveTransform(attributes, property.toLowerCase());\n}","'use strict';\n\nvar markdownSpace = require('../character/markdown-space.js');\n\nfunction spaceFactory(effects, ok, type, max) {\n  var limit = max ? max - 1 : Infinity;\n  var size = 0;\n  return start;\n\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n\n    return ok(code);\n  }\n\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n\n    effects.exit(type);\n    return ok(code);\n  }\n}\n\nmodule.exports = spaceFactory;","'use strict';\n\nmodule.exports = blockquote;\n\nvar wrap = require('../wrap');\n\nvar all = require('../all');\n\nfunction blockquote(h, node) {\n  return h(node, 'blockquote', wrap(all(h, node), true));\n}","'use strict';\n\nvar xtend = require('xtend');\n\nvar Schema = require('./schema');\n\nmodule.exports = merge;\n\nfunction merge(definitions) {\n  var length = definitions.length;\n  var property = [];\n  var normal = [];\n  var index = -1;\n  var info;\n  var space;\n\n  while (++index < length) {\n    info = definitions[index];\n    property.push(info.property);\n    normal.push(info.normal);\n    space = info.space;\n  }\n\n  return new Schema(xtend.apply(null, property), xtend.apply(null, normal), space);\n}","'use strict';\n\nvar types = require('./util/types');\n\nvar create = require('./util/create');\n\nvar caseSensitiveTransform = require('./util/case-sensitive-transform');\n\nvar boolean = types.boolean;\nvar number = types.number;\nvar spaceSeparated = types.spaceSeparated;\nvar commaSeparated = types.commaSeparated;\nvar commaOrSpaceSeparated = types.commaOrSpaceSeparated;\nmodule.exports = create({\n  space: 'svg',\n  attributes: {\n    accentHeight: 'accent-height',\n    alignmentBaseline: 'alignment-baseline',\n    arabicForm: 'arabic-form',\n    baselineShift: 'baseline-shift',\n    capHeight: 'cap-height',\n    className: 'class',\n    clipPath: 'clip-path',\n    clipRule: 'clip-rule',\n    colorInterpolation: 'color-interpolation',\n    colorInterpolationFilters: 'color-interpolation-filters',\n    colorProfile: 'color-profile',\n    colorRendering: 'color-rendering',\n    crossOrigin: 'crossorigin',\n    dataType: 'datatype',\n    dominantBaseline: 'dominant-baseline',\n    enableBackground: 'enable-background',\n    fillOpacity: 'fill-opacity',\n    fillRule: 'fill-rule',\n    floodColor: 'flood-color',\n    floodOpacity: 'flood-opacity',\n    fontFamily: 'font-family',\n    fontSize: 'font-size',\n    fontSizeAdjust: 'font-size-adjust',\n    fontStretch: 'font-stretch',\n    fontStyle: 'font-style',\n    fontVariant: 'font-variant',\n    fontWeight: 'font-weight',\n    glyphName: 'glyph-name',\n    glyphOrientationHorizontal: 'glyph-orientation-horizontal',\n    glyphOrientationVertical: 'glyph-orientation-vertical',\n    hrefLang: 'hreflang',\n    horizAdvX: 'horiz-adv-x',\n    horizOriginX: 'horiz-origin-x',\n    horizOriginY: 'horiz-origin-y',\n    imageRendering: 'image-rendering',\n    letterSpacing: 'letter-spacing',\n    lightingColor: 'lighting-color',\n    markerEnd: 'marker-end',\n    markerMid: 'marker-mid',\n    markerStart: 'marker-start',\n    navDown: 'nav-down',\n    navDownLeft: 'nav-down-left',\n    navDownRight: 'nav-down-right',\n    navLeft: 'nav-left',\n    navNext: 'nav-next',\n    navPrev: 'nav-prev',\n    navRight: 'nav-right',\n    navUp: 'nav-up',\n    navUpLeft: 'nav-up-left',\n    navUpRight: 'nav-up-right',\n    onAbort: 'onabort',\n    onActivate: 'onactivate',\n    onAfterPrint: 'onafterprint',\n    onBeforePrint: 'onbeforeprint',\n    onBegin: 'onbegin',\n    onCancel: 'oncancel',\n    onCanPlay: 'oncanplay',\n    onCanPlayThrough: 'oncanplaythrough',\n    onChange: 'onchange',\n    onClick: 'onclick',\n    onClose: 'onclose',\n    onCopy: 'oncopy',\n    onCueChange: 'oncuechange',\n    onCut: 'oncut',\n    onDblClick: 'ondblclick',\n    onDrag: 'ondrag',\n    onDragEnd: 'ondragend',\n    onDragEnter: 'ondragenter',\n    onDragExit: 'ondragexit',\n    onDragLeave: 'ondragleave',\n    onDragOver: 'ondragover',\n    onDragStart: 'ondragstart',\n    onDrop: 'ondrop',\n    onDurationChange: 'ondurationchange',\n    onEmptied: 'onemptied',\n    onEnd: 'onend',\n    onEnded: 'onended',\n    onError: 'onerror',\n    onFocus: 'onfocus',\n    onFocusIn: 'onfocusin',\n    onFocusOut: 'onfocusout',\n    onHashChange: 'onhashchange',\n    onInput: 'oninput',\n    onInvalid: 'oninvalid',\n    onKeyDown: 'onkeydown',\n    onKeyPress: 'onkeypress',\n    onKeyUp: 'onkeyup',\n    onLoad: 'onload',\n    onLoadedData: 'onloadeddata',\n    onLoadedMetadata: 'onloadedmetadata',\n    onLoadStart: 'onloadstart',\n    onMessage: 'onmessage',\n    onMouseDown: 'onmousedown',\n    onMouseEnter: 'onmouseenter',\n    onMouseLeave: 'onmouseleave',\n    onMouseMove: 'onmousemove',\n    onMouseOut: 'onmouseout',\n    onMouseOver: 'onmouseover',\n    onMouseUp: 'onmouseup',\n    onMouseWheel: 'onmousewheel',\n    onOffline: 'onoffline',\n    onOnline: 'ononline',\n    onPageHide: 'onpagehide',\n    onPageShow: 'onpageshow',\n    onPaste: 'onpaste',\n    onPause: 'onpause',\n    onPlay: 'onplay',\n    onPlaying: 'onplaying',\n    onPopState: 'onpopstate',\n    onProgress: 'onprogress',\n    onRateChange: 'onratechange',\n    onRepeat: 'onrepeat',\n    onReset: 'onreset',\n    onResize: 'onresize',\n    onScroll: 'onscroll',\n    onSeeked: 'onseeked',\n    onSeeking: 'onseeking',\n    onSelect: 'onselect',\n    onShow: 'onshow',\n    onStalled: 'onstalled',\n    onStorage: 'onstorage',\n    onSubmit: 'onsubmit',\n    onSuspend: 'onsuspend',\n    onTimeUpdate: 'ontimeupdate',\n    onToggle: 'ontoggle',\n    onUnload: 'onunload',\n    onVolumeChange: 'onvolumechange',\n    onWaiting: 'onwaiting',\n    onZoom: 'onzoom',\n    overlinePosition: 'overline-position',\n    overlineThickness: 'overline-thickness',\n    paintOrder: 'paint-order',\n    panose1: 'panose-1',\n    pointerEvents: 'pointer-events',\n    referrerPolicy: 'referrerpolicy',\n    renderingIntent: 'rendering-intent',\n    shapeRendering: 'shape-rendering',\n    stopColor: 'stop-color',\n    stopOpacity: 'stop-opacity',\n    strikethroughPosition: 'strikethrough-position',\n    strikethroughThickness: 'strikethrough-thickness',\n    strokeDashArray: 'stroke-dasharray',\n    strokeDashOffset: 'stroke-dashoffset',\n    strokeLineCap: 'stroke-linecap',\n    strokeLineJoin: 'stroke-linejoin',\n    strokeMiterLimit: 'stroke-miterlimit',\n    strokeOpacity: 'stroke-opacity',\n    strokeWidth: 'stroke-width',\n    tabIndex: 'tabindex',\n    textAnchor: 'text-anchor',\n    textDecoration: 'text-decoration',\n    textRendering: 'text-rendering',\n    typeOf: 'typeof',\n    underlinePosition: 'underline-position',\n    underlineThickness: 'underline-thickness',\n    unicodeBidi: 'unicode-bidi',\n    unicodeRange: 'unicode-range',\n    unitsPerEm: 'units-per-em',\n    vAlphabetic: 'v-alphabetic',\n    vHanging: 'v-hanging',\n    vIdeographic: 'v-ideographic',\n    vMathematical: 'v-mathematical',\n    vectorEffect: 'vector-effect',\n    vertAdvY: 'vert-adv-y',\n    vertOriginX: 'vert-origin-x',\n    vertOriginY: 'vert-origin-y',\n    wordSpacing: 'word-spacing',\n    writingMode: 'writing-mode',\n    xHeight: 'x-height',\n    // These were camelcased in Tiny. Now lowercased in SVG 2\n    playbackOrder: 'playbackorder',\n    timelineBegin: 'timelinebegin'\n  },\n  transform: caseSensitiveTransform,\n  properties: {\n    about: commaOrSpaceSeparated,\n    accentHeight: number,\n    accumulate: null,\n    additive: null,\n    alignmentBaseline: null,\n    alphabetic: number,\n    amplitude: number,\n    arabicForm: null,\n    ascent: number,\n    attributeName: null,\n    attributeType: null,\n    azimuth: number,\n    bandwidth: null,\n    baselineShift: null,\n    baseFrequency: null,\n    baseProfile: null,\n    bbox: null,\n    begin: null,\n    bias: number,\n    by: null,\n    calcMode: null,\n    capHeight: number,\n    className: spaceSeparated,\n    clip: null,\n    clipPath: null,\n    clipPathUnits: null,\n    clipRule: null,\n    color: null,\n    colorInterpolation: null,\n    colorInterpolationFilters: null,\n    colorProfile: null,\n    colorRendering: null,\n    content: null,\n    contentScriptType: null,\n    contentStyleType: null,\n    crossOrigin: null,\n    cursor: null,\n    cx: null,\n    cy: null,\n    d: null,\n    dataType: null,\n    defaultAction: null,\n    descent: number,\n    diffuseConstant: number,\n    direction: null,\n    display: null,\n    dur: null,\n    divisor: number,\n    dominantBaseline: null,\n    download: boolean,\n    dx: null,\n    dy: null,\n    edgeMode: null,\n    editable: null,\n    elevation: number,\n    enableBackground: null,\n    end: null,\n    event: null,\n    exponent: number,\n    externalResourcesRequired: null,\n    fill: null,\n    fillOpacity: number,\n    fillRule: null,\n    filter: null,\n    filterRes: null,\n    filterUnits: null,\n    floodColor: null,\n    floodOpacity: null,\n    focusable: null,\n    focusHighlight: null,\n    fontFamily: null,\n    fontSize: null,\n    fontSizeAdjust: null,\n    fontStretch: null,\n    fontStyle: null,\n    fontVariant: null,\n    fontWeight: null,\n    format: null,\n    fr: null,\n    from: null,\n    fx: null,\n    fy: null,\n    g1: commaSeparated,\n    g2: commaSeparated,\n    glyphName: commaSeparated,\n    glyphOrientationHorizontal: null,\n    glyphOrientationVertical: null,\n    glyphRef: null,\n    gradientTransform: null,\n    gradientUnits: null,\n    handler: null,\n    hanging: number,\n    hatchContentUnits: null,\n    hatchUnits: null,\n    height: null,\n    href: null,\n    hrefLang: null,\n    horizAdvX: number,\n    horizOriginX: number,\n    horizOriginY: number,\n    id: null,\n    ideographic: number,\n    imageRendering: null,\n    initialVisibility: null,\n    in: null,\n    in2: null,\n    intercept: number,\n    k: number,\n    k1: number,\n    k2: number,\n    k3: number,\n    k4: number,\n    kernelMatrix: commaOrSpaceSeparated,\n    kernelUnitLength: null,\n    keyPoints: null,\n    // SEMI_COLON_SEPARATED\n    keySplines: null,\n    // SEMI_COLON_SEPARATED\n    keyTimes: null,\n    // SEMI_COLON_SEPARATED\n    kerning: null,\n    lang: null,\n    lengthAdjust: null,\n    letterSpacing: null,\n    lightingColor: null,\n    limitingConeAngle: number,\n    local: null,\n    markerEnd: null,\n    markerMid: null,\n    markerStart: null,\n    markerHeight: null,\n    markerUnits: null,\n    markerWidth: null,\n    mask: null,\n    maskContentUnits: null,\n    maskUnits: null,\n    mathematical: null,\n    max: null,\n    media: null,\n    mediaCharacterEncoding: null,\n    mediaContentEncodings: null,\n    mediaSize: number,\n    mediaTime: null,\n    method: null,\n    min: null,\n    mode: null,\n    name: null,\n    navDown: null,\n    navDownLeft: null,\n    navDownRight: null,\n    navLeft: null,\n    navNext: null,\n    navPrev: null,\n    navRight: null,\n    navUp: null,\n    navUpLeft: null,\n    navUpRight: null,\n    numOctaves: null,\n    observer: null,\n    offset: null,\n    onAbort: null,\n    onActivate: null,\n    onAfterPrint: null,\n    onBeforePrint: null,\n    onBegin: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnd: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFocusIn: null,\n    onFocusOut: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onMouseWheel: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRepeat: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onShow: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onZoom: null,\n    opacity: null,\n    operator: null,\n    order: null,\n    orient: null,\n    orientation: null,\n    origin: null,\n    overflow: null,\n    overlay: null,\n    overlinePosition: number,\n    overlineThickness: number,\n    paintOrder: null,\n    panose1: null,\n    path: null,\n    pathLength: number,\n    patternContentUnits: null,\n    patternTransform: null,\n    patternUnits: null,\n    phase: null,\n    ping: spaceSeparated,\n    pitch: null,\n    playbackOrder: null,\n    pointerEvents: null,\n    points: null,\n    pointsAtX: number,\n    pointsAtY: number,\n    pointsAtZ: number,\n    preserveAlpha: null,\n    preserveAspectRatio: null,\n    primitiveUnits: null,\n    propagate: null,\n    property: commaOrSpaceSeparated,\n    r: null,\n    radius: null,\n    referrerPolicy: null,\n    refX: null,\n    refY: null,\n    rel: commaOrSpaceSeparated,\n    rev: commaOrSpaceSeparated,\n    renderingIntent: null,\n    repeatCount: null,\n    repeatDur: null,\n    requiredExtensions: commaOrSpaceSeparated,\n    requiredFeatures: commaOrSpaceSeparated,\n    requiredFonts: commaOrSpaceSeparated,\n    requiredFormats: commaOrSpaceSeparated,\n    resource: null,\n    restart: null,\n    result: null,\n    rotate: null,\n    rx: null,\n    ry: null,\n    scale: null,\n    seed: null,\n    shapeRendering: null,\n    side: null,\n    slope: null,\n    snapshotTime: null,\n    specularConstant: number,\n    specularExponent: number,\n    spreadMethod: null,\n    spacing: null,\n    startOffset: null,\n    stdDeviation: null,\n    stemh: null,\n    stemv: null,\n    stitchTiles: null,\n    stopColor: null,\n    stopOpacity: null,\n    strikethroughPosition: number,\n    strikethroughThickness: number,\n    string: null,\n    stroke: null,\n    strokeDashArray: commaOrSpaceSeparated,\n    strokeDashOffset: null,\n    strokeLineCap: null,\n    strokeLineJoin: null,\n    strokeMiterLimit: number,\n    strokeOpacity: number,\n    strokeWidth: null,\n    style: null,\n    surfaceScale: number,\n    syncBehavior: null,\n    syncBehaviorDefault: null,\n    syncMaster: null,\n    syncTolerance: null,\n    syncToleranceDefault: null,\n    systemLanguage: commaOrSpaceSeparated,\n    tabIndex: number,\n    tableValues: null,\n    target: null,\n    targetX: number,\n    targetY: number,\n    textAnchor: null,\n    textDecoration: null,\n    textRendering: null,\n    textLength: null,\n    timelineBegin: null,\n    title: null,\n    transformBehavior: null,\n    type: null,\n    typeOf: commaOrSpaceSeparated,\n    to: null,\n    transform: null,\n    u1: null,\n    u2: null,\n    underlinePosition: number,\n    underlineThickness: number,\n    unicode: null,\n    unicodeBidi: null,\n    unicodeRange: null,\n    unitsPerEm: number,\n    values: null,\n    vAlphabetic: number,\n    vMathematical: number,\n    vectorEffect: null,\n    vHanging: number,\n    vIdeographic: number,\n    version: null,\n    vertAdvY: number,\n    vertOriginX: number,\n    vertOriginY: number,\n    viewBox: null,\n    viewTarget: null,\n    visibility: null,\n    width: null,\n    widths: null,\n    wordSpacing: null,\n    writingMode: null,\n    x: null,\n    x1: null,\n    x2: null,\n    xChannelSelector: null,\n    xHeight: number,\n    y: null,\n    y1: null,\n    y2: null,\n    yChannelSelector: null,\n    z: null,\n    zoomAndPan: null\n  }\n});"],"sourceRoot":""}